WeixiangYan/CodeTransOcean huggingface dataset:
Task: Write language name in 3D ASCII

C: #include <stdio.h>
const char*s = "  _____\n /____/\\\n/  ___\\/\n\\  \\/__/\n \\____/";
int main(){ puts(s); return 0; }


C++: #include <windows.h>
#include <iostream>


using namespace std;


int main(int argc, char* argv[])
{
	cout << 
		"                        ______          ______  " << endl <<
		"        _____     _____|\\     \\   _____|\\     \\ " << endl <<
		"   _____\\    \\_  /     / |     | /     / |     |" << endl <<
		"  /     /|     ||      |/     /||      |/     /|" << endl <<
		" /     / /____/||      |\\____/ ||      |\\____/ |" << endl <<
		"|     | |____|/ |\\     \\    | / |\\     \\    | / " << endl <<
		"|     |  _____  | \\     \\___|/  | \\     \\___|/  " << endl <<
		"|\\     \\|\\    \\ |  \\     \\      |  \\     \\      " << endl <<
		"| \\_____\\|    |  \\  \\_____\\      \\  \\_____\\     " << endl <<
		"| |     /____/|   \\ |     |       \\ |     |     " << endl <<
		" \\|_____|    ||    \\|_____|        \\|_____|     " << endl <<
		"        |____|/                                 ";

	cout << endl << endl << endl;

	system( "pause" );
	return 0;
}
Task: Write language name in 3D ASCII

C: #include <stdio.h>
const char*s = "  _____\n /____/\\\n/  ___\\/\n\\  \\/__/\n \\____/";
int main(){ puts(s); return 0; }




Go: package main

import (
    "fmt"
    "strings"
)

var lean = font{
    height:  5,
    slant:   1,
    spacing: 2,
    m: map[rune][]string{
        'G': []string{
            `  _/_/_/`,
            `_/      `,
            `_/  _/_/`,
            `_/    _/`,
            `  _/_/_/`,
        },
        'o': []string{
            `        `,
            `  _/_/  `,
            `_/    _/`,
            `_/    _/`,
            `  _/_/  `,
        },
    }}

var smallKeyboard = font{
    height:  4,
    slant:   0,
    spacing: -1,
    m: map[rune][]string{
        'G': []string{
            ` ____ `,
            `||G ||`,
            `||__||`,
            `|/__\|`,
        },
        'o': []string{
            ` ____ `,
            `||o ||`,
            `||__||`,
            `|/__\|`,
        },
    }}

type font struct {
    height  int
    slant   int
    spacing int
    m       map[rune][]string
}

func render(s string, f font) string {
    rows := make([]string, f.height)
    if f.slant != 0 {
        start := 0
        if f.slant > 0 {
            start = f.height
        }
        for i := range rows {
            rows[i] = strings.Repeat(" ", (start-i)*f.slant)
        }
    }
    if f.spacing >= 0 {
        spacing := strings.Repeat(" ", f.spacing)
        for j, c := range s {
            for i, r := range f.m[c] {
                if j > 0 {
                    r = spacing + r
                }
                rows[i] += r
            }
        }
    } else {
        overlap := -f.spacing
        for j, c := range s {
            for i, r := range f.m[c] {
                if j > 0 {
                    r = r[overlap:]
                }
                rows[i] += r
            }
        }
    }
    return strings.Join(rows, "\n")
}

func main() {
    fmt.Println(render("Go", lean))
    fmt.Println(render("Go", smallKeyboard))
}
Task: Write language name in 3D ASCII

C: #include <stdio.h>
const char*s = "  _____\n /____/\\\n/  ___\\/\n\\  \\/__/\n \\____/";
int main(){ puts(s); return 0; }








VB: Module Module1

    Sub Main()
        Console.WriteLine(" ___      ___ ___  ________  ___  ___  ________  ___               ________  ________  ________  ___  ________           ________   _______  _________   
|\  \    /  /|\  \|\   ____\|\  \|\  \|\   __  \|\  \             |\   __  \|\   __  \|\   ____\|\  \|\   ____\         |\   ___  \|\  ___ \|\___   ___\ 
\ \  \  /  / | \  \ \  \___|\ \  \\\  \ \  \|\  \ \  \            \ \  \|\ /\ \  \|\  \ \  \___|\ \  \ \  \___|         \ \  \\ \  \ \   __/\|___ \  \_| 
 \ \  \/  / / \ \  \ \_____  \ \  \\\  \ \   __  \ \  \            \ \   __  \ \   __  \ \_____  \ \  \ \  \             \ \  \\ \  \ \  \_|/__  \ \  \  
  \ \    / /   \ \  \|____|\  \ \  \\\  \ \  \ \  \ \  \____        \ \  \|\  \ \  \ \  \|____|\  \ \  \ \  \____       __\ \  \\ \  \ \  \_|\ \  \ \  \ 
   \ \__/ /     \ \__\____\_\  \ \_______\ \__\ \__\ \_______\       \ \_______\ \__\ \__\____\_\  \ \__\ \_______\    |\__\ \__\\ \__\ \_______\  \ \__\
    \|__|/       \|__|\_________\|_______|\|__|\|__|\|_______|        \|_______|\|__|\|__|\_________\|__|\|_______|    \|__|\|__| \|__|\|_______|   \|__|
                     \|_________|                                                        \|_________|                                                    
                                                                                                                                                         
                                                                                                                                                         
")
    End Sub

End Module
Task: Write language name in 3D ASCII


C++: #include <windows.h>
#include <iostream>


using namespace std;


int main(int argc, char* argv[])
{
	cout << 
		"                        ______          ______  " << endl <<
		"        _____     _____|\\     \\   _____|\\     \\ " << endl <<
		"   _____\\    \\_  /     / |     | /     / |     |" << endl <<
		"  /     /|     ||      |/     /||      |/     /|" << endl <<
		" /     / /____/||      |\\____/ ||      |\\____/ |" << endl <<
		"|     | |____|/ |\\     \\    | / |\\     \\    | / " << endl <<
		"|     |  _____  | \\     \\___|/  | \\     \\___|/  " << endl <<
		"|\\     \\|\\    \\ |  \\     \\      |  \\     \\      " << endl <<
		"| \\_____\\|    |  \\  \\_____\\      \\  \\_____\\     " << endl <<
		"| |     /____/|   \\ |     |       \\ |     |     " << endl <<
		" \\|_____|    ||    \\|_____|        \\|_____|     " << endl <<
		"        |____|/                                 ";

	cout << endl << endl << endl;

	system( "pause" );
	return 0;
}




Go: package main

import (
    "fmt"
    "strings"
)

var lean = font{
    height:  5,
    slant:   1,
    spacing: 2,
    m: map[rune][]string{
        'G': []string{
            `  _/_/_/`,
            `_/      `,
            `_/  _/_/`,
            `_/    _/`,
            `  _/_/_/`,
        },
        'o': []string{
            `        `,
            `  _/_/  `,
            `_/    _/`,
            `_/    _/`,
            `  _/_/  `,
        },
    }}

var smallKeyboard = font{
    height:  4,
    slant:   0,
    spacing: -1,
    m: map[rune][]string{
        'G': []string{
            ` ____ `,
            `||G ||`,
            `||__||`,
            `|/__\|`,
        },
        'o': []string{
            ` ____ `,
            `||o ||`,
            `||__||`,
            `|/__\|`,
        },
    }}

type font struct {
    height  int
    slant   int
    spacing int
    m       map[rune][]string
}

func render(s string, f font) string {
    rows := make([]string, f.height)
    if f.slant != 0 {
        start := 0
        if f.slant > 0 {
            start = f.height
        }
        for i := range rows {
            rows[i] = strings.Repeat(" ", (start-i)*f.slant)
        }
    }
    if f.spacing >= 0 {
        spacing := strings.Repeat(" ", f.spacing)
        for j, c := range s {
            for i, r := range f.m[c] {
                if j > 0 {
                    r = spacing + r
                }
                rows[i] += r
            }
        }
    } else {
        overlap := -f.spacing
        for j, c := range s {
            for i, r := range f.m[c] {
                if j > 0 {
                    r = r[overlap:]
                }
                rows[i] += r
            }
        }
    }
    return strings.Join(rows, "\n")
}

func main() {
    fmt.Println(render("Go", lean))
    fmt.Println(render("Go", smallKeyboard))
}
Task: Write language name in 3D ASCII


C++: #include <windows.h>
#include <iostream>


using namespace std;


int main(int argc, char* argv[])
{
	cout << 
		"                        ______          ______  " << endl <<
		"        _____     _____|\\     \\   _____|\\     \\ " << endl <<
		"   _____\\    \\_  /     / |     | /     / |     |" << endl <<
		"  /     /|     ||      |/     /||      |/     /|" << endl <<
		" /     / /____/||      |\\____/ ||      |\\____/ |" << endl <<
		"|     | |____|/ |\\     \\    | / |\\     \\    | / " << endl <<
		"|     |  _____  | \\     \\___|/  | \\     \\___|/  " << endl <<
		"|\\     \\|\\    \\ |  \\     \\      |  \\     \\      " << endl <<
		"| \\_____\\|    |  \\  \\_____\\      \\  \\_____\\     " << endl <<
		"| |     /____/|   \\ |     |       \\ |     |     " << endl <<
		" \\|_____|    ||    \\|_____|        \\|_____|     " << endl <<
		"        |____|/                                 ";

	cout << endl << endl << endl;

	system( "pause" );
	return 0;
}







Python: py = '''\
 
 
 
 
 

lines = py.replace('
        .replace('X', '   ').replace('\n', ' Y') \
        .replace('< ', '<>').split('Y')

for i, l in enumerate(lines): 
    print('  ' * (len(lines) - i) + l)
Task: Write language name in 3D ASCII


C++: #include <windows.h>
#include <iostream>


using namespace std;


int main(int argc, char* argv[])
{
	cout << 
		"                        ______          ______  " << endl <<
		"        _____     _____|\\     \\   _____|\\     \\ " << endl <<
		"   _____\\    \\_  /     / |     | /     / |     |" << endl <<
		"  /     /|     ||      |/     /||      |/     /|" << endl <<
		" /     / /____/||      |\\____/ ||      |\\____/ |" << endl <<
		"|     | |____|/ |\\     \\    | / |\\     \\    | / " << endl <<
		"|     |  _____  | \\     \\___|/  | \\     \\___|/  " << endl <<
		"|\\     \\|\\    \\ |  \\     \\      |  \\     \\      " << endl <<
		"| \\_____\\|    |  \\  \\_____\\      \\  \\_____\\     " << endl <<
		"| |     /____/|   \\ |     |       \\ |     |     " << endl <<
		" \\|_____|    ||    \\|_____|        \\|_____|     " << endl <<
		"        |____|/                                 ";

	cout << endl << endl << endl;

	system( "pause" );
	return 0;
}








VB: Module Module1

    Sub Main()
        Console.WriteLine(" ___      ___ ___  ________  ___  ___  ________  ___               ________  ________  ________  ___  ________           ________   _______  _________   
|\  \    /  /|\  \|\   ____\|\  \|\  \|\   __  \|\  \             |\   __  \|\   __  \|\   ____\|\  \|\   ____\         |\   ___  \|\  ___ \|\___   ___\ 
\ \  \  /  / | \  \ \  \___|\ \  \\\  \ \  \|\  \ \  \            \ \  \|\ /\ \  \|\  \ \  \___|\ \  \ \  \___|         \ \  \\ \  \ \   __/\|___ \  \_| 
 \ \  \/  / / \ \  \ \_____  \ \  \\\  \ \   __  \ \  \            \ \   __  \ \   __  \ \_____  \ \  \ \  \             \ \  \\ \  \ \  \_|/__  \ \  \  
  \ \    / /   \ \  \|____|\  \ \  \\\  \ \  \ \  \ \  \____        \ \  \|\  \ \  \ \  \|____|\  \ \  \ \  \____       __\ \  \\ \  \ \  \_|\ \  \ \  \ 
   \ \__/ /     \ \__\____\_\  \ \_______\ \__\ \__\ \_______\       \ \_______\ \__\ \__\____\_\  \ \__\ \_______\    |\__\ \__\\ \__\ \_______\  \ \__\
    \|__|/       \|__|\_________\|_______|\|__|\|__|\|_______|        \|_______|\|__|\|__|\_________\|__|\|_______|    \|__|\|__| \|__|\|_______|   \|__|
                     \|_________|                                                        \|_________|                                                    
                                                                                                                                                         
                                                                                                                                                         
")
    End Sub

End Module
Task: Write language name in 3D ASCII




Go: package main

import (
    "fmt"
    "strings"
)

var lean = font{
    height:  5,
    slant:   1,
    spacing: 2,
    m: map[rune][]string{
        'G': []string{
            `  _/_/_/`,
            `_/      `,
            `_/  _/_/`,
            `_/    _/`,
            `  _/_/_/`,
        },
        'o': []string{
            `        `,
            `  _/_/  `,
            `_/    _/`,
            `_/    _/`,
            `  _/_/  `,
        },
    }}

var smallKeyboard = font{
    height:  4,
    slant:   0,
    spacing: -1,
    m: map[rune][]string{
        'G': []string{
            ` ____ `,
            `||G ||`,
            `||__||`,
            `|/__\|`,
        },
        'o': []string{
            ` ____ `,
            `||o ||`,
            `||__||`,
            `|/__\|`,
        },
    }}

type font struct {
    height  int
    slant   int
    spacing int
    m       map[rune][]string
}

func render(s string, f font) string {
    rows := make([]string, f.height)
    if f.slant != 0 {
        start := 0
        if f.slant > 0 {
            start = f.height
        }
        for i := range rows {
            rows[i] = strings.Repeat(" ", (start-i)*f.slant)
        }
    }
    if f.spacing >= 0 {
        spacing := strings.Repeat(" ", f.spacing)
        for j, c := range s {
            for i, r := range f.m[c] {
                if j > 0 {
                    r = spacing + r
                }
                rows[i] += r
            }
        }
    } else {
        overlap := -f.spacing
        for j, c := range s {
            for i, r := range f.m[c] {
                if j > 0 {
                    r = r[overlap:]
                }
                rows[i] += r
            }
        }
    }
    return strings.Join(rows, "\n")
}

func main() {
    fmt.Println(render("Go", lean))
    fmt.Println(render("Go", smallKeyboard))
}




Python: py = '''\
 
 
 
 
 

lines = py.replace('
        .replace('X', '   ').replace('\n', ' Y') \
        .replace('< ', '<>').split('Y')

for i, l in enumerate(lines): 
    print('  ' * (len(lines) - i) + l)
Task: Write language name in 3D ASCII







Python: py = '''\
 
 
 
 
 

lines = py.replace('
        .replace('X', '   ').replace('\n', ' Y') \
        .replace('< ', '<>').split('Y')

for i, l in enumerate(lines): 
    print('  ' * (len(lines) - i) + l)


VB: Module Module1

    Sub Main()
        Console.WriteLine(" ___      ___ ___  ________  ___  ___  ________  ___               ________  ________  ________  ___  ________           ________   _______  _________   
|\  \    /  /|\  \|\   ____\|\  \|\  \|\   __  \|\  \             |\   __  \|\   __  \|\   ____\|\  \|\   ____\         |\   ___  \|\  ___ \|\___   ___\ 
\ \  \  /  / | \  \ \  \___|\ \  \\\  \ \  \|\  \ \  \            \ \  \|\ /\ \  \|\  \ \  \___|\ \  \ \  \___|         \ \  \\ \  \ \   __/\|___ \  \_| 
 \ \  \/  / / \ \  \ \_____  \ \  \\\  \ \   __  \ \  \            \ \   __  \ \   __  \ \_____  \ \  \ \  \             \ \  \\ \  \ \  \_|/__  \ \  \  
  \ \    / /   \ \  \|____|\  \ \  \\\  \ \  \ \  \ \  \____        \ \  \|\  \ \  \ \  \|____|\  \ \  \ \  \____       __\ \  \\ \  \ \  \_|\ \  \ \  \ 
   \ \__/ /     \ \__\____\_\  \ \_______\ \__\ \__\ \_______\       \ \_______\ \__\ \__\____\_\  \ \__\ \_______\    |\__\ \__\\ \__\ \_______\  \ \__\
    \|__|/       \|__|\_________\|_______|\|__|\|__|\|_______|        \|_______|\|__|\|__|\_________\|__|\|_______|    \|__|\|__| \|__|\|_______|   \|__|
                     \|_________|                                                        \|_________|                                                    
                                                                                                                                                         
                                                                                                                                                         
")
    End Sub

End Module
Task: Write language name in 3D ASCII

C: #include <stdio.h>
const char*s = "  _____\n /____/\\\n/  ___\\/\n\\  \\/__/\n \\____/";
int main(){ puts(s); return 0; }







Python: py = '''\
 
 
 
 
 

lines = py.replace('
        .replace('X', '   ').replace('\n', ' Y') \
        .replace('< ', '<>').split('Y')

for i, l in enumerate(lines): 
    print('  ' * (len(lines) - i) + l)
Task: Element-wise operations

C: #include <math.h>

#define for_i for(i = 0; i < h; i++)
#define for_j for(j = 0; j < w; j++)
#define _M double**
#define OPM(name, _op_) \
	void eop_##name(_M a, _M b, _M c, int w, int h){int i,j;\
		for_i for_j c[i][j] = a[i][j] _op_ b[i][j];}
OPM(add, +);OPM(sub, -);OPM(mul, *);OPM(div, /);

#define OPS(name, res) \
	void eop_s_##name(_M a, double s, _M b, int w, int h) {double x;int i,j;\
		for_i for_j {x = a[i][j]; b[i][j] = res;}}
OPS(mul, x*s);OPS(div, x/s);OPS(add, x+s);OPS(sub, x-s);OPS(pow, pow(x, s));




Go: package element

import (
    "fmt"
    "math"
)

type Matrix struct {
    ele    []float64
    stride int
}

func MatrixFromRows(rows [][]float64) Matrix {
    if len(rows) == 0 {
        return Matrix{nil, 0}
    }
    m := Matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])}
    for rx, row := range rows {
        copy(m.ele[rx*m.stride:(rx+1)*m.stride], row)
    }
    return m
}

func like(m Matrix) Matrix {
    return Matrix{make([]float64, len(m.ele)), m.stride}
}

func (m Matrix) String() string {
    s := ""
    for e := 0; e < len(m.ele); e += m.stride {
        s += fmt.Sprintf("%6.3f \n", m.ele[e:e+m.stride])
    }
    return s
}

type binaryFunc64 func(float64, float64) float64

func elementWiseMM(m1, m2 Matrix, f binaryFunc64) Matrix {
    z := like(m1)
    for i, m1e := range m1.ele {
        z.ele[i] = f(m1e, m2.ele[i])
    }
    return z
}

func elementWiseMS(m Matrix, s float64, f binaryFunc64) Matrix {
    z := like(m)
    for i, e := range m.ele {
        z.ele[i] = f(e, s)
    }
    return z
}

func add(a, b float64) float64 { return a + b }
func sub(a, b float64) float64 { return a - b }
func mul(a, b float64) float64 { return a * b }
func div(a, b float64) float64 { return a / b }
func exp(a, b float64) float64 { return math.Pow(a, b) }

func AddMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, add) }
func SubMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, sub) }
func MulMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, mul) }
func DivMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, div) }
func ExpMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, exp) }

func AddScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, add) }
func SubScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, sub) }
func MulScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, mul) }
func DivScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, div) }
func ExpScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, exp) }
Task: Element-wise operations

C: #include <math.h>

#define for_i for(i = 0; i < h; i++)
#define for_j for(j = 0; j < w; j++)
#define _M double**
#define OPM(name, _op_) \
	void eop_##name(_M a, _M b, _M c, int w, int h){int i,j;\
		for_i for_j c[i][j] = a[i][j] _op_ b[i][j];}
OPM(add, +);OPM(sub, -);OPM(mul, *);OPM(div, /);

#define OPS(name, res) \
	void eop_s_##name(_M a, double s, _M b, int w, int h) {double x;int i,j;\
		for_i for_j {x = a[i][j]; b[i][j] = res;}}
OPS(mul, x*s);OPS(div, x/s);OPS(add, x+s);OPS(sub, x-s);OPS(pow, pow(x, s));





Java: import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.stream.Stream;

@SuppressWarnings("serial")
public class ElementWiseOp {
	static final Map<String, BiFunction<Double, Double, Double>> OPERATIONS = new HashMap<String, BiFunction<Double, Double, Double>>() {
		{
			put("add", (a, b) -> a + b);
			put("sub", (a, b) -> a - b);
			put("mul", (a, b) -> a * b);
			put("div", (a, b) -> a / b);
			put("pow", (a, b) -> Math.pow(a, b));
			put("mod", (a, b) -> a % b);
		}
	};
	public static Double[][] scalarOp(String op, Double[][] matr, Double scalar) {
		BiFunction<Double, Double, Double> operation = OPERATIONS.getOrDefault(op, (a, b) -> a);
		Double[][] result = new Double[matr.length][matr[0].length];
		for (int i = 0; i < matr.length; i++) {
			for (int j = 0; j < matr[i].length; j++) {
				result[i][j] = operation.apply(matr[i][j], scalar);
			}
		}
		return result;
	}
	public static Double[][] matrOp(String op, Double[][] matr, Double[][] scalar) {
		BiFunction<Double, Double, Double> operation = OPERATIONS.getOrDefault(op, (a, b) -> a);
		Double[][] result = new Double[matr.length][Stream.of(matr).mapToInt(a -> a.length).max().getAsInt()];
		for (int i = 0; i < matr.length; i++) {
			for (int j = 0; j < matr[i].length; j++) {
				result[i][j] = operation.apply(matr[i][j], scalar[i % scalar.length][j
						% scalar[i % scalar.length].length]);
			}
		}
		return result;
	}
	public static void printMatrix(Double[][] matr) {
		Stream.of(matr).map(Arrays::toString).forEach(System.out::println);
	}
	public static void main(String[] args) {
		printMatrix(scalarOp("mul", new Double[][] {
				{ 1.0, 2.0, 3.0 }, 
				{ 4.0, 5.0, 6.0 }, 
				{ 7.0, 8.0, 9.0 }
		}, 3.0));

		printMatrix(matrOp("div", new Double[][] {
				{ 1.0, 2.0, 3.0 }, 
				{ 4.0, 5.0, 6.0 }, 
				{ 7.0, 8.0, 9.0 }
		}, new Double[][] {
				{ 1.0, 2.0}, 
				{ 3.0, 4.0} 
		}));
	}
}
Task: Element-wise operations

C: #include <math.h>

#define for_i for(i = 0; i < h; i++)
#define for_j for(j = 0; j < w; j++)
#define _M double**
#define OPM(name, _op_) \
	void eop_##name(_M a, _M b, _M c, int w, int h){int i,j;\
		for_i for_j c[i][j] = a[i][j] _op_ b[i][j];}
OPM(add, +);OPM(sub, -);OPM(mul, *);OPM(div, /);

#define OPS(name, res) \
	void eop_s_##name(_M a, double s, _M b, int w, int h) {double x;int i,j;\
		for_i for_j {x = a[i][j]; b[i][j] = res;}}
OPS(mul, x*s);OPS(div, x/s);OPS(add, x+s);OPS(sub, x-s);OPS(pow, pow(x, s));







Python: >>> import random
>>> from operator import add, sub, mul, floordiv
>>> from pprint import pprint as pp
>>> 
>>> def ewise(matrix1, matrix2, op):
	return [[op(e1,e2) for e1,e2 in zip(row1, row2)] for row1,row2 in zip(matrix1, matrix2)]

>>> m,n = 3,4 	
>>> a0 = [[random.randint(1,9) for y in range(n)] for x in range(m)]
>>> a1 = [[random.randint(1,9) for y in range(n)] for x in range(m)]
>>> pp(a0); pp(a1)
[[7, 8, 7, 4], [4, 9, 4, 1], [2, 3, 6, 4]]
[[4, 5, 1, 6], [6, 8, 3, 4], [2, 2, 6, 3]]
>>> pp(ewise(a0, a1, add))
[[11, 13, 8, 10], [10, 17, 7, 5], [4, 5, 12, 7]]
>>> pp(ewise(a0, a1, sub))
[[3, 3, 6, -2], [-2, 1, 1, -3], [0, 1, 0, 1]]
>>> pp(ewise(a0, a1, mul))
[[28, 40, 7, 24], [24, 72, 12, 4], [4, 6, 36, 12]]
>>> pp(ewise(a0, a1, floordiv))
[[1, 1, 7, 0], [0, 1, 1, 0], [1, 1, 1, 1]]
>>> pp(ewise(a0, a1, pow))
[[2401, 32768, 7, 4096], [4096, 43046721, 64, 1], [4, 9, 46656, 64]]
>>> pp(ewise(a0, a1, lambda x, y:2*x - y))
[[10, 11, 13, 2], [2, 10, 5, -2], [2, 4, 6, 5]]
>>> 
>>> def s_ewise(scalar1, matrix1, op):
	return [[op(scalar1, e1) for e1 in row1] for row1 in matrix1]

>>> scalar = 10
>>> a0
[[7, 8, 7, 4], [4, 9, 4, 1], [2, 3, 6, 4]]
>>> for op in ( add, sub, mul, floordiv, pow, lambda x, y:2*x - y ):
	print("%10s :" % op.__name__, s_ewise(scalar, a0, op))

	
       add : [[17, 18, 17, 14], [14, 19, 14, 11], [12, 13, 16, 14]]
       sub : [[3, 2, 3, 6], [6, 1, 6, 9], [8, 7, 4, 6]]
       mul : [[70, 80, 70, 40], [40, 90, 40, 10], [20, 30, 60, 40]]
  floordiv : [[1, 1, 1, 2], [2, 1, 2, 10], [5, 3, 1, 2]]
       pow : [[10000000, 100000000, 10000000, 10000], [10000, 1000000000, 10000, 10], [100, 1000, 1000000, 10000]]
  <lambda> : [[13, 12, 13, 16], [16, 11, 16, 19], [18, 17, 14, 16]]
>>>