ecrealindividual.java

用Java实现的粒子群优化算法

// Decompiled by Jad v1.5.7f. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   ECRealIndividual.java

package ci.ec.real;

import ci.ec.function.ECFunctions;
import ci.real.RealIndividual;
import java.io.PrintStream;

public class ECRealIndividual extends RealIndividual
    implements ECFunctions
{

    public ECRealIndividual()
    {
    }

    public ECRealIndividual(int i)
    {
        super(i);
    }

    public ECRealIndividual(double ad[])
    {
        super(ad);
    }

    public static void main(String args[])
    {
        ECRealIndividual ecrealindividual = new ECRealIndividual(3);
        System.out.println("firt real individual before initialization \n" + ecrealindividual);
        ecrealindividual.initialization(5D);
        System.out.println("first real individual after initialization \n" + ecrealindividual);
        ECRealIndividual ecrealindividual1 = new ECRealIndividual(3);
        System.out.println("second real individual before copy \n" + ecrealindividual1);
        ecrealindividual1.copyof(ecrealindividual);
        System.out.println("second real individual after copy \n" + ecrealindividual1);
        System.out.println("first real individual after copy \n" + ecrealindividual);
        ECRealIndividual ecrealindividual2 = new ECRealIndividual(3);
        ecrealindividual2.addTwo(ecrealindividual, ecrealindividual1);
        System.out.println("third real individual ri1+ri2\n" + ecrealindividual2);
        ecrealindividual2.multiply(2D);
        System.out.println("third real individual multiplied by 2\n" + ecrealindividual2);
        ecrealindividual2.divide(2D);
        System.out.println("third real individual divided by 2 \n" + ecrealindividual2);
        ecrealindividual2.add(ecrealindividual1);
        System.out.println("third real individual add with second \n" + ecrealindividual2);
        ECRealIndividual ecrealindividual3 = new ECRealIndividual(3);
        ecrealindividual3.substractTwo(ecrealindividual2, ecrealindividual1);
        System.out.println("fourth equals = third  - second \n" + ecrealindividual3);
        ecrealindividual2.substract(ecrealindividual1);
        System.out.println("third equals = third -second \n" + ecrealindividual2);
        double d = ecrealindividual2.sphere(10);
        System.out.println("return value of sphere(): " + d + "\n");
    }

    public double evaluate(String s, int i)
    {
        double d = 0.0D;
        if(s.equals("Sphere"))
            d = sphere(i);
        else
        if(s.equals("Rosenbrock"))
            d = rosenbrock(i);
        else
        if(s.equals("Rastrigrin"))
            d = rastrigrin(i);
        else
        if(s.equals("Griewank"))
            d = griewank(i);
        else
        if(s.equals("DeJong F4"))
            d = dejongf4(i);
        else
        if(s.equals("DeJong F4 with noise"))
            d = dejongf4noise(i);
        else
        if(s.equals("Ackley"))
            d = ackley(i);
        else
        if(s.equals("Koon F3"))
            d = koonf3(i);
        else
        if(s.equals("Bohachevsky"))
            d = bohachevsky();
        else
        if(s.equals("Colville"))
            d = colville();
        else
        if(s.equals("GoldsteinP"))
            d = goldsteinp();
        else
        if(s.equals("Easom"))
            d = easom();
        else
        if(s.equals("Floudas"))
            d = floudas();
        else
        if(s.equals("Beale"))
            d = beale();
        else
        if(s.equals("Matyas"))
            d = matyas();
        else
        if(s.equals("Zettl"))
        {
            d = zettl();
        } else
        {
            System.out.println("no such function\n");
            System.exit(0);
        }
        return d;
    }

    public double sphere(int i)
    {
        if(i != length)
        {
            System.out.println("Sphere function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        for(int j = 0; j < i; j++)
            d += elements[j] * elements[j];

        return d;
    }

    public double rosenbrock(int i)
    {
        if(i != length)
        {
            System.out.println("Rosenbrock function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        for(int j = 0; j < i - 1; j++)
        {
            double d1 = elements[j + 1] - elements[j] * elements[j];
            d1 *= d1;
            d1 *= 100D;
            d1 += (elements[j] - 1.0D) * (elements[j] - 1.0D);
            d += d1;
        }

        return d;
    }

    public double rastrigrin(int i)
    {
        if(i != length)
        {
            System.out.println("Rastrigrin function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        for(int j = 0; j < i; j++)
        {
            double d1 = 10D * Math.cos(6.2831853071795862D * elements[j]);
            d1 = elements[j] * elements[j] - d1;
            d1 += 10D;
            d += d1;
        }

        return d;
    }

    public double griewank(int i)
    {
        if(i != length)
        {
            System.out.println("Griewank function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        double d1 = 0.0D;
        for(int j = 0; j < i; j++)
        {
            d += elements[j] * elements[j];
            d1 *= Math.cos(elements[j] / Math.sqrt(j + 1));
        }

        d = (d / 4000D - d1) + 1.0D;
        return d;
    }

    public double dejongf4(int i)
    {
        if(i != length)
        {
            System.out.println("DeJong F4 function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        for(int j = 0; j < i; j++)
            d += ((double)j + 1.0D) * Math.pow(elements[j], 4D);

        return d;
    }

    public double dejongf4noise(int i)
    {
        if(i != length)
        {
            System.out.println("DeJong F4 function with noise dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        for(int j = 0; j < i; j++)
            d += ((double)j + 1.0D) * Math.pow(elements[j], 4D) + Math.random();

        return d;
    }

    public double ackley(int i)
    {
        if(i != length)
        {
            System.out.println("Ackley function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        double d1 = 0.0D;
        for(int j = 0; j < i; j++)
        {
            d += elements[j] * elements[j];
            d1 += Math.cos(6.2831853071795862D * elements[j]);
        }

        d /= i;
        d = -0.20000000000000001D * Math.sqrt(d);
        d = -20D * Math.pow(2.7182818284590451D, d);
        d1 /= i;
        d1 = -1D * Math.pow(2.7182818284590451D, d1);
        d += d1 + 20D + 2.7182818284590451D;
        return d;
    }

    public double koonf3(int i)
    {
        if(i != length)
        {
            System.out.println("Koon F3 function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        for(int j = 0; j < i; j++)
            d += (Math.pow(elements[j], 4D) - 16D * Math.pow(elements[j], 2D)) + 5D * elements[j];

        return d / 2D;
    }

    public double bohachevsky()
    {
        if(length != 2)
        {
            System.out.println("Bohachevsky function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        d = elements[0] * elements[0] + 2D * elements[1] * elements[1];
        d += -0.29999999999999999D * Math.cos(9.4247779607693793D * elements[0]) * Math.cos(12.566370614359172D * elements[1]);
        d += 0.29999999999999999D;
        return d;
    }

    public double colville()
    {
        if(length != 4)
        {
            System.out.println("Colville function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        double d1 = elements[0] * elements[0] - elements[1];
        d = 100D * d1 * d1;
        d1 = 1.0D - elements[0];
        d1 *= d1;
        d += d1;
        d1 = elements[3] - elements[2] * elements[2];
        d1 = 90D * d1 * d1;
        d += d1;
        d1 = (1.0D - elements[2]) * (1.0D - elements[2]);
        d += d1;
        d1 = 0.10000000000000001D * ((elements[1] - 1.0D) * (elements[1] - 1.0D) + (elements[3] - 1.0D) * (elements[3] - 1.0D));
        d += d1;
        d1 = 19.800000000000001D * (elements[1] - 1.0D) * (elements[3] - 1.0D);
        d += d1;
        return d;
    }

    public double goldsteinp()
    {
        if(length != 2)
        {
            System.out.println("GoldsteinP function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        double d1 = 0.0D;
        d = (19D - 14D * (elements[0] + elements[1])) + 3D * Math.pow(elements[0], 2D);
        d += 6D * elements[0] * elements[1];
        d += 3D * Math.pow(elements[1], 2D);
        d *= Math.pow(elements[0] + elements[1] + 1.0D, 2D);
        d++;
        d1 = (18D - 32D * elements[0]) + 12D * Math.pow(elements[0], 2D) + 48D * elements[1];
        d1 -= 36D * elements[0] * elements[1];
        d1 += 27D * Math.pow(elements[1], 2D);
        d1 *= Math.pow(2D * elements[0] - 3D * elements[1], 2D);
        d1 += 30D;
        d *= d1;
        return d;
    }

    public double easom()
    {
        if(length != 2)
        {
            System.out.println("Easom function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        double d1 = 0.0D;
        d = -1D * Math.cos(elements[0]) * Math.cos(elements[1]);
        d1 = -1D * Math.pow(elements[0] - 3.1415926535897931D, 2D) - Math.pow(elements[1] - 3.1415926535897931D, 2D);
        d1 = Math.pow(2.7182818284590451D, d1);
        d *= d1;
        return d;
    }

    public double floudas()
    {
        if(length != 5)
        {
            System.out.println("Floudas function dimension not match\n");
            System.exit(0);
        }
        double d = -5D;
        double d1 = -1D;
        for(int i = 0; i < 5; i++)
        {
            d *= Math.sin(elements[i]);
            d1 *= Math.sin(5D * elements[i]);
        }

        d += d1;
        return d;
    }

    public double beale()
    {
        if(length != 2)
        {
            System.out.println("Beale function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        double d1 = 0.0D;
        double d2 = 0.0D;
        d = 1.5D - elements[0] * (1.0D - elements[1]);
        d = Math.pow(d, 2D);
        d1 = 2.25D - elements[0] * (1.0D - Math.pow(elements[1], 2D));
        d1 = Math.pow(d1, 2D);
        d2 = 2.625D - elements[0] * (1.0D - Math.pow(elements[1], 3D));
        d2 = Math.pow(d2, 2D);
        d += d1 + d2;
        return d;
    }

    public double matyas()
    {
        if(length != 2)
        {
            System.out.println("Matyas function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        d = 0.26000000000000001D * (Math.pow(elements[0], 2D) + Math.pow(elements[1], 2D)) - 0.47999999999999998D * elements[0] * elements[1];
        return d;
    }

    public double zettl()
    {
        if(length != 2)
        {
            System.out.println("Zettl function dimension not match\n");
            System.exit(0);
        }
        double d = 0.0D;
        d = (Math.pow(elements[0], 2D) + Math.pow(elements[1], 2D)) - 2D * elements[0];
        d = Math.pow(d, 2D);
        d += 0.25D * elements[0];
        return d;
    }
}