// Decompiled by JAD v1.5.4.3. Copyright 1997-98 Pavel Kouznetsov.// JAD Home Page:      http://web.unicom.com.cy/~kpd/jad.html// Decompiler options: packimports(3) // Source File Name:   RBFunction.java// Decompiled by S.Baehni in order to be compliant with Java1.2import java.awt.Color;class Network{    public double[] trainnet(GaussCenter agausscenter[], DataPoints datapoints)    {        double ad[] = new double[agausscenter.length];        if(datapoints.count == 0 || datapoints.count < agausscenter.length)        {            RBFunction.statusMesg("Please add more training points (atleast as many as number of centers).");            ad[0] = -1000D;            return ad;        }        double ad1[][] = new double[datapoints.count][agausscenter.length];        for(int i = 0; i < datapoints.count; i++)        {            for(int j = 0; j < agausscenter.length; j++)                ad1[i][j] = agausscenter[j].eval(datapoints.data[i][0]);        }        double ad2[] = new double[datapoints.data.length];        for(int k = 0; k < datapoints.data.length; k++)            ad2[k] = datapoints.data[k][1];        ad = pinvsoln(ad1, ad2);        return ad;    }    public void plotoutput(double ad[], GaussCenter agausscenter[], DataDisp datadisp, double ad1[])    {        double ad2[][] = new double[ad1.length][2];        for(int i = 0; i < ad1.length; i++)        {            ad2[i][0] = ad1[i];            ad2[i][1] = 0.0D;        }        double ad4[][] = new double[ad1.length][2];        for(int j = 0; j < agausscenter.length; j++)        {            double ad3[] = agausscenter[j].eval(ad1);            for(int k = 0; k < ad1.length; k++)            {                ad2[k][1] += ad[j] * ad3[k];                ad4[k][0] = ad1[k];                ad4[k][1] = ad[j] * ad3[k];            }            datadisp.drawcurve(ad4, Color.green);        }        datadisp.drawcurve(ad2, Color.red);    }    private double[] pinvsoln(double ad[][], double ad1[])    {        double ad2[] = new double[ad.length + 1];        double ad3[][] = mattonr(ad);        double ad4[] = vectonr(ad1);        double ad5[][] = new double[ad[0].length + 1][ad[0].length + 1];        double ad6[] = new double[ad[0].length + 1];        svdcmp(ad3, ad.length, ad[0].length, ad6, ad5);        svbksb(ad3, ad6, ad5, ad.length, ad[0].length, ad4, ad2);        return vecfromnr(ad2);    }    private double[] vectonr(double ad[])    {        double ad1[] = new double[ad.length + 1];        for(int i = 0; i < ad.length; i++)            ad1[i + 1] = ad[i];        return ad1;    }    private double[] vecfromnr(double ad[])    {        double ad1[] = new double[ad.length - 1];        for(int i = 0; i < ad.length - 1; i++)            ad1[i] = ad[i + 1];        return ad1;    }    private double[][] mattonr(double ad[][])    {        double ad1[][] = new double[ad.length + 1][ad[0].length + 1];        for(int i = 0; i < ad.length; i++)        {            for(int j = 0; j < ad[0].length; j++)                ad1[i + 1][j + 1] = ad[i][j];        }        return ad1;    }    private double[][] matfromnr(double ad[][])    {        double ad1[][] = new double[ad.length - 1][ad[0].length - 1];        for(int i = 0; i < ad.length - 1; i++)        {            for(int j = 0; j < ad[0].length - 1; j++)                ad1[i][j] = ad[i + 1][j + 1];        }        return ad1;    }    private void svdcmp(double ad[][], int i, int j, double ad1[], double ad2[][])    {        int k9 = 1;        int j10 = 1;        double ad3[] = new double[j + 1];        double d;        double d25;        double d9 = d25 = d = 0.0D;        for(int k = 1; k <= j; k++)        {            k9 = k + 1;            ad3[k] = d25 * d9;            double d19;            d9 = d19 = d25 = 0.0D;            if(k <= i)            {                for(int k5 = k; k5 <= i; k5++)                    d25 += Math.abs(ad[k5][k]);                if(d25 != 0.0D)                {                    for(int l5 = k; l5 <= i; l5++)                    {                        ad[l5][k] /= d25;                        d19 += ad[l5][k] * ad[l5][k];                    }                    double d3 = ad[k][k];                    d9 = -sign(Math.sqrt(d19), d3);                    double d14 = d3 * d9 - d19;                    ad[k][k] = d3 - d9;                    for(int i2 = k9; i2 <= j; i2++)                    {                        d19 = 0.0D;                        for(int i6 = k; i6 <= i; i6++)                            d19 += ad[i6][k] * ad[i6][i2];                        double d4 = d19 / d14;                        for(int j6 = k; j6 <= i; j6++)                            ad[j6][i2] += d4 * ad[j6][k];                    }                    for(int k6 = k; k6 <= i; k6++)                        ad[k6][k] *= d25;                }            }            ad1[k] = d25 * d9;            d9 = d19 = d25 = 0.0D;            if(k <= i && k != j)            {                for(int l6 = k9; l6 <= j; l6++)                    d25 += Math.abs(ad[k][l6]);                if(d25 != 0.0D)                {                    for(int i7 = k9; i7 <= j; i7++)                    {                        ad[k][i7] /= d25;                        d19 += ad[k][i7] * ad[k][i7];                    }                    double d5 = ad[k][k9];                    d9 = -sign(Math.sqrt(d19), d5);                    double d15 = d5 * d9 - d19;                    ad[k][k9] = d5 - d9;                    for(int j7 = k9; j7 <= j; j7++)                        ad3[j7] = ad[k][j7] / d15;                    for(int j2 = k9; j2 <= i; j2++)                    {                        double d20 = 0.0D;                        for(int k7 = k9; k7 <= j; k7++)                            d20 += ad[j2][k7] * ad[k][k7];                        for(int l7 = k9; l7 <= j; l7++)                            ad[j2][l7] += d20 * ad3[l7];                    }                    for(int i8 = k9; i8 <= j; i8++)                        ad[k][i8] *= d25;                }            }            d = Math.max(d, Math.abs(ad1[k]) + Math.abs(ad3[k]));        }        for(int l = j; l >= 1; l--)        {            if(l < j)            {                if(d9 != 0.0D)                {                    for(int k2 = k9; k2 <= j; k2++)                        ad2[k2][l] = ad[l][k2] / ad[l][k9] / d9;                    for(int l2 = k9; l2 <= j; l2++)                    {                        double d21 = 0.0D;                        for(int j8 = k9; j8 <= j; j8++)                            d21 += ad[l][j8] * ad2[j8][l2];                        for(int k8 = k9; k8 <= j; k8++)                            ad2[k8][l2] += d21 * ad2[k8][l];                    }                }                for(int i3 = k9; i3 <= j; i3++)                    ad2[l][i3] = ad2[i3][l] = 0.0D;            }            ad2[l][l] = 1.0D;            d9 = ad3[l];            k9 = l;        }        for(int i1 = Math.min(i, j); i1 >= 1; i1--)        {            int l9 = i1 + 1;            double d10 = ad1[i1];            for(int j3 = l9; j3 <= j; j3++)                ad[i1][j3] = 0.0D;            if(d10 != 0.0D)            {                d10 = 1.0D / d10;                for(int k3 = l9; k3 <= j; k3++)                {                    double d22 = 0.0D;                    for(int l8 = l9; l8 <= i; l8++)                        d22 += ad[l8][i1] * ad[l8][k3];                    double d6 = (d22 / ad[i1][i1]) * d10;                    for(int i9 = i1; i9 <= i; i9++)                        ad[i9][k3] += d6 * ad[i9][i1];                }                for(int l3 = i1; l3 <= i; l3++)                    ad[l3][i1] *= d10;            }            else            {                for(int i4 = i1; i4 <= i; i4++)                    ad[i4][i1] = 0.0D;            }            ad[i1][i1]++;        }        for(int j9 = j; j9 >= 1; j9--)        {            for(int l1 = 1; l1 <= 30; l1++)            {                boolean flag = true;                int i10;                for(i10 = j9; i10 >= 1; i10--)                {                    j10 = i10 - 1;                    if(Math.abs(ad3[i10]) + d == d)                    {                        flag = false;                        break;                    }                    if(Math.abs(ad1[j10]) + d == d)                        break;                }                if(flag)                {                    double d1 = 0.0D;                    double d23 = 1.0D;                    for(int j1 = i10; j1 <= j9; j1++)                    {                        double d7 = d23 * ad3[j1];                        ad3[j1] = d1 * ad3[j1];                        if(Math.abs(d7) + d == d)                            break;                        double d11 = ad1[j1];                        double d16 = pythag(d7, d11);                        ad1[j1] = d16;                        d16 = 1.0D / d16;                        d1 = d11 * d16;                        d23 = -d7 * d16;                        for(int j4 = 1; j4 <= i; j4++)                        {                            double d27 = ad[j4][j10];                            double d31 = ad[j4][j1];                            ad[j4][j10] = d27 * d1 + d31 * d23;                            ad[j4][j1] = d31 * d1 - d27 * d23;                        }                    }                }                double d32 = ad1[j9];                if(i10 == j9)                {                    if(d32 < 0.0D)                    {                        ad1[j9] = -d32;                        for(int k4 = 1; k4 <= j; k4++)                            ad2[k4][j9] = -ad2[k4][j9];                    }                    break;                }                if(l1 == 30)                    RBFunction.statusMesg("Singular Value Decomposition for the pseudo-inverse has not converged in 30 iterations.");                double d26 = ad1[i10];                j10 = j9 - 1;                double d28 = ad1[j10];                double d12 = ad3[j10];                double d17 = ad3[j9];                double d8 = ((d28 - d32) * (d28 + d32) + (d12 - d17) * (d12 + d17)) / (2D * d17 * d28);                d12 = pythag(d8, 1.0D);                d8 = ((d26 - d32) * (d26 + d32) + d17 * (d28 / (d8 + sign(d12, d8)) - d17)) / d26;                double d24;                double d2 = d24 = 1.0D;                for(int l4 = i10; l4 <= j10; l4++)                {                    int k1 = l4 + 1;                    double d13 = ad3[k1];                    double d29 = ad1[k1];                    double d18 = d24 * d13;                    d13 = d2 * d13;                    double d33 = pythag(d8, d18);                    ad3[l4] = d33;                    d2 = d8 / d33;                    d24 = d18 / d33;                    d8 = d26 * d2 + d13 * d24;                    d13 = d13 * d2 - d26 * d24;                    d18 = d29 * d24;                    d29 *= d2;                    for(int i5 = 1; i5 <= j; i5++)                    {                        d26 = ad2[i5][l4];                        d33 = ad2[i5][k1];                        ad2[i5][l4] = d26 * d2 + d33 * d24;                        ad2[i5][k1] = d33 * d2 - d26 * d24;                    }                    d33 = pythag(d8, d18);                    ad1[l4] = d33;                    if(d33 != 0.0D)                    {                        d33 = 1.0D / d33;                        d2 = d8 * d33;                        d24 = d18 * d33;                    }                    d8 = d2 * d13 + d24 * d29;                    d26 = d2 * d29 - d24 * d13;                    for(int j5 = 1; j5 <= i; j5++)                    {                        double d30 = ad[j5][l4];                        double d34 = ad[j5][k1];                        ad[j5][l4] = d30 * d2 + d34 * d24;                        ad[j5][k1] = d34 * d2 - d30 * d24;                    }                }                ad3[i10] = 0.0D;                ad3[j9] = d8;                ad1[j9] = d26;            }        }    }    private void svbksb(double ad[][], double ad1[], double ad2[][], int i, int j, double ad3[], double ad4[])    {        double ad5[] = new double[j + 1];        for(int l = 1; l <= j; l++)        {            double d = 0.0D;            if(ad1[l] != 0.0D)            {                for(int j1 = 1; j1 <= i; j1++)                    d += ad[j1][l] * ad3[j1];                d /= ad1[l];            }            ad5[l] = d;        }        for(int i1 = 1; i1 <= j; i1++)        {            double d1 = 0.0D;            for(int k = 1; k <= j; k++)                d1 += ad2[i1][k] * ad5[k];            ad4[i1] = d1;        }    }    private double pythag(double d, double d1)    {        double d2 = Math.abs(d);        double d3 = Math.abs(d1);        if(d2 > d3)            return d2 * Math.sqrt(1.0D + sqr(d3 / d2));        if(d3 == 0.0D)            return 0.0D;        else            return d3 * Math.sqrt(1.0D + sqr(d2 / d3));    }    private double sqr(double d)    {        if(d == 0.0D)            return 0.0D;        else            return d * d;    }    private double sign(double d, double d1)    {        if(d1 >= 0.0D)            return Math.abs(d);        else            return -Math.abs(d);    }    Network()    {    }    public static final double BADDATA = -1000D;}