def test_standardNormal():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
assert NumCpp.standardNormal(inShape) is not None
assert NumCpp.standardNormal() is not None
def test_coord_not_equality_operator():
cCoord = NumCpp.Coordinate()
raDegrees = np.random.rand(1).item() * 360
decDegrees = np.random.rand(1).item() * 180 - 90
cCoord2 = NumCpp.Coordinate(raDegrees, decDegrees)
assert cCoord2 != cCoord
def test_poly1D_integ_deriv_area_order():
numRoots = np.random.randint(3, 10, [
1,
]).item()
roots = np.random.randint(-20, 20, [
numRoots,
])
rootsC = NumCpp.NdArray(1, numRoots)
rootsC.setArray(roots)
poly = np.poly1d(roots, True)
polyC = NumCpp.Poly1d(rootsC, True)
bounds = np.random.rand(2) * 100 - 50
bounds = np.sort(bounds)
polyIntegral = poly.integ()
assert np.round(polyC.area(*bounds), 3) == np.round(
polyIntegral(bounds[1]) - polyIntegral(bounds[0]), 3)
assert np.array_equal(
polyC.deriv().coefficients().getNumpyArray().flatten(),
np.flipud(poly.deriv().coefficients))
assert np.array_equal(
polyC.integ().coefficients().getNumpyArray().flatten(),
np.flipud(poly.integ().coefficients))
assert polyC.order() == roots.size
value = np.random.randint(-20, 20, [
1,
]).item()
assert polyC[value] == poly(value)
def test_pivotLU_decomposition():
sizeInput = np.random.randint(5, 50)
shape = NumCpp.Shape(sizeInput)
cArray = NumCpp.NdArray(shape)
data = np.random.randint(1, 100, [shape.rows, shape.cols])
cArray.setArray(data)
l, u, p = NumCpp.pivotLU_decomposition(cArray)
lhs = p.dot(data)
rhs = l.dot(u)
assert np.array_equal(np.round(lhs, 10), np.round(rhs, 10))
shapeInput = np.random.randint(5, 50, [
2,
])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(1, 100, [shape.rows, shape.cols])
cArray.setArray(data)
uArray = NumCpp.NdArray()
sArray = NumCpp.NdArray()
vArray = NumCpp.NdArray()
NumCpp.svd(cArray, uArray, sArray, vArray)
data2 = np.dot(uArray.getNumpyArray(),
np.dot(sArray.getNumpyArray(), vArray.getNumpyArray()))
assert np.array_equal(np.round(data, 9), np.round(data2, 9))
def test_poly1D_fit():
polyOrder = np.random.randint(2, 5)
numMeasurements = np.random.randint(50, 100)
xValues = np.random.rand(numMeasurements) * 100 - 50
coefficients = np.random.rand(polyOrder + 1) * 5 - 10
yValues = []
for x in xValues:
y = 0
for order in range(polyOrder + 1):
y += coefficients[order] * x**order
yValues.append(y + np.random.randn(1).item())
yValues = np.array(yValues)
yValues = yValues.reshape(yValues.size, 1)
cX = NumCpp.NdArray(1, xValues.size)
cY = NumCpp.NdArray(yValues.size, 1)
cX.setArray(xValues)
cY.setArray(yValues)
poly = Polynomial.fit(xValues, yValues.flatten(),
polyOrder).convert().coef # noqa
polyC = NumCpp.Poly1d.fit(
cX, cY, polyOrder).coefficients().getNumpyArray().flatten()
assert np.array_equal(np.round(poly, 5), np.round(polyC, 5))
def test_inv():
order = np.random.randint(5, 50, [1, ]).item()
shape = NumCpp.Shape(order)
cArray = NumCpp.NdArray(shape)
data = np.random.randint(1, 100, [shape.rows, shape.cols])
cArray.setArray(data)
assert np.array_equal(np.round(NumCpp.inv(cArray).getNumpyArray(), 9), np.round(np.linalg.inv(data), 9))
def test_spherical_harmonic():
if NumCpp.NO_USE_BOOST:
return
for order in range(ORDER_MAX):
degree = np.random.randint(order, ORDER_MAX)
theta = np.random.rand(1).item() * np.pi * 2
phi = np.random.rand(1).item() * np.pi
valuePy = sp.sph_harm(order, degree, theta, phi)
valueCpp = NumCpp.spherical_harmonic(order, degree, theta, phi)
assert (np.round(valuePy.real, DECIMALS_ROUND) == np.round(
valueCpp[0], DECIMALS_ROUND)
and np.round(valuePy.imag, DECIMALS_ROUND) == np.round(
valueCpp[1], DECIMALS_ROUND))
for order in range(ORDER_MAX):
degree = np.random.randint(order, ORDER_MAX)
theta = np.random.rand(1).item() * np.pi * 2
phi = np.random.rand(1).item() * np.pi
valuePy = sp.sph_harm(order, degree, theta, phi)
valueCpp = NumCpp.spherical_harmonic_r(order, degree, theta, phi)
assert np.round(valuePy.real,
DECIMALS_ROUND) == np.round(valueCpp, DECIMALS_ROUND)
for order in range(ORDER_MAX):
degree = np.random.randint(order, ORDER_MAX)
theta = np.random.rand(1).item() * np.pi * 2
phi = np.random.rand(1).item() * np.pi
valuePy = sp.sph_harm(order, degree, theta, phi)
valueCpp = NumCpp.spherical_harmonic_i(order, degree, theta, phi)
assert np.round(valuePy.imag,
DECIMALS_ROUND) == np.round(valueCpp, DECIMALS_ROUND)
def test_comp_ellint_3():
if NumCpp.NUMCPP_NO_USE_BOOST and not NumCpp.STL_SPECIAL_FUNCTIONS:
return
a = np.random.rand(1).item()
b = np.random.rand(1).item()
assert (roundScaler(NumCpp.comp_ellint_3_Scaler(a, b),
NUM_DECIMALS_ROUND) == roundScaler(
float(mpmath.ellippi(b, a**2)),
NUM_DECIMALS_ROUND))
shapeInput = np.random.randint(20, 100, [
2,
])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
aArray = NumCpp.NdArray(shape)
bArray = NumCpp.NdArray(shape)
a = np.random.rand(shape.rows, shape.cols)
b = np.random.rand(shape.rows, shape.cols)
aArray.setArray(a)
bArray.setArray(b)
result = np.zeros_like(a)
for row in range(a.shape[0]):
for col in range(a.shape[1]):
result[row,
col] = float(mpmath.ellippi(b[row, col], a[row, col]**2))
assert np.array_equal(
roundArray(NumCpp.comp_ellint_3_Array(aArray, bArray),
NUM_DECIMALS_ROUND), roundArray(result, NUM_DECIMALS_ROUND))
def test_ra_equality_operator():
ra = NumCpp.Ra()
assert ra
randDegrees = np.random.rand(1).item() * 360
ra2 = NumCpp.Ra(randDegrees)
assert ra != ra2
def test_cube():
value = np.random.randint(1, 6, [1, ], dtype=np.int8).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 32, [1, ], dtype=np.int16).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 100, [1, ], dtype=np.int32).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 100, [1, ], dtype=np.int64).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 7, [1, ], dtype=np.uint8).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 41, [1, ], dtype=np.uint16).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 100, [1, ], dtype=np.uint32).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 100, [1, ], dtype=np.uint64).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 100, [1, ]).astype(np.double).item()
assert NumCpp.cube(value) == value ** 3
value = np.random.randint(1, 100, [1, ]).astype(np.float32).item()
assert NumCpp.cube(value) == value ** 3
def test_equality_operator():
dec = NumCpp.Dec()
assert dec
randDegrees = np.random.rand(1).item() * 180 - 90
dec2 = NumCpp.Dec(randDegrees)
assert dec != dec2
def test_sqr():
value = np.random.randint(1, 12, [1, ], dtype=np.int8).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 100, [1, ], dtype=np.int16).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 100, [1, ], dtype=np.int32).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 100, [1, ], dtype=np.int64).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 15, [1, ], dtype=np.uint8).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 100, [1, ], dtype=np.uint16).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 100, [1, ], dtype=np.uint32).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 100, [1, ], dtype=np.uint64).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 100, [1, ]).astype(np.double).item()
assert NumCpp.sqr(value) == value ** 2
value = np.random.randint(1, 100, [1, ]).astype(np.float32).item()
assert NumCpp.sqr(value) == value ** 2
def test_poly1D_coefficents_constructor():
numCoefficients = np.random.randint(3, 10, [1, ]).item()
coefficients = np.random.randint(-20, 20, [numCoefficients, ])
coefficientsC = NumCpp.NdArray(1, numCoefficients)
coefficientsC.setArray(coefficients)
polyC = NumCpp.Poly1d(coefficientsC, False)
assert np.array_equal(polyC.coefficients().getNumpyArray().flatten(), coefficients)
def test_poly1D_operators():
numRoots = np.random.randint(3, 10, [1, ]).item()
roots = np.random.randint(-20, 20, [numRoots, ])
rootsC = NumCpp.NdArray(1, numRoots)
rootsC.setArray(roots)
poly = np.poly1d(roots, True)
polyC = NumCpp.Poly1d(rootsC, True)
numCoefficients = np.random.randint(3, 10, [1, ]).item()
coefficients = np.random.randint(-20, 20, [numCoefficients, ])
coefficientsC = NumCpp.NdArray(1, numCoefficients)
coefficientsC.setArray(coefficients)
polyC2 = NumCpp.Poly1d(coefficientsC, False)
poly2 = np.poly1d(np.flip(coefficients))
assert np.array_equal(np.fliplr((polyC + polyC2).coefficients().getNumpyArray()).flatten(),
(poly + poly2).coefficients)
assert np.array_equal(np.fliplr((polyC - polyC2).coefficients().getNumpyArray()).flatten(),
(poly - poly2).coefficients)
assert np.array_equal(np.fliplr((polyC * polyC2).coefficients().getNumpyArray()).flatten(),
(poly * poly2).coefficients)
exponent = np.random.randint(0, 5, [1, ]).item()
assert np.array_equal(np.fliplr((polyC2 ** exponent).coefficients().getNumpyArray()).flatten(),
(poly2 ** exponent).coefficients)
polyC.print()
def test_bernoulli():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
p = np.random.rand()
assert NumCpp.bernoulli(inShape, p) is not None
assert NumCpp.bernoulli(p) is not None
def test_poly1D_roots_constructor():
numRoots = np.random.randint(3, 10, [1, ]).item()
roots = np.random.randint(-20, 20, [numRoots, ])
rootsC = NumCpp.NdArray(1, numRoots)
rootsC.setArray(roots)
poly = np.poly1d(roots, True)
polyC = NumCpp.Poly1d(rootsC, True)
assert np.array_equal(np.fliplr(polyC.coefficients().getNumpyArray()).flatten().astype(np.int), poly.coefficients)
def test_Vec2_array_constructor():
components = np.random.rand(2)
shape = NumCpp.Shape(1, 2)
cArray = NumCpp.NdArray(shape)
cArray.setArray(components)
vec2 = NumCpp.Vec2(cArray)
assert vec2.x == components[0].item()
assert vec2.y == components[1].item()
def test_Vec3_division_operator():
components = np.random.rand(3)
scaler = np.random.rand(1).item()
vec3py = vectormath.Vector3(*components)
vec3cpp = NumCpp.Vec3(*components)
assert np.array_equal(np.round(vec3py / scaler, DECIMALS_TO_ROUND),
np.round((NumCpp.Vec3_divVec3Scaler(vec3cpp, scaler)).toNdArray().flatten(),
DECIMALS_TO_ROUND))
def test_poisson():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
mean = np.random.rand() * 10
assert NumCpp.poisson(inShape, mean) is not None
assert NumCpp.poisson(mean) is not None
def test_exponential():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
scale = np.random.rand() * 10
assert NumCpp.exponential(inShape, scale) is not None
assert NumCpp.exponential(scale) is not None
def test_geometric():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
p = np.random.rand()
assert NumCpp.geometric(inShape, p) is not None
assert NumCpp.geometric(p) is not None
def test_cauchy():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
mean = np.random.randn() * 10
sigma = np.random.rand() * 10
assert NumCpp.cauchy(inShape, mean, sigma) is not None
assert NumCpp.cauchy(mean, sigma) is not None
def test_weibull():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
inputs = np.random.rand(2)
assert NumCpp.weibull(inShape, inputs[0].item(),
inputs[1].item()) is not None
assert NumCpp.weibull(inputs[0].item(), inputs[1].item()) is not None
def test_functions():
k = np.random.randint(1, 5, [3, 1]).astype(np.double)
v = np.random.randint(1, 5, [3, 1]).astype(np.double)
theta = np.random.rand(1).item() * np.pi * 2
vec = NumCpp.rodriguesRotation(k, theta, v).flatten()
dcm = angleAxisRotation(k, theta)
vecPy = dcm.dot(v).flatten()
assert np.array_equal(np.round(vec, 10), np.round(vecPy, 10))
radians = np.random.rand(1) * 2 * np.pi
axis = np.random.rand(3)
cAxis = NumCpp.NdArray(1, 3)
cAxis.setArray(axis)
rot = NumCpp.DCM.angleAxisRotationNdArray(cAxis, radians.item())
vecBody = list()
vecInertial = list()
for _ in range(1000):
vec = np.random.randint(1, 100, [3, 1])
vec = vec / np.linalg.norm(vec)
vecBody.append(vec.flatten())
vecInertial.append(rot.dot(vec).flatten())
vecBody = np.array(vecBody)
vecInertial = np.array(vecInertial)
rotWahba = NumCpp.wahbasProblem(vecInertial, vecBody)
assert np.array_equal(np.round(rotWahba, 10), np.round(rot, 10))
radians = np.random.rand(1) * 2 * np.pi
axis = np.random.rand(3)
cAxis = NumCpp.NdArray(1, 3)
cAxis.setArray(axis)
rot = NumCpp.DCM.angleAxisRotationNdArray(cAxis, radians.item())
vecBody = list()
vecInertial = list()
for _ in range(1000):
vec = np.random.randint(1, 100, [3, 1])
vec = vec / np.linalg.norm(vec)
vecBody.append(vec.flatten())
vecInertial.append(rot.dot(vec).flatten())
vecBody = np.array(vecBody)
vecInertial = np.array(vecInertial)
weights = np.random.randint(1, 100) * np.ones(
[vecBody.shape[0]]) # all the same weight for simplicity...
rotWahba = NumCpp.wahbasProblemWeighted(vecInertial, vecBody, weights)
assert np.array_equal(np.round(rotWahba, 10), np.round(rot, 10))
def test_shuffle():
shapeInput = np.random.randint(1, 100, [
2,
])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
data = np.random.randint(1, 10, [shape.rows, shape.cols])
cArray.setArray(data)
NumCpp.shuffle(cArray)
def test_gamma():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
shape = np.random.rand() * 10
scale = np.random.rand() * 100
assert NumCpp.gamma(inShape, shape, scale) is not None
assert NumCpp.gamma(shape, scale) is not None
def test_f():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
dofN = np.random.rand() * 10
dofD = np.random.rand() * 100
assert NumCpp.f(inShape, dofN, dofD) is not None
assert NumCpp.f(dofN, dofD) is not None
def test_extremeValue():
shapeInput = np.random.randint(1, 100, [
2,
])
inShape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
a = np.random.rand() * 10
b = np.random.rand() * 100
assert NumCpp.extremeValue(inShape, a, b) is not None
assert NumCpp.extremeValue(a, b) is not None
def test_cholesky():
shapeInput = np.random.randint(5, 50, [2, ])
shape = NumCpp.Shape(shapeInput[0].item(), shapeInput[1].item())
cArray = NumCpp.NdArray(shape)
a = np.random.randint(1, 100, [shape.rows, shape.cols]).flatten()
aL = np.tril(a)
b = aL.dot(aL.transpose())
cArray.setArray(b)
assert np.array_equal(np.round(NumCpp.cholesky(cArray).getNumpyArray()), np.round(aL))
def test_lu_decomposition():
sizeInput = np.random.randint(5, 50)
shape = NumCpp.Shape(sizeInput)
cArray = NumCpp.NdArray(shape)
data = np.random.randint(1, 100, [shape.rows, shape.cols])
cArray.setArray(data)
l, u = NumCpp.lu_decomposition(cArray)
p = np.round(np.dot(l.getNumpyArray(), u.getNumpyArray())).astype(np.int)
assert np.array_equal(p, data)
