Пример #1
0
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()
Пример #2
0
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)
Пример #3
0
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)
Пример #4
0
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)
Пример #5
0
def test_newton():
    root = np.random.randint(-50, 50, [
        1,
    ]).item()
    roots = np.array([root, root + np.random.randint(5, 50, [
        1,
    ]).item()])
    largestRoot = np.max(roots).item()
    rootsC = NumCpp.NdArray(1, roots.size)
    rootsC.setArray(roots)
    polyC = NumCpp.Poly1d(rootsC, True)
    rootC = int(np.round(NumCpp.newton_roots(polyC, largestRoot)))
    assert rootC == largestRoot
Пример #6
0
def test_simpson():
    numCoefficients = np.random.randint(2, 5, [
        1,
    ]).item()
    coefficients = np.random.randint(-20, 20, [
        numCoefficients,
    ])
    coefficientsC = NumCpp.NdArray(1, numCoefficients)
    coefficientsC.setArray(coefficients)
    poly = np.poly1d(np.flipud(coefficients), False)
    polyIntegral = poly.integ()
    polyC = NumCpp.Poly1d(coefficientsC, False)
    a, b = np.sort(np.random.rand(2) * 100 - 50)
    area = np.round(polyIntegral(b) - polyIntegral(a), NUM_DECIMALS_ROUND)
    areaC = np.round(NumCpp.integrate_simpson(polyC, a, b), NUM_DECIMALS_ROUND)
    assert area == areaC
Пример #7
0
def test_romberg():
    PERCENT_LEEWAY = 0.1
    numCoefficients = np.random.randint(2, 5, [
        1,
    ]).item()
    coefficients = np.random.randint(-20, 20, [
        numCoefficients,
    ])
    coefficientsC = NumCpp.NdArray(1, numCoefficients)
    coefficientsC.setArray(coefficients)
    poly = np.poly1d(np.flipud(coefficients), False)
    polyIntegral = poly.integ()
    polyC = NumCpp.Poly1d(coefficientsC, False)
    a, b = np.sort(np.random.rand(2) * 100 - 50)
    area = np.round(polyIntegral(b) - polyIntegral(a), NUM_DECIMALS_ROUND)
    areaC = np.round(NumCpp.integrate_romberg(polyC, a, b), NUM_DECIMALS_ROUND)
    # romberg is much less acurate so let's give it some leeway
    areaLow, areaHigh = np.sort(
        [area * (1 - PERCENT_LEEWAY), area * (1 + PERCENT_LEEWAY)])
    assert areaLow < areaC < areaHigh