network.java

This program demonstrates some function approximation capabilities of a Radial Basis Function Networ

// 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.2

import 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;
}