package com.dam.heuristic.afas.test;
import java.io.Serializable;
import java.util.Random;
/**
 * 人工鱼
 */
public class Fish implements Serializable {
    //记录位置的维度(x,y,z,……)
    private int dimension;
    //记录位置
    private double[] position;
    //鱼的适应度
    private double fitness;
    //位置每个维度坐标的区间
    private double[][] axisScopeArr;
    //目标函数是否为取最大值
    private boolean isGetMax;
    public Fish(int dimension, double[][] axisScopeArr, boolean isGetMax) {
        this.dimension = dimension;
        this.position = new double[this.dimension];
        this.axisScopeArr = axisScopeArr;
        this.isGetMax = isGetMax;
        this.fitness = 0;
    }
    /**
     * 初始化鱼的位置及适应度
     */
    public void initFishMessage() {
        Random random = new Random();
        //初始化位置
        for (int i = 0; i < this.dimension; i++) {
            position[i] = random.nextDouble() * (this.axisScopeArr[i][1] - this.axisScopeArr[i][0]) + this.axisScopeArr[i][0];
        }
        //初始化适应度
        this.fitness = new ObjectFunction().objectFunction(position,this.isGetMax);
    }
    public int getDimension() {
        return dimension;
    }
    public void setDimension(int dimension) {
        this.dimension = dimension;
    }
    public double[] getPosition() {
        return position;
    }
    public void setPosition(double[] position) {
        this.position = position;
    }
    public double getFitness() {
        return fitness;
    }
    public void setFitness(double fitness) {
        this.fitness = fitness;
    }
}

package com.dam.heuristic.afas.test;
public class ObjectFunction {
    /**
     * 目标函数
     * 由于所举例子的目标函数的目标是最小化，适应度则是越大越好，因此这里需要取负值
     *
     * @param position
     * @param isGetMax 是否获取函数的最大值
     * @return
     */
    public double objectFunction(double[] position, boolean isGetMax) {
        //目标：在变量区间范围最小化 y=x^2+y^2-xy-10x-4y+60
        double value = Math.pow(position[0], 2) + Math.pow(position[1], 2) - position[0] * position[1] - 10 * position[0] - 4 * position[1] + 60;
        if (isGetMax == false) {
            return -value;
        } else {
            return value;
        }
    }
}

package com.dam.heuristic.afas.test;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class AfasApi {
    //鱼群中鱼的数量
    private int fishNum;
    //尝试次数，该数越大，鱼的觅食能力越强，收敛速度越快
    private int tryNum;
    //维度
    private int dimension;
    //鱼的移动步长
    private double stepLen;
    //拥挤度因子（delta=1/(random.nextDouble()*maxFishNum)：maxFishNum为鱼的视野范围内最大的鱼的总数量）
    //当delta越大时，拥挤程度越小，鱼更难聚在一起，因此容易跳出局部最优，但是也会让其他鱼不想过来，造成找到的解不能精确逼近最优解
    private double delta;
    //鱼的视野范围
    private double visual;
    //迭代次数
    private int genNum;
    //目标函数是否为取最大值
    private boolean isGetMax;
    //位置每个维度坐标的区间
    private double[][] axisScopeArr;
    public AfasApi(int fishNum, int tryNum, double stepLen, double delta, double visual, int genNum, boolean isGetMax, double[][] axisScopeArr) {
        this.fishNum = fishNum;
        this.tryNum = tryNum;
        this.dimension = axisScopeArr[0].length;
        this.stepLen = stepLen;
        this.delta = delta;
        this.visual = visual;
        this.genNum = genNum;
        this.isGetMax = isGetMax;
        this.axisScopeArr = axisScopeArr;
    }
    public double[][][] solve() {
        变量声明
        long start = System.currentTimeMillis();
        //鱼群
        Fish[] fishArr;
        //最好的鱼
        Fish bestFish;
        //存储觅食、聚群、追尾所找到的最优鱼
        Fish[] nextFishArr;
        //随机数工具类
        Random random = new Random();
        //目标函数类
        ObjectFunction objectFunction = new ObjectFunction();
        //存储每一代鱼所在位置
        double[][][] positionArr = new double[this.genNum][this.fishNum][this.dimension];
        初始化鱼群
        //初始化最优鱼
        bestFish = new Fish(this.dimension, this.axisScopeArr, isGetMax);
        //初始化最优鱼的适应度为很小的值，说明当前最优鱼不咋的
        bestFish.setFitness(-Double.MAX_VALUE);
        fishArr = new Fish[this.fishNum];
        for (int i = 0; i < this.fishNum; i++) {
            //创建鱼
            fishArr[i] = new Fish(this.dimension, this.axisScopeArr, isGetMax);
            //初始化鱼的位置及适应度
            fishArr[i].initFishMessage();
            //更新初始最优鱼
            if (fishArr[i].getFitness() > bestFish.getFitness()) {
                bestFish = (Fish) deepClone(fishArr[i]);
            }
        }
        //初始化（觅食、聚群、追尾）所找到的最优鱼数组，三种方式
        nextFishArr = new Fish[3];
        求解
        for (int t = 0; t < this.genNum; t++) {
            for (int i = 0; i < this.fishNum; i++) {
//                System.out.println("找位置--------------------------------------------------------------------------");
                //自己出门觅觅食，万一找到什么好地方就爽了
                this.foraging(fishArr, nextFishArr, i, random, objectFunction, 0);
                //找到第i条鱼视野范围内的小鱼群
                List<Fish> fishNearingFishIList = this.findFishArrNearFishI(i, fishArr);
                //如果鱼群的中间吃的比较多，又不太挤，就跟着去看看
                this.cluster(fishArr, nextFishArr, i, fishNearingFishIList, random, objectFunction);
                //看一下哪条小鱼仔吃得比较好，旁边的地方又不太挤，就跟着去看看
                this.follow(fishArr, nextFishArr, i, fishNearingFishIList, random, objectFunction);
                //汇总一下信息，根据所找到的位置选择出最好的位置，再决定去不去
                this.upDateFishPositionAndBestFish(fishArr, nextFishArr, i, bestFish);
                positionArr[t][i] = fishArr[i].getPosition();
            }
        }
        //如果函数求的是最小值，要取负值，因为算法是根据将目标函数取负号并以目标为求最大值来进行求解
        double fitness = this.isGetMax == false ? -bestFish.getFitness() : bestFish.getFitness();
        System.out.println("最优目标函数值：" + String.format("%.6f", fitness));
        System.out.println("最优位置：" + Arrays.toString(bestFish.getPosition()));
        System.out.println("求解时间：" + (System.currentTimeMillis() - start) + "ms");
        return positionArr;
    }
    /**
     * 觅食
     *
     * @param index 由于聚群，追尾时找不到好位置的话，也要觅食，用index来控制所找位置的填充参数
     */
    private void foraging(Fish[] fishArr, Fish[] nextFishArr, int i, Random random, ObjectFunction objectFunction, int index) {
        //该鱼的下一可能位置
        double[] nextPositionOfThisFish = new double[this.dimension];
        //存储所寻找的最优位置
        Fish bestPositionOfThisFish = new Fish(this.dimension, this.axisScopeArr, isGetMax);
        bestPositionOfThisFish.setFitness(-Double.MAX_VALUE);
        // 进行this.tryNum次尝试觅食，选择一个比较好的位置
        for (int j = 0; j < this.tryNum; j++) {
            //让鱼在视野范围内随意走动一下
            for (int k = 0; k < this.dimension; k++) {
                nextPositionOfThisFish[k] = fishArr[i].getPosition()[k] + (2 * (random.nextDouble()) - 1) * this.visual;
            }
            //修正一下位置
            this.fixPosition(nextPositionOfThisFish, this.axisScopeArr);
            //计算一下所走动到的位置的食物如何，即适应度如何
            double nextPositionFitness = objectFunction.objectFunction(nextPositionOfThisFish, this.isGetMax);
            if (nextPositionFitness > fishArr[i].getFitness()) {
                double distance = this.getDistanceOfTwoPositions(fishArr[i].getPosition(), nextPositionOfThisFish);
                for (int k = 0; k < this.dimension; k++) {
                    //fishArr[i].getPosition()[k]：鱼的当前坐标
                    //(nextPositionOfThisFish.getPosition()[k] - fishArr[i].getPosition()[k]) / distance：该方向走的步长/两位置距离(可以结合直角三角形的投影关系进行理解)
                    //this.stepLen * random.nextDouble()：虽然一步可以走这么远，但是鱼不一定要竭尽全力地游，* random.nextDouble()可以让鱼在自己的大长腿范围内随机走一段距离
                    bestPositionOfThisFish.getPosition()[k] =
                            fishArr[i].getPosition()[k] +
                                    ((nextPositionOfThisFish[k] - fishArr[i].getPosition()[k]) / distance)
                                            * this.stepLen * random.nextDouble();
                }
                //设置新位置的适应度
                bestPositionOfThisFish.setFitness(objectFunction.objectFunction(bestPositionOfThisFish.getPosition(), this.isGetMax));
            }
        }
        //存储觅食找到的最优位置
        nextFishArr[index] = bestPositionOfThisFish;
//        System.out.println("通过觅食找到更优位置" + bestPositionOfThisFish.getFitness());
    }
    /**
     * 聚群
     *
     * @param fishArr
     * @param nextFishArr
     * @param i
     * @param random
     * @param objectFunction
     */
    private void cluster(Fish[] fishArr, Fish[] nextFishArr, int i, List<Fish> fishNearingFishIList, Random random, ObjectFunction objectFunction) {
        //存储所寻找的最优位置
        Fish bestPositionOfThisFish = new Fish(this.dimension, this.axisScopeArr, this.isGetMax);
        bestPositionOfThisFish.setFitness(-Double.MAX_VALUE);
        //鱼群的中心位置
        double[] centerPosition = new double[this.dimension];
        for (int k = 0; k < this.dimension; k++) {
            centerPosition[k] = 0;
        }
        if (fishNearingFishIList.size() > 0) {
            //计算小鱼群的中心位置
            for (int j = 0; j < fishNearingFishIList.size(); j++) {
                for (int k = 0; k < this.dimension; ++k) {
                    centerPosition[k] += fishNearingFishIList.get(j).getPosition()[k];
                }
            }
            //人工鱼的中心位置(各维度位置的平均值)
            for (int k = 0; k < this.dimension; k++) {
                centerPosition[k] /= fishNearingFishIList.size();
            }
            //修正一下位置
            this.fixPosition(centerPosition, this.axisScopeArr);
            //求中心位置的适应度
            double centerPositionFitness = objectFunction.objectFunction(centerPosition, this.isGetMax);
            //求中心位置离第i条鱼的距离
            double distance = this.getDistanceOfTwoPositions(fishArr[i].getPosition(), centerPosition);
            //centerPositionFitness / fishNearingFishIList.size() > this.delta * fishArr[i].getFitness()：看一下要去的地方性价比怎么样
            //就算那里伙食很好，住宿条件不太行（鱼太多，贼拥挤），小鱼鱼也懒得去
            if (centerPositionFitness > fishArr[i].getFitness()
                    && centerPositionFitness / fishNearingFishIList.size() > this.delta * fishArr[i].getFitness()) {
                for (int k = 0; k < this.dimension; k++) {
                    bestPositionOfThisFish.getPosition()[k] = fishArr[i].getPosition()[k] +
                            ((centerPosition[k] - fishArr[i].getPosition()[k]) / distance)
                                    * this.stepLen * random.nextDouble();
                }
                //设置新位置的适应度
                bestPositionOfThisFish.setFitness(objectFunction.objectFunction(bestPositionOfThisFish.getPosition(), this.isGetMax));
                //存储聚群找到的最优位置
                nextFishArr[1] = bestPositionOfThisFish;
//                System.out.println("通过聚群找到更优位置" + bestPositionOfThisFish.getFitness());
            } else {
                //找到的中心位置不咋地，不如自己出去觅食
                this.foraging(fishArr, nextFishArr, i, random, objectFunction, 1);
            }
        } else {
            //附近找不到鱼群，只能继续觅食了
            this.foraging(fishArr, nextFishArr, i, random, objectFunction, 1);
        }
    }
    /**
     * 追尾行为
     *
     * @param fishArr
     * @param nextFishArr
     * @param i
     * @param random
     * @param objectFunction
     * @throws IOException
     */
    private void follow(Fish[] fishArr, Fish[] nextFishArr, int i, List<Fish> fishNearingFishIList, Random random, ObjectFunction objectFunction) {
        //存储所寻找的最优位置
        Fish bestPositionOfThisFish = new Fish(this.dimension, this.axisScopeArr, isGetMax);
        bestPositionOfThisFish.setFitness(-Double.MAX_VALUE);
        if (fishNearingFishIList.size() > 0) {
            //存储最优邻居鱼
            Fish bestNeighbourFish = new Fish(this.dimension, this.axisScopeArr, isGetMax);
            //存储最优邻居鱼对应的索引
            int bestNeighbourFishIndex = i;
            //找邻居中适应度最高的那条鱼
            for (int j = 0; j < fishNearingFishIList.size(); j++) {
                if (fishNearingFishIList.get(j).getFitness() > bestNeighbourFish.getFitness()) {
                    bestNeighbourFish.setPosition(fishNearingFishIList.get(j).getPosition().clone());
                    bestNeighbourFishIndex = j;
                }
            }
            //修正一下坐标
            this.fixPosition(bestNeighbourFish.getPosition(), this.axisScopeArr);
            if (bestNeighbourFish.getFitness() < fishArr[i].getFitness()) {
                //邻居鱼不咋地，还是自己去觅食吧
                this.foraging(fishArr, nextFishArr, i, random, objectFunction, 2);
            } else {
                //找到最优邻居鱼旁边的鱼群
                List<Fish> fishArrNearBestNeighbourFish = this.findFishArrNearFishI(bestNeighbourFishIndex, fishArr);
                if (fishArrNearBestNeighbourFish.size() > 0 &&
                        bestNeighbourFish.getFitness() / fishArrNearBestNeighbourFish.size() > this.delta * fishArr[i].getFitness()) {
                    //求第i条鱼和最优邻居鱼之间的距离
                    double distance = this.getDistanceOfTwoPositions(fishArr[i].getPosition(), bestNeighbourFish.getPosition());
                    for (int k = 0; k < this.dimension; k++) {
                        bestPositionOfThisFish.getPosition()[k] = fishArr[i].getPosition()[k]
                                + ((bestNeighbourFish.getPosition()[k] - fishArr[i].getPosition()[k]) / distance)
                                * this.stepLen * random.nextDouble();
                    }
                    //设置新位置的适应度
                    bestPositionOfThisFish.setFitness(objectFunction.objectFunction(bestPositionOfThisFish.getPosition(), this.isGetMax));
                    //存储追尾找到的最优位置
                    nextFishArr[2] = bestPositionOfThisFish;
//                    System.out.println("通过追尾找到更优位置" + bestPositionOfThisFish.getFitness());
                } else {
                    this.foraging(fishArr, nextFishArr, i, random, objectFunction, 2);
                }
            }
        } else {
            this.foraging(fishArr, nextFishArr, i, random, objectFunction, 2);
        }
    }
    /**
     * 更新第i条鱼的位置，同时更新最优的鱼
     *
     * @param fishArr
     * @param nextFishArr
     * @param i
     * @param bestFish
     */
    private void upDateFishPositionAndBestFish(Fish[] fishArr, Fish[] nextFishArr, int i, Fish bestFish) {
        for (int j = 0; j < nextFishArr.length; j++) {
            if (nextFishArr[j].getFitness() > fishArr[i].getFitness()) {
                fishArr[i].setPosition(nextFishArr[j].getPosition());
                fishArr[i].setFitness(nextFishArr[j].getFitness());
            }
            if (nextFishArr[j].getFitness() > bestFish.getFitness()) {
//                System.out.println("更新最优解");
                bestFish.setPosition(nextFishArr[j].getPosition());
                bestFish.setFitness(nextFishArr[j].getFitness());
            }
        }
    }
    /**
     * 找一下附近有哪些鱼鱼
     *
     * @param i
     * @return
     */
    private List<Fish> findFishArrNearFishI(int i, Fish[] fishArr) {
        List<Fish> fishNearingFishIList = new ArrayList<>();
        for (int j = 0; j < this.fishNum; j++) {
            if (this.getDistanceOfTwoPositions(fishArr[i].getPosition(), fishArr[j].getPosition()) < this.visual) {
                fishNearingFishIList.add(fishArr[j]);
            }
        }
        return fishNearingFishIList;
    }
    /**
     * 获取两个位置之间的距离
     *
     * @param position1
     * @param position2
     */
    private double getDistanceOfTwoPositions(double[] position1, double[] position2) {
        double distance = 0;
        for (int i = 0; i < position1.length; i++) {
            distance += Math.pow((position1[i] - position2[i]), 2);
        }
        return Math.sqrt(distance);
    }
    /**
     * 对位置进行限制，限制再变量区间内
     *
     * @param position
     */
    private void fixPosition(double[] position, double[][] axisScopeArr) {
        for (int i = 0; i < position.length; i++) {
            //让坐标处于区间内
            if (position[i] > axisScopeArr[i][1]) {
                position[i] = axisScopeArr[i][1];
            } else if (position[i] < axisScopeArr[i][0]) {
                position[i] = axisScopeArr[i][0];
            }
        }
    }
    /**
     * 深拷贝对象
     *
     * @param srcObject
     * @return
     */
    private Object deepClone(Object srcObject) {
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        Object result = null;
        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            //将对象写到流里
            oos.writeObject(srcObject);
            //从流里读回来
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            result = ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }
}

package com.dam.heuristic.afas.test;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class AfasMainRun {
    public static void main(String[] args) {
        //变量的区间
        double[][] axisScopeArr = {
                {-1000, 1000},
                {-1000, 1000}
        };
        AfasApi afasApi = new AfasApi(50, 50, 5, 0.2, 5, 1000, false, axisScopeArr);
        double[][][] position = afasApi.solve();
        //创建WorkBook
        Workbook workbook = new XSSFWorkbook();
        Sheet xData = workbook.createSheet("xData");
        Sheet yData = workbook.createSheet("yData");
        //获取每一代，每一个粒子的x坐标
        CellStyle cellStyle = workbook.createCellStyle();
        //设置居中
        cellStyle.setAlignment(XSSFCellStyle.ALIGN_CENTER);
        for (int i = 0; i < position.length; i++) {
            Row xRow = xData.createRow(i);
            Row yRow = yData.createRow(i);
            for (int j = 0; j < position[0].length; j++) {
                Cell xCell = xRow.createCell(j);
                xCell.setCellValue(position[i][j][0]);
                //设置数据类型
                xCell.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
                //设置居中
                xCell.setCellStyle(cellStyle);
                Cell yCell = yRow.createCell(j);
                yCell.setCellValue(position[i][j][1]);
                //设置数据类型
                yCell.setCellType(XSSFCell.CELL_TYPE_NUMERIC);
                //设置居中
                yCell.setCellStyle(cellStyle);
            }
        }
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(new File("D:\\Desktop\\paintData.xlsx"));
            workbook.write(fileOutputStream);
            fileOutputStream.close();
            System.out.println("存储文件完成");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}