/** * Sets the observed value by coordinate point. * * @param x x-coordinate.-1 to 1 * @param y y-coordinate -1 to 1 * @param value Observed value at that coordinate */ public void setValue( int x , int y , double value ) { setValue((y+1)*3+x+1,value); }
public static Polynomial derivative( Polynomial poly , Polynomial deriv ) { if( deriv == null ) { deriv = new Polynomial(poly.size-1); } else { deriv.size = poly.size - 1; } for( int i = 1; i < poly.size; i++ ) { deriv.c[i-1] = poly.c[i]*i; } return deriv; }
/** * Wraps the polynomial around the array:<br> * f(x) = c[0] + c[1]*x + ... + c[n]*x<sup>n-1</sup> * @param coefficients Polynomial coefficients * @return new instance of a polyonimial which is identical to the input array */ public static Polynomial wrap( double ...coefficients ) { Polynomial p = new Polynomial(coefficients.length); p.setTo(coefficients,coefficients.length); return p; }
public static void main( String args[] ) { Polynomial a = Polynomial.wrap(5,-2,3,0.5,30.4); Polynomial b = Polynomial.wrap(-0.4,8.4,-2.3); System.out.println("a = "+a); System.out.println("b = "+b); System.out.println("a + b = "+PolynomialOps.add(a,b,null)); System.out.println("a * b = "+PolynomialOps.multiply(a, b, null)); // Declare storage for the quotient and the remainder Polynomial q = new Polynomial(10); Polynomial r = new Polynomial(10); PolynomialOps.divide(a, b, q,r); System.out.println("a / b = ( "+q+" , "+r+" )"); System.out.println("Derivative a = "+PolynomialOps.derivative(a,null)); } }
Polynomial deriv = new Polynomial(poly.size()); derivative(poly,deriv); double v = poly.evaluate(root); double d = deriv.evaluate(root);
@Test public void derivative() { Polynomial p = Polynomial.wrap(2,3,4,5); p.size = 2; Polynomial d = new Polynomial(10); PolynomialOps.derivative(p,d); assertTrue(d.isIdentical(Polynomial.wrap(3), 1e-8)); p.size = 3; PolynomialOps.derivative(p,d); assertTrue(d.isIdentical(Polynomial.wrap(3, 8), 1e-8)); }
/** * Randomly generate polynomials. First divide then multiply them back together to reconstruct * the original. */ @Test public void divide_then_multiply() { for( int i = 2; i < 10; i++ ) { Polynomial n = createRandom(i); for( int j = 1; j < i; j++ ) { Polynomial d = createRandom(j); Polynomial q = new Polynomial(10); Polynomial r = new Polynomial(10); PolynomialOps.divide(n,d,q,r); Polynomial a = PolynomialOps.multiply(d,q,null); Polynomial b = PolynomialOps.add(a,r,null); assertTrue(b.isIdentical(n, 1e-8)); } } }
@Test public void divide() { // numerator and denominator, intentionally add trailing zeros to skew things up Polynomial n = Polynomial.wrap(1,2,3,0); Polynomial d = Polynomial.wrap(-3,1,0); // quotient and remainder Polynomial q = new Polynomial(10); Polynomial r = new Polynomial(10); // expected solutions Polynomial expectedQ = Polynomial.wrap(11,3,0); Polynomial expectedR = Polynomial.wrap(34); PolynomialOps.divide(n,d,q,r); assertEquals(3,q.size); assertEquals(1,r.size); assertTrue(expectedQ.isIdentical(q, 1e-8)); assertTrue(expectedR.isIdentical(r, 1e-8)); }
@Test public void cubicRealRoot() { Polynomial p = Polynomial.wrap(4,-5,2,1.3); double root = PolynomialOps.cubicRealRoot(p.c[0],p.c[1],p.c[2],p.c[3]); double eval = p.evaluate(root); assertEquals(0, eval, 1e-8); } }
@Test public void add() { Polynomial a = PolynomialOps.add(Polynomial.wrap(0.5,1,1),Polynomial.wrap(0.5,1,2),null); Polynomial b = PolynomialOps.add(Polynomial.wrap(0.5,1),Polynomial.wrap(0.5,1,2),null); Polynomial c = PolynomialOps.add(Polynomial.wrap(0.5,1,1),Polynomial.wrap(0.5,1),null); assertTrue(Polynomial.wrap(1, 2, 3).isIdentical(a, 1e-8)); assertTrue(Polynomial.wrap(1, 2, 2).isIdentical(b, 1e-8)); assertTrue(Polynomial.wrap(1, 2, 1).isIdentical(c, 1e-8)); }
@Test public void multiply() { Polynomial a = PolynomialOps.multiply(Polynomial.wrap(2), Polynomial.wrap(3), null); Polynomial b = PolynomialOps.multiply(Polynomial.wrap(),Polynomial.wrap(3),null); Polynomial c = PolynomialOps.multiply(Polynomial.wrap(),Polynomial.wrap(),null); Polynomial d = PolynomialOps.multiply(Polynomial.wrap(4),Polynomial.wrap(2,3),null); Polynomial e = PolynomialOps.multiply(Polynomial.wrap(2,3),Polynomial.wrap(4),null); Polynomial f = PolynomialOps.multiply(Polynomial.wrap(2,3),Polynomial.wrap(4,8),null); assertTrue(Polynomial.wrap(6).isIdentical(a, 1e-8)); assertTrue(b.size == 0); assertTrue(c.size == 0); assertTrue(Polynomial.wrap(8, 12).isIdentical(d, 1e-8)); assertTrue(Polynomial.wrap(8, 12).isIdentical(e, 1e-8)); assertTrue(Polynomial.wrap(8, 28, 24).isIdentical(f, 1e-8)); }
/** * Computed a root using Sage. The two other roots are imaginary */ @Test public void cubicRootReal_known() { double root = PolynomialSolver.cubicRootReal(4, 3, 2, 1); // test it against a known solution assertEquals(-1.65062919143939, root, 1e-8); // test it against the definition of a root assertEquals(0, cubic(4, 3, 2, 1, root), 1e-8); }
Polynomial deriv = new Polynomial(poly.size()); derivative(poly,deriv); double v = poly.evaluate(root); double d = deriv.evaluate(root);
/** * Wraps the polynomial around the array:<br> * f(x) = c[0] + c[1]*x + ... + c[n]*x<sup>n-1</sup> * @param coefficients Polynomial coefficients * @return new instance of a polyonimial which is identical to the input array */ public static Polynomial wrap( double ...coefficients ) { Polynomial p = new Polynomial(coefficients.length); p.setTo(coefficients,coefficients.length); return p; }
public static Polynomial derivative( Polynomial poly , Polynomial deriv ) { if( deriv == null ) { deriv = new Polynomial(poly.size-1); } else { deriv.size = poly.size - 1; } for( int i = 1; i < poly.size; i++ ) { deriv.c[i-1] = poly.c[i]*i; } return deriv; }
/** * Sets the observed value by coordinate point. * * @param x x-coordinate.-1 to 1 * @param y y-coordinate -1 to 1 * @param value Observed value at that coordinate */ public void setValue( int x , int y , double value ) { setValue((y+1)*3+x+1,value); }
/** * Configures the algorithm. * * @param maxPolySize The maximum number of coefficients on the polynomial being processed. */ public SturmSequence( int maxPolySize ) { next = new Polynomial(maxPolySize); previous = new Polynomial(maxPolySize); result = new Polynomial(maxPolySize); sequence = new Polynomial[maxPolySize+1]; for( int i = 0; i < sequence.length; i++ ) sequence[i] = new Polynomial(maxPolySize); f = new double[ maxPolySize + 1]; }
/** * Configures the algorithm. * * @param maxPolySize The maximum number of coefficients on the polynomial being processed. */ public SturmSequence( int maxPolySize ) { next = new Polynomial(maxPolySize); previous = new Polynomial(maxPolySize); result = new Polynomial(maxPolySize); sequence = new Polynomial[maxPolySize+1]; for( int i = 0; i < sequence.length; i++ ) sequence[i] = new Polynomial(maxPolySize); f = new double[ maxPolySize + 1]; }
private Polynomial createRandom( int N ) { Polynomial ret = new Polynomial(N); for( int i = 0; i < N; i++ ) { ret.c[i] = 5*(rand.nextDouble()-0.5); } return ret; }