{

// Print sine of one angle:

// >>> np.sin(np.pi/2.)

// 1.0

//

#if TODO

var given= np.sin(np.pi/2.);

var expected=

"1.0";

Assert.AreEqual(expected, given.repr);

#endif

// Print sines of an array of angles given in degrees:

// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )

// array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ])

//

#if TODO

given= np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. );

expected=

"array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ])";

Assert.AreEqual(expected, given.repr);

#endif

// Plot the sine function:

// >>> import matplotlib.pylab as plt

// >>> x = np.linspace(-np.pi, np.pi, 201)

// >>> plt.plot(x, np.sin(x))

// >>> plt.xlabel('Angle [rad]')

// >>> plt.ylabel('sin(x)')

// >>> plt.axis('tight')

// >>> plt.show()

//

#if TODO

given= import matplotlib.pylab as plt;

given= x = np.linspace(-np.pi, np.pi, 201);

given= plt.plot(x, np.sin(x));

given= plt.xlabel('Angle [rad]');

given= plt.ylabel('sin(x)');

given= plt.axis('tight');

given= plt.show();

#endif

}

[TestMethod]

public void cosTest()

{

// >>> np.cos(np.array([0, np.pi/2, np.pi]))

// array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00])

// >>>

// >>> # Example of providing the optional output parameter

// >>> out2 = np.cos([0.1], out1)

// >>> out2 is out1

// True

// >>>

// >>> # Example of ValueError due to provision of shape mis-matched `out`

// >>> np.cos(np.zeros((3,3)),np.zeros((2,2)))

// Traceback (most recent call last):

// File "<stdin>", line 1, in <module>

// ValueError: invalid return array shape

//

#if TODO

var given= np.cos(np.array({0, np.pi/2, np.pi}));

var expected=

"array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00])";

Assert.AreEqual(expected, given.repr);

given= ;

given= # Example of providing the optional output parameter;

given= out2 = np.cos({0.1}, out1);

given= out2 is out1;

expected=

"True";

Assert.AreEqual(expected, given.repr);

given= ;

given= # Example of ValueError due to provision of shape mis-matched `out`;

given= np.cos(np.zeros((3,3)),np.zeros((2,2)));

expected=

"Traceback (most recent call last):\n" +

" File "<stdin>", line 1, in <module>\n" +

"ValueError: invalid return array shape";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> from math import pi

// >>> np.tan(np.array([-pi,pi/2,pi]))

// array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16])

// >>>

// >>> # Example of providing the optional output parameter illustrating

// >>> # that what is returned is a reference to said parameter

// >>> out2 = np.cos([0.1], out1)

// >>> out2 is out1

// True

// >>>

// >>> # Example of ValueError due to provision of shape mis-matched `out`

// >>> np.cos(np.zeros((3,3)),np.zeros((2,2)))

// Traceback (most recent call last):

// File "<stdin>", line 1, in <module>

// ValueError: invalid return array shape

//

#if TODO

var given= from math import pi;

given= np.tan(np.array({-pi,pi/2,pi}));

var expected=

"array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16])";

Assert.AreEqual(expected, given.repr);

given= ;

given= # Example of providing the optional output parameter illustrating;

given= # that what is returned is a reference to said parameter;

given= out2 = np.cos({0.1}, out1);

given= out2 is out1;

expected=

"True";

Assert.AreEqual(expected, given.repr);

given= ;

given= # Example of ValueError due to provision of shape mis-matched `out`;

given= np.cos(np.zeros((3,3)),np.zeros((2,2)));

expected=

"Traceback (most recent call last):\n" +

" File "<stdin>", line 1, in <module>\n" +

"ValueError: invalid return array shape";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.arcsin(1) # pi/2

// 1.5707963267948966

// >>> np.arcsin(-1) # -pi/2

// -1.5707963267948966

// >>> np.arcsin(0)

// 0.0

//

#if TODO

var given= np.arcsin(1) # pi/2;

var expected=

"1.5707963267948966";

Assert.AreEqual(expected, given.repr);

given= np.arcsin(-1) # -pi/2;

expected=

"-1.5707963267948966";

Assert.AreEqual(expected, given.repr);

given= np.arcsin(0);

expected=

"0.0";

Assert.AreEqual(expected, given.repr);

#endif

{

// We expect the arccos of 1 to be 0, and of -1 to be pi:

// >>> np.arccos([1, -1])

// array([ 0. , 3.14159265])

//

#if TODO

var given= np.arccos({1, -1});

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// Plot arccos:

// >>> import matplotlib.pyplot as plt

// >>> x = np.linspace(-1, 1, num=100)

// >>> plt.plot(x, np.arccos(x))

// >>> plt.axis('tight')

// >>> plt.show()

//

#if TODO

given= import matplotlib.pyplot as plt;

given= x = np.linspace(-1, 1, num=100);

given= plt.plot(x, np.arccos(x));

given= plt.axis('tight');

given= plt.show();

#endif

{

// We expect the arctan of 0 to be 0, and of 1 to be pi/4:

// >>> np.arctan([0, 1])

// array([ 0. , 0.78539816])

//

#if TODO

var given= np.arctan({0, 1});

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

// >>> np.pi/4

// 0.78539816339744828

//

#if TODO

given= np.pi/4;

expected=

"0.78539816339744828";

Assert.AreEqual(expected, given.repr);

#endif

// Plot arctan:

// >>> import matplotlib.pyplot as plt

// >>> x = np.linspace(-10, 10)

// >>> plt.plot(x, np.arctan(x))

// >>> plt.axis('tight')

// >>> plt.show()

//

#if TODO

given= import matplotlib.pyplot as plt;

given= x = np.linspace(-10, 10);

given= plt.plot(x, np.arctan(x));

given= plt.axis('tight');

given= plt.show();

#endif

{

// >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))

// array([[ 5., 5., 5.],

// [ 5., 5., 5.],

// [ 5., 5., 5.]])

//

#if TODO

var given= np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)));

var expected=

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

" [ 5., 5., 5.],\n" +

" [ 5., 5., 5.]])";

Assert.AreEqual(expected, given.repr);

#endif

// Example showing broadcast of scalar_like argument:

// >>> np.hypot(3*np.ones((3, 3)), [4])

// array([[ 5., 5., 5.],

// [ 5., 5., 5.],

// [ 5., 5., 5.]])

//

#if TODO

given= np.hypot(3*np.ones((3, 3)), {4});

expected=

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

" [ 5., 5., 5.],\n" +

" [ 5., 5., 5.]])";

Assert.AreEqual(expected, given.repr);

#endif

{

// Consider four points in different quadrants:

// >>> x = np.array([-1, +1, +1, -1])

// >>> y = np.array([-1, -1, +1, +1])

// >>> np.arctan2(y, x) * 180 / np.pi

// array([-135., -45., 45., 135.])

//

#if TODO

var given= x = np.array({-1, +1, +1, -1});

given= y = np.array({-1, -1, +1, +1});

given= np.arctan2(y, x) * 180 / np.pi;

var expected=

"array([-135., -45., 45., 135.])";

Assert.AreEqual(expected, given.repr);

#endif

// Note the order of the parameters. arctan2 is defined also when x2 = 0

// and at several other special points, obtaining values in

// the range [-pi, pi]:

// >>> np.arctan2([1., -1.], [0., 0.])

// array([ 1.57079633, -1.57079633])

// >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])

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

//

#if TODO

given= np.arctan2({1., -1.}, {0., 0.});

expected=

"array([ 1.57079633, -1.57079633])";

Assert.AreEqual(expected, given.repr);

given= np.arctan2({0., 0., np.inf}, {+0., -0., np.inf});

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// Convert a radian array to degrees

// >>> rad = np.arange(12.)*np.pi/6

// >>> np.degrees(rad)

// array([ 0., 30., 60., 90., 120., 150., 180., 210., 240.,

// 270., 300., 330.])

//

#if TODO

var given= rad = np.arange(12.)*np.pi/6;

given= np.degrees(rad);

var expected=

"array([ 0., 30., 60., 90., 120., 150., 180., 210., 240.,\n" +

" 270., 300., 330.])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> out = np.zeros((rad.shape))

// >>> r = degrees(rad, out)

// >>> np.all(r == out)

// True

//

#if TODO

given= out = np.zeros((rad.shape));

given= r = degrees(rad, out);

given= np.all(r == out);

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

{

// Convert a degree array to radians

// >>> deg = np.arange(12.) * 30.

// >>> np.radians(deg)

// array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 ,

// 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898,

// 5.23598776, 5.75958653])

//

#if TODO

var given= deg = np.arange(12.) * 30.;

given= np.radians(deg);

var expected=

"array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 ,\n" +

" 2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898,\n" +

" 5.23598776, 5.75958653])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> out = np.zeros((deg.shape))

// >>> ret = np.radians(deg, out)

// >>> ret is out

// True

//

#if TODO

given= out = np.zeros((deg.shape));

given= ret = np.radians(deg, out);

given= ret is out;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> phase = np.linspace(0, np.pi, num=5)

// >>> phase[3:] += np.pi

// >>> phase

// array([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531])

// >>> np.unwrap(phase)

// array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ])

//

#if TODO

var given= phase = np.linspace(0, np.pi, num=5);

given= phase{3:} += np.pi;

given= phase;

var expected=

"array([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531])";

Assert.AreEqual(expected, given.repr);

given= np.unwrap(phase);

expected=

"array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ])";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.deg2rad(180)

// 3.1415926535897931

//

#if TODO

var given= np.deg2rad(180);

var expected=

"3.1415926535897931";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.rad2deg(np.pi/2)

// 90.0

//

#if TODO

var given= np.rad2deg(np.pi/2);

var expected=

"90.0";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.sinh(0)

// 0.0

// >>> np.sinh(np.pi*1j/2)

// 1j

// >>> np.sinh(np.pi*1j) # (exact value is 0)

// 1.2246063538223773e-016j

// >>> # Discrepancy due to vagaries of floating point arithmetic.

//

#if TODO

var given= np.sinh(0);

var expected=

"0.0";

Assert.AreEqual(expected, given.repr);

given= np.sinh(np.pi*1j/2);

expected=

"1j";

Assert.AreEqual(expected, given.repr);

given= np.sinh(np.pi*1j) # (exact value is 0);

expected=

"1.2246063538223773e-016j";

Assert.AreEqual(expected, given.repr);

given= # Discrepancy due to vagaries of floating point arithmetic.;

#endif

// >>> # Example of providing the optional output parameter

// >>> out2 = np.sinh([0.1], out1)

// >>> out2 is out1

// True

//

#if TODO

given= # Example of providing the optional output parameter;

given= out2 = np.sinh({0.1}, out1);

given= out2 is out1;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

// >>> # Example of ValueError due to provision of shape mis-matched `out`

// >>> np.sinh(np.zeros((3,3)),np.zeros((2,2)))

// Traceback (most recent call last):

// File "<stdin>", line 1, in <module>

// ValueError: invalid return array shape

//

#if TODO

given= # Example of ValueError due to provision of shape mis-matched `out`;

given= np.sinh(np.zeros((3,3)),np.zeros((2,2)));

expected=

"Traceback (most recent call last):\n" +

" File "<stdin>", line 1, in <module>\n" +

"ValueError: invalid return array shape";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.cosh(0)

// 1.0

//

#if TODO

var given= np.cosh(0);

var expected=

"1.0";

Assert.AreEqual(expected, given.repr);

#endif

// The hyperbolic cosine describes the shape of a hanging cable:

// >>> import matplotlib.pyplot as plt

// >>> x = np.linspace(-4, 4, 1000)

// >>> plt.plot(x, np.cosh(x))

// >>> plt.show()

//

#if TODO

given= import matplotlib.pyplot as plt;

given= x = np.linspace(-4, 4, 1000);

given= plt.plot(x, np.cosh(x));

given= plt.show();

#endif

{

// >>> np.tanh((0, np.pi*1j, np.pi*1j/2))

// array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j])

//

#if TODO

var given= np.tanh((0, np.pi*1j, np.pi*1j/2));

var expected=

"array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j])";

Assert.AreEqual(expected, given.repr);

#endif

// >>> # Example of providing the optional output parameter illustrating

// >>> # that what is returned is a reference to said parameter

// >>> out2 = np.tanh([0.1], out1)

// >>> out2 is out1

// True

//

#if TODO

given= # Example of providing the optional output parameter illustrating;

given= # that what is returned is a reference to said parameter;

given= out2 = np.tanh({0.1}, out1);

given= out2 is out1;

expected=

"True";

Assert.AreEqual(expected, given.repr);

#endif

// >>> # Example of ValueError due to provision of shape mis-matched `out`

// >>> np.tanh(np.zeros((3,3)),np.zeros((2,2)))

// Traceback (most recent call last):

// File "<stdin>", line 1, in <module>

// ValueError: invalid return array shape

//

#if TODO

given= # Example of ValueError due to provision of shape mis-matched `out`;

given= np.tanh(np.zeros((3,3)),np.zeros((2,2)));

expected=

"Traceback (most recent call last):\n" +

" File "<stdin>", line 1, in <module>\n" +

"ValueError: invalid return array shape";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.arcsinh(np.array([np.e, 10.0]))

// array([ 1.72538256, 2.99822295])

//

#if TODO

var given= np.arcsinh(np.array({np.e, 10.0}));

var expected=

"array([ 1.72538256, 2.99822295])";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.arccosh([np.e, 10.0])

// array([ 1.65745445, 2.99322285])

// >>> np.arccosh(1)

// 0.0

//

#if TODO

var given= np.arccosh({np.e, 10.0});

var expected=

"array([ 1.65745445, 2.99322285])";

Assert.AreEqual(expected, given.repr);

given= np.arccosh(1);

expected=

"0.0";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.arctanh([0, -0.5])

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

//

#if TODO

var given= np.arctanh({0, -0.5});

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.around([0.37, 1.64])

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

// >>> np.around([0.37, 1.64], decimals=1)

// array([ 0.4, 1.6])

// >>> np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value

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

// >>> np.around([1,2,3,11], decimals=1) # ndarray of ints is returned

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

// >>> np.around([1,2,3,11], decimals=-1)

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

//

#if TODO

var given= np.around({0.37, 1.64});

var expected=

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

Assert.AreEqual(expected, given.repr);

given= np.around({0.37, 1.64}, decimals=1);

expected=

"array([ 0.4, 1.6])";

Assert.AreEqual(expected, given.repr);

given= np.around({.5, 1.5, 2.5, 3.5, 4.5}) # rounds to nearest even value;

expected=

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

Assert.AreEqual(expected, given.repr);

given= np.around({1,2,3,11}, decimals=1) # ndarray of ints is returned;

expected=

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

Assert.AreEqual(expected, given.repr);

given= np.around({1,2,3,11}, decimals=-1);

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])

// >>> np.rint(a)

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

//

#if TODO

var given= a = np.array({-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0});

given= np.rint(a);

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.fix(3.14)

// 3.0

// >>> np.fix(3)

// 3.0

// >>> np.fix([2.1, 2.9, -2.1, -2.9])

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

//

#if TODO

var given= np.fix(3.14);

var expected=

"3.0";

Assert.AreEqual(expected, given.repr);

given= np.fix(3);

expected=

"3.0";

Assert.AreEqual(expected, given.repr);

given= np.fix({2.1, 2.9, -2.1, -2.9});

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])

// >>> np.floor(a)

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

//

#if TODO

var given= a = np.array({-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0});

given= np.floor(a);

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])

// >>> np.ceil(a)

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

//

#if TODO

var given= a = np.array({-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0});

given= np.ceil(a);

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])

// >>> np.trunc(a)

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

//

#if TODO

var given= a = np.array({-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0});

given= np.trunc(a);

var expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// By default, calculate the product of all elements:

// >>> np.prod([1.,2.])

// 2.0

Assert.AreEqual(2.0, np.prod(new[] { 1.0, 2.0 }).asscalar<double>());

// Even when the input array is two-dimensional:

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

// 24.0

Assert.AreEqual(24.0, (double)np.prod(new[,] { { 1.0, 2.0 }, { 3.0, 4.0 } }));

// But we can also specify the axis over which to multiply:

// >>> np.prod([[1.,2.],[3.,4.]], axis=1)

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

var given = np.prod(new[,] { { 1.0, 2.0 }, { 3.0, 4.0 } }, axis: new[] { 1 });

var expected = "array([ 2., 12.])";

Assert.AreEqual(expected, given.repr);

// If the type of x is unsigned, then the output type is

// the unsigned platform integer:

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

// >>> np.prod(x).dtype == np.uint

// True

var x = np.array(new byte[] { 1, 2, 3 }, dtype: np.uint8);

Assert.AreEqual(np.@uint, np.prod(x).dtype);

// If x is of a signed integer type, then the output type

// is the default platform integer:

x = np.array(new byte[] { 1, 2, 3 }, dtype: np.int8);

Assert.AreEqual(np.int_, np.prod(x).dtype);

// You can also start the product with a value other than one:

// >>> np.prod([1, 2], initial=5)

// 10

Assert.AreEqual(10, (int)np.prod(new[] { 1, 2 }, initial: 5));

{

// >>> np.sum([0.5, 1.5])

// 2.0

// >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)

// 1

// >>> np.sum([[0, 1], [0, 5]])

// 6

// >>> np.sum([[0, 1], [0, 5]], axis=0)

// array([0, 6])

// >>> np.sum([[0, 1], [0, 5]], axis=1)

// array([1, 5])

//

var given = np.sum(new[] { 0.5, 1.5 });

var expected =

"2.0";

Assert.AreEqual(expected, given.repr);

given = np.sum(new[] { 0.5, 0.7, 0.2, 1.5 }, dtype: np.int32);

expected =

"1";

Assert.AreEqual(expected, given.repr);

given = np.sum(new[,] { { 0, 1 }, { 0, 5 } });

expected =

"6";

Assert.AreEqual(expected, given.repr);

given = np.sum(new[,] { { 0, 1 }, { 0, 5 } }, axis: 0);

expected =

"array([0, 6])";

Assert.AreEqual(expected, given.repr);

given = np.sum(new[,] { { 0, 1 }, { 0, 5 } }, axis: 1);

expected =

"array([1, 5])";

Assert.AreEqual(expected, given.repr);

// If the accumulator is too small, overflow occurs:

// >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)

// -128

//

#if TODO

given= np.ones(128, dtype=np.int8).sum(dtype=np.int8);

expected=

"-128";

Assert.AreEqual(expected, given.repr);

#endif

// You can also start the sum with a value other than zero:

// >>> np.sum([10], initial=5)

// 15

//

#if TODO

given= np.sum({10}, initial=5);

expected=

"15";

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.nanprod(1)

// 1

// >>> np.nanprod([1])

// 1

// >>> np.nanprod([1, np.nan])

// 1.0

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

// >>> np.nanprod(a)

// 6.0

// >>> np.nanprod(a, axis=0)

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

//

#if TODO

var given= np.nanprod(1);

var expected=

"1";

Assert.AreEqual(expected, given.repr);

given= np.nanprod({1});

expected=

"1";

Assert.AreEqual(expected, given.repr);

given= np.nanprod({1, np.nan});

expected=

"1.0";

Assert.AreEqual(expected, given.repr);

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

given= np.nanprod(a);

expected=

"6.0";

Assert.AreEqual(expected, given.repr);

given= np.nanprod(a, axis=0);

expected=

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

Assert.AreEqual(expected, given.repr);

#endif

{

// >>> np.nansum(1)

// 1

// >>> np.nansum([1])

// 1

// >>> np.nansum([1, np.nan])

// 1.0

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

// >>> np.nansum(a)

// 3.0

// >>> np.nansum(a, axis=0)

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