Interpolazione

[vegetablu]

Ciao a tutti,
vorrei sapere se esiste una classe/metodo che mi permetta di interpolare una serie di punti per ricavarne la funzione.

Avete gi� un codice funzionante? Perch� non trovo nulla sulla documentazione ufficiale.
Grazie

[andbin]

vorrei sapere se esiste una classe/metodo che mi permetta di interpolare una serie di punti per ricavarne la funzione.

Avete gi� un codice funzionante? Perch� non trovo nulla sulla documentazione ufficiale.

Esiste dove? Nel framework standard? Sicuramente no, non c'è nulla del genere. Poi scusa, quello che dici vorrebbe dire che: dati dei punti vuoi determinare la funzione es. y = 3x^2 + 4x + 1 ? Questo è altamente complesso, non credo sia "banale".

[vegetablu]

Esiste dove? Nel framework standard? Sicuramente no, non c'è nulla del genere. Poi scusa, quello che dici vorrebbe dire che: dati dei punti vuoi determinare la funzione es. y = 3x^2 + 4x + 1 ? Questo è altamente complesso, non credo sia "banale".

Si intendevo proprio questo.
Dati dei punti (x1,y1), (x2,y2), ......., (xn,yn) trovare la funzione interpolante.

Quindi non esiste ed è molto complesso fare una cosa del genere?

Grazie

[Andrea1979]

Se si sta parlando di interpolazione polinomiale
https://en.wikipedia.org/wiki/Polynomial_interpolation

non ti resta che compilare la matrice di Vandermonde.

Commons di apache ha una libreria (math) che ti linko qui:

http://commons.apache.org/proper/commons-math/

che ha già implementato ogni cosa. Ti riporto un piccolo esempio da cui articolare

import org.apache.commons.math3.linear.*;

/* ....
.... 
*/
private RealMatrix VandermondeMatrix;
private RealVector Constants, CoefficientsMatrix;
private int degree;
    
    private RealMatrix calculateVandermondeMatrix() {
        double[][] values = new double[degree+1][degree+1];
        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < (values[i].length-1); j++) {
                values[i][j] = Math.pow(points[i].getX(), degree-j);
            }
            values[i][degree] = 1;
        }
        VandermondeMatrix = new Array2DRowRealMatrix(values);
        return VandermondeMatrix;
    }


    private RealVector getConstants() {
        double[] values = new double[degree+1];
        for (int i = 0; i < values.length; i++) {
            values[i] = points[i].getY();
        }
        Constants = new ArrayRealVector(values) ;
        return Constants;
    }
    
    private RealVector calculateCoefficientsMatrix() {
        DecompositionSolver solver = new LUDecomposition(this.VandermondeMatrix).getSolver();
        return solver.solve(Constants);
    }




public PolynomialInterpolation(Point[] points) {
        this.points = points;        
        this.degree = points.length-1;
    }

dove la classe Point (in realtà inutile, ma visto che ho riutilizzato codice di un vecchio progetto me la sono trovata tra i piedi) altro non è che una classe che modellizza un punto nel piano (2D) e che ha solo due campi, x, y e metodi getter e setter.

[vegetablu]

Se si sta parlando di interpolazione polinomiale
https://en.wikipedia.org/wiki/Polynomial_interpolation

non ti resta che compilare la matrice di Vandermonde.

Commons di apache ha una libreria (math) che ti linko qui:

http://commons.apache.org/proper/commons-math/

che ha già implementato ogni cosa. Ti riporto un piccolo esempio da cui articolare

import org.apache.commons.math3.linear.*;

/* ....
.... 
*/
private RealMatrix VandermondeMatrix;
private RealVector Constants, CoefficientsMatrix;
private int degree;
    
    private RealMatrix calculateVandermondeMatrix() {
        double[][] values = new double[degree+1][degree+1];
        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < (values[i].length-1); j++) {
                values[i][j] = Math.pow(points[i].getX(), degree-j);
            }
            values[i][degree] = 1;
        }
        VandermondeMatrix = new Array2DRowRealMatrix(values);
        return VandermondeMatrix;
    }


    private RealVector getConstants() {
        double[] values = new double[degree+1];
        for (int i = 0; i < values.length; i++) {
            values[i] = points[i].getY();
        }
        Constants = new ArrayRealVector(values) ;
        return Constants;
    }
    
    private RealVector calculateCoefficientsMatrix() {
        DecompositionSolver solver = new LUDecomposition(this.VandermondeMatrix).getSolver();
        return solver.solve(Constants);
    }




public PolynomialInterpolation(Point[] points) {
        this.points = points;        
        this.degree = points.length-1;
    }

dove la classe Point (in realtà inutile, ma visto che ho riutilizzato codice di un vecchio progetto me la sono trovata tra i piedi) altro non è che una classe che modellizza un punto nel piano (2D) e che ha solo due campi, x, y e metodi getter e setter.

Grazie.
Mi basta inserire i miei punti dentro una matrice e passarla alla funzione
PolynomialInterpolation ??
Ma come parametro riceve un Point (teoricamente è una matrice)?
Non lo so, ma mi sono confuso ahahhaha.

Inoltre, a che mi serve il getConstants e il calculateCoefficientsMatrix() ??

Forse questi metodi valgono per il tuo progetto, giusto? A me serve prendere spunto solo dalle formule della matrice di Vandermonde ?

[Andrea1979]

Ok, faccio prima a scriverti un esempio completo:

package interpolation;


import org.apache.commons.math3.linear.*;


/**
 *
 * @author Andrea
 */
public class PolynomialInterpolation {    
    
    private Point[] points;
    private RealMatrix VandermondeMatrix;
    private RealVector Constants, CoefficientsMatrix;
    private int degree;
    
    private RealMatrix calculateVandermondeMatrix() {
        double[][] values = new double[degree+1][degree+1];
        for (int i = 0; i < values.length; i++) {
            for (int j = 0; j < (values[i].length-1); j++) {
                values[i][j] = Math.pow(points[i].getX(), degree-j);
            }
            values[i][degree] = 1;
        }
        VandermondeMatrix = new Array2DRowRealMatrix(values);
        return VandermondeMatrix;
    }


    private RealVector getConstants() {
        double[] values = new double[degree+1];
        for (int i = 0; i < values.length; i++) {
            values[i] = points[i].getY();
        }
        Constants = new ArrayRealVector(values) ;
        return Constants;
    }
    
    private RealVector calculateCoefficientsMatrix() {
        DecompositionSolver solver = new LUDecomposition(this.VandermondeMatrix).getSolver();
        return solver.solve(Constants);
    }
    
    public PolynomialInterpolation(Point[] points) {
        this.points = points;        
        this.degree = points.length-1;
        VandermondeMatrix = this.calculateVandermondeMatrix();
        Constants = this.getConstants();
        CoefficientsMatrix = this.calculateCoefficientsMatrix();
    }
    
    public PolynomialInterpolation() {
        this(new Point[]{
            new Point(0,1), 
            new Point (2,5)
        });
    }
    
    public String toString() {        
        double[] coeff = CoefficientsMatrix.toArray();        
        StringBuffer buf = new StringBuffer();
        String sign;
        String exp;
        double pivot;
        for (int i = degree; i >= 0; i--) {
            pivot = coeff[coeff.length-i-1];            
            //sign = (pivot > 0 ? "+" : (pivot < 0 ? "-" : ""));
            sign = (pivot > 0 ? "+" : "");
            exp = (i == 1 ? "x" : "x^"+i);
            buf.append(i != 0 ? (" "+sign+pivot+exp+" ") : " "+sign+pivot);
        }        
        return buf.toString();
    }
    
    public static void main (String[] args) {
        
        PolynomialInterpolation pi = new PolynomialInterpolation(new Point[] {
            new Point (0, 1), 
            new Point (2, 5),
            new Point (3, -6)
        });
        
        /*
        PolynomialInterpolation pi = new PolynomialInterpolation(new Point[] {
            new Point (0, 0),
            new Point (1, 0.8415),
            new Point (2, 0.9093),
            new Point (3, 0.1411),
            new Point (4, -0.7568),
            new Point (5, -0.9589),
            new Point (6, -0.2794)
        });
        */
        String result = pi.toString();
        System.out.println(result);
        
    }
    
}

e questa è la classe Point

package interpolation;


/**
 *
 * @author Andrea
 */
public class Point {
    
        double x;
        double y;
        
        public double getX() {
            return this.x;
        }
        
        public double getY() {
            return this.y;
        }
        
        public void setX (double x) {
            this.x = x;
        }
        
        public void setY (double y) {
            this.y = y;
        }
        
        public Point (double x, double y) {
            this.x = x;
            this.y = y;
        }
        
        public String toString() {
            return new String("["+x+" , "+y+"]");
        }
    }

Per inciso, la parte commentata relativa all'interpolazione di 6 punti, usa i dati trovati sulla pagina di wikipedia:

https://it.wikipedia.org/wiki/Interp...ne_polinomiale

e come potrai verificare ritorna (in notazione scientifica) i risultati che trovi nella pagina stessa.

Venendo ai tuoi dubbi: tu hai una serie di punti (specifica del tuo progetto nel primo messaggio), ed io parto da una serie di punti (array di Point). Ti vuoi una funziona interpolatrice (assunto: un polinomio) ed lì hai una matrice (array) coefficientMatrix che rappresenta i coefficienti del tuo polinomio interpolatore. Il resto sono metodi di appoggio