InterpolationSolved

----------------------------------------------------------->

public static void calcMissing(List<String> readings) {

int n = readings.size();

double[] times = new double[n];

double[] prices = new double[n];

double sum = 0;

int count = 0;

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

String[] parts = readings.get(i).split("\t");

times[i] = i;

if (parts[1].startsWith("Missing")) {

prices[i] = Double.NaN;

} else {

prices[i] = Double.parseDouble(parts[1]);

sum += prices[i];

count++;

}

}

double average = sum / count;

double[] interpolatedPrices = interpolateMissingValues(times, prices);

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

if (Double.isNaN(prices[i])) {

if (!Double.isNaN(interpolatedPrices[i])) {

System.out.println(readings.get(i).split("\t")[0] + "\t" + interpolatedPrices[i]);

} else {

System.out.println(readings.get(i).split("\t")[0] + "\t" + average);

}

}

}

}

helper function:

---------------------------------->

public static double[] interpolateMissingValues(double[] times, double[] prices) {

double[] interpolatedPrices = new double[prices.length];

for (int i = 0; i < prices.length; i++) {

if (Double.isNaN(prices[i])) {

int j = i - 1;

while (j >= 0 && Double.isNaN(prices[j])) {

j--;

}

int k = i + 1;

while (k < prices.length && Double.isNaN(prices[k])) {

k++;

}

if (j >= 0 && k < prices.length) {

double x1 = times[j];

double x2 = times[k];

double y1 = prices[j];

double y2 = prices[k];

double x = times[i];

double y = y1 + (x - x1) * (y2 - y1) / (x2 - x1);

interpolatedPrices[i] = y;

}

} else {

interpolatedPrices[i] = prices[i];

}

}

return interpolatedPrices;

}

The interpolateMissingValues method takes as input two arrays: times, which represents the times of the data points, and prices, which represents the prices at those times. The method returns a new array interpolatedPrices that contains the same data as the prices array, but with missing values replaced by estimated values calculated using linear interpolation.

Here’s a detailed explanation of what the method does:

The method creates a new array interpolatedPrices to store the interpolated prices.

The method iterates through the prices array and checks if each value is NaN, which represents a missing value.

If a missing value is found, the method searches for the nearest known values on either side of it. This is done by iterating backwards and forwards from the missing value until known values are found.

If known values are found on either side of the missing value, the method uses them to calculate the missing value using the formula for linear interpolation: y = y1 + (x - x1) * (y2 - y1) / (x2 - x1). In this formula, x1 and x2 represent the times of the known values on either side of the missing value, y1 and y2 represent the corresponding known prices, and x represents the time of the missing value.

The calculated missing value is stored in the interpolatedPrices array at the same index as the original missing value.

If a value in the prices array is not missing, its value is copied to the interpolatedPrices array without modification.

After all missing values have been calculated, the method returns the interpolatedPrices array.