java - 创建一个像环面一样工作的数组

Question

我创建了一个程序，该程序采用从 0 开始并添加 Math.random()(0 到 0.999 之间的两倍)n 次创建的随机数组，并计算特定半径内每个位置的加权平均值。我目前有一个程序可以执行此操作，但我想知道如何使用环面创建一个程序。基本原则是最后一个元素现在等于第一个元素，当第一个元素更新其位置时，它会考虑其他元素之间的差异，包括数组中的一些最后元素。

如有任何帮助，我们将不胜感激。它对编码没有帮助，但根据其背后的原理，我无法弄清楚多次迭代如何做到这一点。

这是目前为止适用于一次迭代的代码。在一个之后，代码不正确并计算出错误的值。

import java.text.DecimalFormat;
import java.util.Scanner;

/**
* Created by jameshales on 12/03/2014.
 */
public class Torus {

public static void main(String[] args) {


    DecimalFormat df = new DecimalFormat("#.###"); //  this sets all decimals to a max of 3 decimal places.


    System.out.println("how many numbers of agents on the real line?"); // This asks the question "how many numbers on the real line?" to the user.

    Scanner input = new Scanner(System.in);
    int n = 0;
    n=Integer.parseInt(input.nextLine()); // the scanner reads the input and assigns it to the variable n


    double[] agentPosition = new  double[n];  // create an array with decimal places allowed called agentPosition
    double[] newAgentPosition = new double[n];  // create an array with decimal places allowed called newAgentPosition
    double[] originalAgentPosition = new double[n];  // create an array with decimal places allowed called originalAgentPosition

    System.out.println("Please select your desired radius? select 1 normally"); // This asks the question "Please select your desired radius?


    double r = 0;
    r = input.nextDouble(); // the scanner reads the next input and assigns it to the variable r

    int t = 0;  // sets t to 0

    double epsilon = 0.001;  // this allows us to sets epsilon to 0.


    // start the array from position 0 with its value set to 0

    for (int i = 0; i <= n - 1; i++) {   // starting from position 1 it creates a random number between 0 and 0.999 and adds it to the previous agentPosition to fill the array in a random increasing way.

        if (i > 0)
            agentPosition[i] = agentPosition[i - 1] + Math.random(); // this equation creates the random array 
        else agentPosition[i] =0.0;
    }

    System.arraycopy(agentPosition,0,originalAgentPosition,0,n);
    // This takes the first randomly created array(agentPosition), copyies each element starting from 0 to n and calls it originalAgentPosition.



    while(true) { // This is the start of the while loop, this will keep running until false


        for (int i = 0; i <= n - 1; i++) {

            // this will go through the array 1 position at a time in an increasing order from position 0 to n-1

            double total1 = agentPosition[i];    // sets the initial value of total1 to 0

            double total2 = 0;    // sets the initial value of total2 to 0

            int numposition = 1;  // this starts at 1 so it includes the position in the array when dividing.(also stops dividing by 1)


                for (int j = i - 1; j >= 0; j--) {   // this will work from the initial value of the array to the one before the one selected.

                    if ((agentPosition[i] - agentPosition[j]) <= r) {  // this calculates the absolute value of the difference between 2 positions on the array. (from i working downwards)


                        numposition++;         // this sums the number of positions within the radius of the chosen position.

                        total1 += agentPosition[j];   // this sums up all the values within the radius below to the total1.
                    } else break;  // stops the program once it has passed a position of a distance of 1

                }

                for (int k = i + 1; k <= n - 1 ; k++) { // this will go from the one after the position selected to the last position in the array to test if the distance is greater than 1, stops otherwise..

                    if (Math.abs(agentPosition[k] - agentPosition[i]) <= r) {     // this calculates the absolute value of the difference between 2 positions on the array(i and positions greater).


                        numposition++;      // this sums the number of positions within the radius of the chosen position.

                        total2 += agentPosition[k]; // this sums up all the values within the radius above to the total1.
                    } else break;    // stops the program once it has passed a position of a distance of 1
                }


                for (int j = n - 2; j >= 1; j--) {   // this will work from the initial value of the array to the one before the one selected.

                    if (((agentPosition[n-1] + agentPosition[i]) - agentPosition[j]) <= r) {  // this calculates the absolute value of the difference between 2 positions on the array. (from i working downwards)

                        numposition++;

                        total1 += (agentPosition[j] - agentPosition[n - 1]);   // this sums up all the values within the radius below to the total1.
                    }    else break;// stops the program once it has passed a position of a distance of 1

                }


                for (int k = 1; k <= n - 2 ; k++) { // this will go from the one after the position selected to the last position in the array to test if the distance is greater than 1, stops otherwise..

                    if (Math.abs((agentPosition[i] - agentPosition[n - 1]) - agentPosition[k]) <= r) {     // this calculates the absolute value of the difference between 2 positions on the array(i and positions greater).


                        numposition++;      // this sums the number of positions within the radius of the chosen position.


                        total2 += (agentPosition[n - 1] + agentPosition[k]); // this sums up all the values within the radius above to the total1.
                    }     else break;// stops the program once it has passed a position of a distance of 1
                }


                newAgentPosition[i] = (total1 + total2) / numposition; // this calculates the new weighted average. ( sum of assigned random variable/ sum of position)

            }

        for (int i = 0; i <= n - 1; i++){

            if (newAgentPosition[i] > originalAgentPosition[n - 1]){
                newAgentPosition[i] = newAgentPosition[i] - originalAgentPosition[n - 1];
            }

            if(newAgentPosition[i] < 0) {  // This checks if the agentPosition is smaller than 0 and then adds the largest agent to make all the elements within the range.
                newAgentPosition[i] = newAgentPosition[i] + originalAgentPosition[n - 1];
            }

        }

        t++;  // This sums up how many iterations it will take.

        double largestDiff = 0.0;  // This assigns largestDiff to 0

        for (int i = 0; i <= n-1; i++) {

            double diff = Math.abs(agentPosition[i] - newAgentPosition[i]);  // This calculates the difference between the previous and current array at position i.

            if(diff > largestDiff)  // If the difference between the agents is bigger than 0, assign it to the variable largestDiff.
                largestDiff = diff;

        }

        if(largestDiff <= epsilon){  // This checks if the difference is bigger than the set epsilon,

            break;  // This stops the program if the difference is smaller than epsilon
        }

        agentPosition = new double[n];

        System.arraycopy(newAgentPosition, 0, agentPosition, 0, n);  // This takes the newly generated array(newAgentPosition), copyies each element starting from 0 to n and assigns it back to agentPosition. (this stops the problem j and with taking the newly created elements.)

    }


    for (int i = 0 ; i <= n - 1; i++) {   // starting from position 1 it creates a random number between 0 and 0.999 and adds it to the previous agentPosition to fill the array in a random increasing way.

        System.out.println(i + ": " + df.format(originalAgentPosition[i]) + "\t->\t" + df.format(agentPosition[i]));

    }

    int sumdofclusters = 1;  // This sets the sum of clusters to 1

    System.out.println("The different clusters are:\n" + df.format(agentPosition[0]));   // This prints out the first cluster only.

    for (int i = 1; i <= n - 1 ; i++) {

        if(Math.abs(agentPosition[i] - agentPosition[i - 1]) >= epsilon) {  // This checks if the element after the element at hand is different by a set epsilon.(how to work out different clusters)

            sumdofclusters++;  // This sums the number of clusters.


            System.out.println(df.format(agentPosition[i])); // This prints out the different clusters other than the first 1.
        }

    }
    System.out.println("Number of clusters is:" + sumdofclusters); // This prints out the number of clusters.

    System.out.println("Number of iterations:" + t);   // This prints out the number of iterations.


}
}

Answer 1

您可以使用带模除法的数组创建循环列表。

getElementAt(double[] arr, int index)
{
    index = index % arr.length;
    index = index + arr.length; // If index is negative, modulus division gives us negative result, so this makes it positive.
    index = index % arr.length; // In case the previous step made index >= n
    return arr[index]
}

如果n是arr.length然后

0 <= index < n会像往常一样。

n <= index将环绕列表(例如 arr[n] == arr[0] 、 arr[n+1] == arr[1] 等)

index < 0将在另一个方向环绕列表(例如 arr[-1] == arr[n-1] 、 arr[-2] == arr[n-2] 等)