// Copyright (c) 2019 by the SciSharp Team

// Code generated by CodeMinion: https://github.com/SciSharp/CodeMinion

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using Numpy.Models;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using Assert = NUnit.Framework.Assert;

namespace Numpy.UnitTest

{

[TestClass]

public class NumPy_array_creationTest : BaseTestCase

{

[TestMethod]

public void emptyTest()

{

var given = np.empty(new Shape(2, 2), np.int32);

Assert.IsTrue(given.repr.StartsWith("array([["));

Assert.IsTrue(given.repr.EndsWith("]])"));

}

[TestMethod]

public void empty_likeTest()

{

var a = new[,] { { 1, 2, 3 }, { 4, 5, 6 } };

var given = np.empty_like(a);

Assert.AreEqual(new Shape(2, 3), given.shape);

Assert.AreEqual(np.int32, given.dtype);

var b = np.array(new[,] { { 1f, 2f, 3f }, { 4f, 5f, 6f } });

var c = np.empty_like(b);

Assert.AreEqual(new Shape(2, 3), c.shape);

Assert.AreEqual(np.float32, c.dtype);

}

[TestMethod]

public void eyeTest()

{

// >>> np.eye(2, dtype=int)

// array([[1, 0],

// [0, 1]])

// >>> np.eye(3, k=1)

// array([[ 0., 1., 0.],

// [ 0., 0., 1.],

// [ 0., 0., 0.]])

//

var given = np.eye(2, dtype: np.int_);

var expected =

"array([[1, 0],\n" +

" [0, 1]])";

Assert.AreEqual(expected, given.repr);

given = np.eye(3, k: 1);

expected =

"array([[0., 1., 0.],\n" +

" [0., 0., 1.],\n" +

" [0., 0., 0.]])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void identityTest()

{

// >>> np.identity(3)

// array([[ 1., 0., 0.],

// [ 0., 1., 0.],

// [ 0., 0., 1.]])

//

var given = np.identity(3);

var expected =

"array([[1., 0., 0.],\n" +

" [0., 1., 0.],\n" +

" [0., 0., 1.]])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void onesTest()

{

// >>> np.ones(5)

// array([ 1., 1., 1., 1., 1.])

//

var given = np.ones(5);

var expected =

"array([1., 1., 1., 1., 1.])";

Assert.AreEqual(expected, given.repr);

// >>> np.ones((5,), dtype=int)

// array([1, 1, 1, 1, 1])

//

given = np.ones(new Shape(5), dtype: np.int_);

expected =

"array([1, 1, 1, 1, 1])";

Assert.AreEqual(expected, given.repr);

// >>> np.ones((2, 1))

// array([[ 1.],

// [ 1.]])

//

given = np.ones(new Shape(2, 1));

expected =

"array([[1.],\n" +

" [1.]])";

Assert.AreEqual(expected, given.repr);

// >>> s = (2,2)

// >>> np.ones(s)

// array([[ 1., 1.],

// [ 1., 1.]])

//

var s = new Shape(2, 2);

given = np.ones(s);

expected =

"array([[1., 1.],\n" +

" [1., 1.]])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void ones_likeTest()

{

// >>> x = np.arange(6)

// >>> x = x.reshape((2, 3))

// >>> x

// array([[0, 1, 2],

// [3, 4, 5]])

// >>> np.ones_like(x)

// array([[1, 1, 1],

// [1, 1, 1]])

//

var x = np.arange(6);

x = x.reshape(2, 3);

var given = x;

var expected =

"array([[0, 1, 2],\n" +

" [3, 4, 5]])";

Assert.AreEqual(expected, given.repr);

given = np.ones_like(x);

expected =

"array([[1, 1, 1],\n" +

" [1, 1, 1]])";

Assert.AreEqual(expected, given.repr);

// >>> y = np.arange(3, dtype=float)

// >>> y

// array([ 0., 1., 2.])

// >>> np.ones_like(y)

// array([ 1., 1., 1.])

//

var y = np.arange(3, dtype: np.float_);

given = y;

expected =

"array([0., 1., 2.])";

Assert.AreEqual(expected, given.repr);

given = np.ones_like(y);

expected =

"array([1., 1., 1.])";

Assert.AreEqual(expected, given.repr);

}

[TestMethod]

public void zerosTest()

{

// >>> np.zeros(5)

// array([ 0., 0., 0., 0., 0.])

//

var given = np.zeros(5);

var expected =

"array([0., 0., 0., 0., 0.])";

Assert.AreEqual(expected, given.repr);

// >>> np.zeros((5,), dtype=int)

// array([0, 0, 0, 0, 0])

//

#if TODO

given= np.zeros((5,), dtype=int);

expected=

"array([0, 0, 0, 0, 0])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.zeros((2, 1))

// array([[ 0.],

// [ 0.]])

//

#if TODO

given= np.zeros((2, 1));

expected=

"array([[ 0.],\n" +

" [ 0.]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> s = (2,2)

// >>> np.zeros(s)

// array([[ 0., 0.],

// [ 0., 0.]])

//

#if TODO

given= s = (2,2);

given= np.zeros(s);

expected=

"array([[ 0., 0.],\n" +

" [ 0., 0.]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype

// array([(0, 0), (0, 0)],

// dtype=[('x', '<i4'), ('y', '<i4')])

//

#if TODO

given= np.zeros((2,), dtype={('x', 'i4'), ('y', 'i4')}) # custom dtype;

expected=

"array([(0, 0), (0, 0)],\n" +

" dtype=[('x', '<i4'), ('y', '<i4')])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void zeros_likeTest()

{

// >>> x = np.arange(6)

// >>> x = x.reshape((2, 3))

// >>> x

// array([[0, 1, 2],

// [3, 4, 5]])

// >>> np.zeros_like(x)

// array([[0, 0, 0],

// [0, 0, 0]])

//

#if TODO

var given= x = np.arange(6);

given= x = x.reshape((2, 3));

given= x;

var expected=

"array([[0, 1, 2],\n" +

" [3, 4, 5]])";

Assert.AreEqual(expected, given.repr);

given= np.zeros_like(x);

expected=

"array([[0, 0, 0],\n" +

" [0, 0, 0]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> y = np.arange(3, dtype=float)

// >>> y

// array([ 0., 1., 2.])

// >>> np.zeros_like(y)

// array([ 0., 0., 0.])

//

#if TODO

given= y = np.arange(3, dtype=float);

given= y;

expected=

"array([ 0., 1., 2.])";

Assert.AreEqual(expected, given.repr);

given= np.zeros_like(y);

expected=

"array([ 0., 0., 0.])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fullTest()

{

// >>> np.full((2, 2), np.inf)

// array([[ inf, inf],

// [ inf, inf]])

// >>> np.full((2, 2), 10)

// array([[10, 10],

// [10, 10]])

//

#if TODO

var given= np.full((2, 2), np.inf);

var expected=

"array([[ inf, inf],\n" +

" [ inf, inf]])";

Assert.AreEqual(expected, given.repr);

given= np.full((2, 2), 10);

expected=

"array([[10, 10],\n" +

" [10, 10]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void full_likeTest()

{

// >>> x = np.arange(6, dtype=int)

// >>> np.full_like(x, 1)

// array([1, 1, 1, 1, 1, 1])

// >>> np.full_like(x, 0.1)

// array([0, 0, 0, 0, 0, 0])

// >>> np.full_like(x, 0.1, dtype=np.double)

// array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

// >>> np.full_like(x, np.nan, dtype=np.double)

// array([ nan, nan, nan, nan, nan, nan])

//

#if TODO

var given= x = np.arange(6, dtype=int);

given= np.full_like(x, 1);

var expected=

"array([1, 1, 1, 1, 1, 1])";

Assert.AreEqual(expected, given.repr);

given= np.full_like(x, 0.1);

expected=

"array([0, 0, 0, 0, 0, 0])";

Assert.AreEqual(expected, given.repr);

given= np.full_like(x, 0.1, dtype=np.double);

expected=

"array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])";

Assert.AreEqual(expected, given.repr);

given= np.full_like(x, np.nan, dtype=np.double);

expected=

"array([ nan, nan, nan, nan, nan, nan])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> y = np.arange(6, dtype=np.double)

// >>> np.full_like(y, 0.1)

// array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

//

#if TODO

given= y = np.arange(6, dtype=np.double);

given= np.full_like(y, 0.1);

expected=

"array([ 0.1, 0.1, 0.1, 0.1, 0.1, 0.1])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void arrayTest()

{

// >>> np.array([1, 2, 3])

// array([1, 2, 3])

//

#if TODO

var given= np.array({1, 2, 3});

var expected=

"array([1, 2, 3])";

Assert.AreEqual(expected, given.repr);

#endif

// Upcasting:

// >>> np.array([1, 2, 3.0])

// array([ 1., 2., 3.])

//

#if TODO

given= np.array({1, 2, 3.0});

expected=

"array([ 1., 2., 3.])";

Assert.AreEqual(expected, given.repr);

#endif

// More than one dimension:

// >>> np.array([[1, 2], [3, 4]])

// array([[1, 2],

// [3, 4]])

//

#if TODO

given= np.array({{1, 2}, {3, 4}});

expected=

"array([[1, 2],\n" +

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

// Minimum dimensions 2:

// >>> np.array([1, 2, 3], ndmin=2)

// array([[1, 2, 3]])

//

#if TODO

given= np.array({1, 2, 3}, ndmin=2);

expected=

"array([[1, 2, 3]])";

Assert.AreEqual(expected, given.repr);

#endif

// Type provided:

// >>> np.array([1, 2, 3], dtype=complex)

// array([ 1.+0.j, 2.+0.j, 3.+0.j])

//

#if TODO

given= np.array({1, 2, 3}, dtype=complex);

expected=

"array([ 1.+0.j, 2.+0.j, 3.+0.j])";

Assert.AreEqual(expected, given.repr);

#endif

// Data-type consisting of more than one element:

// >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])

// >>> x['a']

// array([1, 3])

//

#if TODO

given= x = np.array({(1,2),(3,4)},dtype={('a','<i4'),('b','<i4')});

given= x['a'];

expected=

"array([1, 3])";

Assert.AreEqual(expected, given.repr);

#endif

// Creating an array from sub-classes:

// >>> np.array(np.mat('1 2; 3 4'))

// array([[1, 2],

// [3, 4]])

//

#if TODO

given= np.array(np.mat('1 2; 3 4'));

expected=

"array([[1, 2],\n" +

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.array(np.mat('1 2; 3 4'), subok=True)

// matrix([[1, 2],

// [3, 4]])

//

#if TODO

given= np.array(np.mat('1 2; 3 4'), subok=True);

expected=

"matrix([[1, 2],\n" +

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void asarrayTest()

{

// Convert a list into an array:

// >>> a = [1, 2]

// >>> np.asarray(a)

// array([1, 2])

//

#if TODO

var given= a = [1, 2];

given= np.asarray(a);

var expected=

"array([1, 2])";

Assert.AreEqual(expected, given.repr);

#endif

// Existing arrays are not copied:

// >>> a = np.array([1, 2])

// >>> np.asarray(a) is a

// True

//

#if TODO

given= a = np.array({1, 2});

given= np.asarray(a) is a;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

// If dtype is set, array is copied only if dtype does not match:

// >>> a = np.array([1, 2], dtype=np.float32)

// >>> np.asarray(a, dtype=np.float32) is a

// True

// >>> np.asarray(a, dtype=np.float64) is a

// False

//

#if TODO

given= a = np.array({1, 2}, dtype=np.float32);

given= np.asarray(a, dtype=np.float32) is a;

expected=

"True";

Assert.AreEqual(expected, given.repr);

given= np.asarray(a, dtype=np.float64) is a;

expected=

"False";

Assert.AreEqual(expected, given.repr);

#endif

// Contrary to asanyarray, ndarray subclasses are not passed through:

// >>> issubclass(np.recarray, np.ndarray)

// True

// >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)

// >>> np.asarray(a) is a

// False

// >>> np.asanyarray(a) is a

// True

//

#if TODO

given= issubclass(np.recarray, np.ndarray);

expected=

"True";

Assert.AreEqual(expected, given.repr);

given= a = np.array({(1.0, 2), (3.0, 4)}, dtype='f4,i4').view(np.recarray);

given= np.asarray(a) is a;

expected=

"False";

Assert.AreEqual(expected, given.repr);

given= np.asanyarray(a) is a;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void asanyarrayTest()

{

// Convert a list into an array:

// >>> a = [1, 2]

// >>> np.asanyarray(a)

// array([1, 2])

//

#if TODO

var given= a = [1, 2];

given= np.asanyarray(a);

var expected=

"array([1, 2])";

Assert.AreEqual(expected, given.repr);

#endif

// Instances of ndarray subclasses are passed through as-is:

// >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)

// >>> np.asanyarray(a) is a

// True

//

#if TODO

given= a = np.array({(1.0, 2), (3.0, 4)}, dtype='f4,i4').view(np.recarray);

given= np.asanyarray(a) is a;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void ascontiguousarrayTest()

{

// >>> x = np.arange(6).reshape(2,3)

// >>> np.ascontiguousarray(x, dtype=np.float32)

// array([[ 0., 1., 2.],

// [ 3., 4., 5.]], dtype=float32)

// >>> x.flags['C_CONTIGUOUS']

// True

//

#if TODO

var given= x = np.arange(6).reshape(2,3);

given= np.ascontiguousarray(x, dtype=np.float32);

var expected=

"array([[ 0., 1., 2.],\n" +

" [ 3., 4., 5.]], dtype=float32)";

Assert.AreEqual(expected, given.repr);

given= x.flags['C_CONTIGUOUS'];

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

// Note: This function returns an array with at least one-dimension (1-d)

// so it will not preserve 0-d arrays.

}

[TestMethod]

public void asmatrixTest()

{

// >>> x = np.array([[1, 2], [3, 4]])

//

#if TODO

var given= x = np.array({{1, 2}, {3, 4}});

#endif

// >>> m = np.asmatrix(x)

//

#if TODO

given= m = np.asmatrix(x);

#endif

// >>> x[0,0] = 5

//

#if TODO

given= x[0,0] = 5;

#endif

// >>> m

// matrix([[5, 2],

// [3, 4]])

//

#if TODO

given= m;

var expected=

"matrix([[5, 2],\n" +

" [3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void copyTest()

{

// Create an array x, with a reference y and a copy z:

// >>> x = np.array([1, 2, 3])

// >>> y = x

// >>> z = np.copy(x)

//

#if TODO

var given= x = np.array({1, 2, 3});

given= y = x;

given= z = np.copy(x);

#endif

// Note that, when we modify x, y changes, but not z:

// >>> x[0] = 10

// >>> x[0] == y[0]

// True

// >>> x[0] == z[0]

// False

//

#if TODO

given= x[0] = 10;

given= x[0] == y[0];

var expected=

"True";

Assert.AreEqual(expected, given.repr);

given= x[0] == z[0];

expected=

"False";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void frombufferTest()

{

// >>> s = 'hello world'

// >>> np.frombuffer(s, dtype='S1', count=5, offset=6)

// array(['w', 'o', 'r', 'l', 'd'],

// dtype='|S1')

//

#if TODO

var given= s = 'hello world';

given= np.frombuffer(s, dtype='S1', count=5, offset=6);

var expected=

"array(['w', 'o', 'r', 'l', 'd'],\n" +

" dtype='|S1')";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.frombuffer(b'\x01\x02', dtype=np.uint8)

// array([1, 2], dtype=uint8)

// >>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3)

// array([1, 2, 3], dtype=uint8)

//

#if TODO

given= np.frombuffer(b'\x01\x02', dtype=np.uint8);

expected=

"array([1, 2], dtype=uint8)";

Assert.AreEqual(expected, given.repr);

given= np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3);

expected=

"array([1, 2, 3], dtype=uint8)";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fromfileTest()

{

// Construct an ndarray:

// >>> dt = np.dtype([('time', [('min', int), ('sec', int)]),

// ... ('temp', float)])

// >>> x = np.zeros((1,), dtype=dt)

// >>> x['time']['min'] = 10; x['temp'] = 98.25

// >>> x

// array([((10, 0), 98.25)],

// dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])

//

#if TODO

var given= dt = np.dtype({('time', {('min', int), ('sec', int)}),;

var expected=

"... ('temp', float)])";

Assert.AreEqual(expected, given.repr);

given= x = np.zeros((1,), dtype=dt);

given= x['time']['min'] = 10; x['temp'] = 98.25;

given= x;

expected=

"array([((10, 0), 98.25)],\n" +

" dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])";

Assert.AreEqual(expected, given.repr);

#endif

// Save the raw data to disk:

// >>> import os

// >>> fname = os.tmpnam()

// >>> x.tofile(fname)

//

#if TODO

given= import os;

given= fname = os.tmpnam();

given= x.tofile(fname);

#endif

// Read the raw data from disk:

// >>> np.fromfile(fname, dtype=dt)

// array([((10, 0), 98.25)],

// dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])

//

#if TODO

given= np.fromfile(fname, dtype=dt);

expected=

"array([((10, 0), 98.25)],\n" +

" dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])";

Assert.AreEqual(expected, given.repr);

#endif

// The recommended way to store and load data:

// >>> np.save(fname, x)

// >>> np.load(fname + '.npy')

// array([((10, 0), 98.25)],

// dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])

//

#if TODO

given= np.save(fname, x);

given= np.load(fname + '.npy');

expected=

"array([((10, 0), 98.25)],\n" +

" dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fromfunctionTest()

{

// >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)

// array([[ True, False, False],

// [False, True, False],

// [False, False, True]])

//

#if TODO

var given= np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int);

var expected=

"array([[ True, False, False],\n" +

" [False, True, False],\n" +

" [False, False, True]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)

// array([[0, 1, 2],

// [1, 2, 3],

// [2, 3, 4]])

//

#if TODO

given= np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int);

expected=

"array([[0, 1, 2],\n" +

" [1, 2, 3],\n" +

" [2, 3, 4]])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fromiterTest()

{

// >>> iterable = (x*x for x in range(5))

// >>> np.fromiter(iterable, float)

// array([ 0., 1., 4., 9., 16.])

//

#if TODO

var given= iterable = (x*x for x in range(5));

given= np.fromiter(iterable, float);

var expected=

"array([ 0., 1., 4., 9., 16.])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void fromstringTest()

{

// >>> np.fromstring('1 2', dtype=int, sep=' ')

// array([1, 2])

// >>> np.fromstring('1, 2', dtype=int, sep=',')

// array([1, 2])

//

#if TODO

var given= np.fromstring('1 2', dtype=int, sep=' ');

var expected=

"array([1, 2])";

Assert.AreEqual(expected, given.repr);

given= np.fromstring('1, 2', dtype=int, sep=',');

expected=

"array([1, 2])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void loadtxtTest()

{

// >>> from io import StringIO # StringIO behaves like a file object

// >>> c = StringIO(u"0 1\n2 3")

// >>> np.loadtxt(c)

// array([[ 0., 1.],

// [ 2., 3.]])

//

#if TODO

var given= from io import StringIO # StringIO behaves like a file object;

given= c = StringIO(u"0 1\n2 3");

given= np.loadtxt(c);

var expected=

"array([[ 0., 1.],\n" +

" [ 2., 3.]])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> d = StringIO(u"M 21 72\nF 35 58")

// >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),

// ... 'formats': ('S1', 'i4', 'f4')})

// array([('M', 21, 72.0), ('F', 35, 58.0)],

// dtype=[('gender', '|S1'), ('age', '<i4'), ('weight', '<f4')])

//

#if TODO

given= d = StringIO(u"M 21 72\nF 35 58");

given= np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),;

expected=

"... 'formats': ('S1', 'i4', 'f4')})\n" +

"array([('M', 21, 72.0), ('F', 35, 58.0)],\n" +

" dtype=[('gender', '|S1'), ('age', '<i4'), ('weight', '<f4')])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> c = StringIO(u"1,0,2\n3,0,4")

// >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)

// >>> x

// array([ 1., 3.])

// >>> y

// array([ 2., 4.])

//

#if TODO

given= c = StringIO(u"1,0,2\n3,0,4");

given= x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True);

given= x;

expected=

"array([ 1., 3.])";

Assert.AreEqual(expected, given.repr);

given= y;

expected=

"array([ 2., 4.])";

Assert.AreEqual(expected, given.repr);

#endif

}

[TestMethod]

public void chararrayTest()

{

// >>> charar = np.chararray((3, 3))

// >>> charar[:] = 'a'

// >>> charar

// chararray([['a', 'a', 'a'],

// ['a', 'a', 'a'],

// ['a', 'a', 'a']],

// dtype='|S1')

//

#if TODO

var given= charar = np.chararray((3, 3));

given= charar[:] = 'a';

given= charar;

var expected=

"chararray([['a', 'a', 'a'],\n" +

" ['a', 'a', 'a'],\n" +

" ['a', 'a', 'a']],\n" +

" dtype='|S1')";

Assert.AreEqual(expected, given.repr);

#endif

// >>> charar = np.chararray(charar.shape, itemsize=5)

// >>> charar[:] = 'abc'

// >>> charar

// chararray([['abc', 'abc', 'abc'],

// ['abc', 'abc', 'abc'],

// ['abc', 'abc', 'abc']],

// dtype='|S5')

//

#if TODO

given= charar = np.chararray(charar.shape, itemsize=5);

given= charar[:] = 'abc';

given= charar;

expected=

"chararray([['abc', 'abc', 'abc'],\n" +

" ['abc', 'abc', 'abc'],\n" +

" ['abc', 'abc', 'abc']],\n" +

" dtype='|S5')";

Assert.AreEqual(expected, given.repr);

#endif

// Methods

}

[TestMethod]

public void arangeTest()

{

// >>> np.arange(3)

// array([0, 1, 2])

// >>> np.arange(3.0)

// array([ 0., 1., 2.])

// >>> np.arange(3,7)

// array([3, 4, 5, 6])

// >>> np.arange(3,7,2)

// array([3, 5])

//

#if TODO

var given= np.arange(3);

var expected=

"array([0, 1, 2])";

Assert.AreEqual(expected, given.repr);

given= np.arange(3.0);

expected=

"array([ 0., 1., 2.])";

Assert.AreEqual(expected, given.repr);

given= np.arange(3,7);

expected=

"array([3, 4, 5, 6])";

Assert.AreEqual(expected, given.repr);

given= np.arange(3,7,2);

expected=

"array([3, 5])";

Assert.AreEqual(expected, given.repr);

#endif

}