added Singular Spectrum Analysis
git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/data-analysis/EcologicalEngine@94963 82a268e6-3cf1-43bd-a215-b396298e98cf
This commit is contained in:
parent
e10ab6c4f8
commit
68a3e28eea
|
|
@ -0,0 +1,240 @@
|
||||||
|
package org.gcube.dataanalysis.ecoengine.signals.ssa;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
import org.jfree.chart.ChartPanel;
|
||||||
|
|
||||||
|
import Jama.Matrix;
|
||||||
|
|
||||||
|
public class SSADataset {
|
||||||
|
|
||||||
|
private List<Double> timeSeries; //the original time series
|
||||||
|
private int L; //length of window
|
||||||
|
private double inclosureMatrix [][]; //matrix attachment
|
||||||
|
private Matrix X []; //Basic Matrix singular decomposition
|
||||||
|
private Matrix groupX []; //the resulting matrix for each of the groups
|
||||||
|
private Matrix V []; //the main components of singular decomposition
|
||||||
|
private List<Double> reconstructionList; //recycled a number of
|
||||||
|
private List<Double> forecastList; //recycled a number of
|
||||||
|
|
||||||
|
private List <Double> SMA; //moving averages
|
||||||
|
private List <Double> cov; //averaging the diagonal covariance
|
||||||
|
private List <Double> eigenValueList;//eigenvalues
|
||||||
|
private List <Double> lgEigenValue; //log of the eigenvalues
|
||||||
|
private List <Double> sqrtEigenValue;//roots of eigenvalues
|
||||||
|
private List eigenVectors; //eigenvectors
|
||||||
|
private List <Double> percentList; //capital/interest/numbers
|
||||||
|
private List<Double> accruePercentList; //accrued interest eigenvalues
|
||||||
|
private double percThreshold=1;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* for a cascading display InternalFrame
|
||||||
|
*/
|
||||||
|
private int nextFrameX;
|
||||||
|
private int nextFrameY;
|
||||||
|
private int frameDistance;
|
||||||
|
private int eigenFuncPage;
|
||||||
|
private int mainCompPage;
|
||||||
|
private List<ChartPanel> eigenVecListCharts;
|
||||||
|
private List<ChartPanel> mainCompListCharts;
|
||||||
|
|
||||||
|
public SSADataset() {
|
||||||
|
timeSeries = new ArrayList<Double>();
|
||||||
|
L = 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List getEigenVectors() {
|
||||||
|
return eigenVectors;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setEigenVectors(List eigenVectors) {
|
||||||
|
this.eigenVectors = eigenVectors;
|
||||||
|
}
|
||||||
|
|
||||||
|
public Matrix[] getV() {
|
||||||
|
return V;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setV(Matrix[] V) {
|
||||||
|
this.V = V;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getTimeSeries() {
|
||||||
|
return timeSeries;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setTimeSeries(List<Double> timeSeries) {
|
||||||
|
this.timeSeries = timeSeries;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getL() {
|
||||||
|
return L;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setL(int L) {
|
||||||
|
this.L = L;
|
||||||
|
}
|
||||||
|
|
||||||
|
public double[][] getInclosureMatrix() {
|
||||||
|
return inclosureMatrix;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setInclosureMatrix(double matrix[][]) {
|
||||||
|
inclosureMatrix = matrix;
|
||||||
|
}
|
||||||
|
|
||||||
|
public Matrix[] getX() {
|
||||||
|
return X;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setX(Matrix X[]) {
|
||||||
|
this.X = X;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getReconstructionList() {
|
||||||
|
return reconstructionList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setReconstructionList(List<Double> reconstructionList) {
|
||||||
|
this.reconstructionList = reconstructionList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getSMA() {
|
||||||
|
return SMA;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setSMA(List<Double> SMA) {
|
||||||
|
this.SMA = SMA;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getCov() {
|
||||||
|
return cov;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setCov(List<Double> cov) {
|
||||||
|
this.cov = cov;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setLgEigenValue(List<Double> lgEigenValue) {
|
||||||
|
this.lgEigenValue = lgEigenValue;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getLgEigenValue() {
|
||||||
|
return lgEigenValue;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setSqrtEigenValue(List<Double> sqrtEigenValue) {
|
||||||
|
this.sqrtEigenValue = sqrtEigenValue;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getSqrtEigenValue() {
|
||||||
|
return sqrtEigenValue;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getEigenValueList() {
|
||||||
|
return eigenValueList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setEigenValueList(List<Double> eigenValueList) {
|
||||||
|
this.eigenValueList = eigenValueList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getAccruePercentList() {
|
||||||
|
return accruePercentList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setAccruePercentList(List<Double> accruePercentList) {
|
||||||
|
this.accruePercentList = accruePercentList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getPercentList() {
|
||||||
|
return percentList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setPercentList(List<Double> percentList) {
|
||||||
|
this.percentList = percentList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setFrameDistance(int frameDistance) {
|
||||||
|
this.frameDistance = frameDistance;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setNextFrameX(int nextFrameX) {
|
||||||
|
this.nextFrameX = nextFrameX;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setNextFrameY(int nextFrameY) {
|
||||||
|
this.nextFrameY = nextFrameY;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getFrameDistance() {
|
||||||
|
return frameDistance;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getNextFrameX() {
|
||||||
|
return nextFrameX;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getNextFrameY() {
|
||||||
|
return nextFrameY;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getEigenFuncPage() {
|
||||||
|
return eigenFuncPage;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setEigenFuncPage(int eigenFuncPage) {
|
||||||
|
this.eigenFuncPage = eigenFuncPage;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<ChartPanel> getEigenVecListCharts() {
|
||||||
|
return eigenVecListCharts;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setEigenVecListCharts(List<ChartPanel> eigenVecListCharts) {
|
||||||
|
this.eigenVecListCharts = eigenVecListCharts;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<ChartPanel> getMainCompListCharts() {
|
||||||
|
return mainCompListCharts;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setMainCompListCharts(List<ChartPanel> mainCompListCharts) {
|
||||||
|
this.mainCompListCharts = mainCompListCharts;
|
||||||
|
}
|
||||||
|
|
||||||
|
public int getMainCompPage() {
|
||||||
|
return mainCompPage;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setMainCompPage(int mainCompPage) {
|
||||||
|
this.mainCompPage = mainCompPage;
|
||||||
|
}
|
||||||
|
|
||||||
|
public Matrix[] getGroupX() {
|
||||||
|
return groupX;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setGroupX(Matrix[] groupX) {
|
||||||
|
this.groupX = groupX;
|
||||||
|
}
|
||||||
|
|
||||||
|
public double getPercThreshold() {
|
||||||
|
return percThreshold;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setPercThreshold(double percThreshold) {
|
||||||
|
this.percThreshold = percThreshold;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List<Double> getForecastList() {
|
||||||
|
return forecastList;
|
||||||
|
}
|
||||||
|
|
||||||
|
public void setForecastList(List<Double> forecastList) {
|
||||||
|
this.forecastList = forecastList;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,30 @@
|
||||||
|
package org.gcube.dataanalysis.ecoengine.signals.ssa;
|
||||||
|
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
public class SSAGroupList {
|
||||||
|
|
||||||
|
private List groups;
|
||||||
|
|
||||||
|
public SSAGroupList(List groups) {
|
||||||
|
this.groups = groups;
|
||||||
|
}
|
||||||
|
|
||||||
|
public String toString() {
|
||||||
|
String value = "";
|
||||||
|
for (int i = 0; i < groups.size(); i++) {
|
||||||
|
if(i != groups.size() - 1) {
|
||||||
|
value += groups.get(i).toString() + ",";
|
||||||
|
} else {
|
||||||
|
value += groups.get(i).toString();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
|
||||||
|
public List getGroups() {
|
||||||
|
return groups;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,27 @@
|
||||||
|
package org.gcube.dataanalysis.ecoengine.signals.ssa;
|
||||||
|
|
||||||
|
import java.math.BigDecimal;
|
||||||
|
import java.math.RoundingMode;
|
||||||
|
|
||||||
|
public class SSAUnselectList{
|
||||||
|
|
||||||
|
public int getIndex() {
|
||||||
|
return index;
|
||||||
|
}
|
||||||
|
|
||||||
|
private int index;
|
||||||
|
private double percent;
|
||||||
|
|
||||||
|
public SSAUnselectList(int index, double percent) {
|
||||||
|
this.index = index;
|
||||||
|
this.percent = percent;
|
||||||
|
}
|
||||||
|
|
||||||
|
public String toString() {
|
||||||
|
String value = "";
|
||||||
|
BigDecimal per = new BigDecimal(percent);
|
||||||
|
double num = per.setScale(4, RoundingMode.HALF_EVEN).doubleValue();
|
||||||
|
value = value + (index + 1) + "(" + num + "%)";
|
||||||
|
return value;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,62 @@
|
||||||
|
package org.gcube.dataanalysis.ecoengine.signals.ssa;
|
||||||
|
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
|
||||||
|
import org.gcube.contentmanagement.lexicalmatcher.utils.AnalysisLogger;
|
||||||
|
import org.gcube.dataanalysis.ecoengine.signals.SignalProcessing;
|
||||||
|
|
||||||
|
public class SSAWorkflow {
|
||||||
|
|
||||||
|
public static SSADataset applyCompleteWorkflow(List<Double> timeseries, int analysisWindowLength, float eigenValuesPercentageThreshold, int nPointsToForecast, boolean reportReconstructedSignal){
|
||||||
|
|
||||||
|
SSADataset data = new SSADataset();
|
||||||
|
data.setTimeSeries(timeseries);
|
||||||
|
data.setL(analysisWindowLength);
|
||||||
|
data.setPercThreshold(eigenValuesPercentageThreshold);
|
||||||
|
// step 1: Embedding of time series in a LxK matrix
|
||||||
|
// L = the length of the window
|
||||||
|
// K = timeseries.size() - L + 1 the number of vectors of attachments
|
||||||
|
SingularSpectrumAnalysis.inclosure(data);
|
||||||
|
// apply SVD and get a number of eigenvectors equal to the rank of the
|
||||||
|
// embedding matrix
|
||||||
|
SingularSpectrumAnalysis.singularDecomposition(data);
|
||||||
|
// calculate averages for each frame of the time series
|
||||||
|
SingularSpectrumAnalysis.setMovingAverage(data);
|
||||||
|
// Diagonal averaging of the covariance matrix
|
||||||
|
SingularSpectrumAnalysis.averagedCovariance(data);
|
||||||
|
// store the logs and the sqrts of the eigenvalues
|
||||||
|
SingularSpectrumAnalysis.functionEigenValue(data);
|
||||||
|
//build groups of indices
|
||||||
|
List<SSAGroupList> groupsModel = new ArrayList<SSAGroupList>();
|
||||||
|
List<SSAUnselectList> groups = new ArrayList<SSAUnselectList>();
|
||||||
|
|
||||||
|
for (int i = 0; i < data.getPercentList().size(); i++) {
|
||||||
|
double currentperc = data.getPercentList().get(i);
|
||||||
|
AnalysisLogger.getLogger().debug("Eigenvalue: Number: "+i+" Percentage: "+currentperc);
|
||||||
|
if (currentperc>eigenValuesPercentageThreshold)
|
||||||
|
groups.add(new SSAUnselectList(i, currentperc));
|
||||||
|
}
|
||||||
|
|
||||||
|
groupsModel.add(new SSAGroupList(groups));
|
||||||
|
//build a matrix which is the sum of the groups matrices
|
||||||
|
SingularSpectrumAnalysis.grouping(groupsModel, data);
|
||||||
|
// restoration of the time series (the diagonal averaging)
|
||||||
|
SingularSpectrumAnalysis.diagonalAveraging(data);
|
||||||
|
double[] signal = new double[data.getTimeSeries().size()];
|
||||||
|
for(int i = 0; i < data.getTimeSeries().size(); i++) signal[i] = data.getTimeSeries().get(i);
|
||||||
|
|
||||||
|
SingularSpectrumAnalysis.forecast(data,nPointsToForecast,reportReconstructedSignal);
|
||||||
|
|
||||||
|
double[] rsignal = new double[data.getForecastList().size()];
|
||||||
|
for(int i = 0; i < data.getForecastList().size(); i++) rsignal[i] = data.getForecastList().get(i);
|
||||||
|
|
||||||
|
//TODO: Report the weights of the components in a chart along with the cutoff
|
||||||
|
SignalProcessing.displaySignalWithGenericTime(signal, 0, 1, "signal");
|
||||||
|
SignalProcessing.displaySignalWithGenericTime(rsignal, 0, 1, "reconstructed signal");
|
||||||
|
|
||||||
|
AnalysisLogger.getLogger().debug("SSA workflow DONE");
|
||||||
|
return data;
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,411 @@
|
||||||
|
package org.gcube.dataanalysis.ecoengine.signals.ssa;
|
||||||
|
|
||||||
|
import Jama.EigenvalueDecomposition;
|
||||||
|
import Jama.Matrix;
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.Collections;
|
||||||
|
import java.util.Comparator;
|
||||||
|
import java.util.List;
|
||||||
|
import javax.swing.DefaultListModel;
|
||||||
|
|
||||||
|
import org.gcube.contentmanagement.lexicalmatcher.utils.AnalysisLogger;
|
||||||
|
|
||||||
|
public class SingularSpectrumAnalysis {
|
||||||
|
|
||||||
|
/**
|
||||||
|
* translation of the original time series into a sequence of multidimensional
|
||||||
|
* vectors
|
||||||
|
*
|
||||||
|
* @param data data for analysis
|
||||||
|
*/
|
||||||
|
public static void inclosure(SSADataset data) {
|
||||||
|
int L = data.getL(); //the length of the window
|
||||||
|
int K = data.getTimeSeries().size() - L + 1; //the number of vectors of attachments
|
||||||
|
double inclosureMatrix[][] = new double[L][K]; //Matrix Orbital
|
||||||
|
//form attachment vectors
|
||||||
|
for (int i = 1; i <= K; i++) {
|
||||||
|
int num = 0;
|
||||||
|
for (int j = i - 1; j <= i + L - 2; j++) {
|
||||||
|
inclosureMatrix[num][i - 1] = data.getTimeSeries().get(j);
|
||||||
|
num++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
data.setInclosureMatrix(inclosureMatrix);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* singular value decomposition
|
||||||
|
*
|
||||||
|
* @param data data for analysis
|
||||||
|
*/
|
||||||
|
public static void singularDecomposition(SSADataset data) {
|
||||||
|
double inclosureMatrix[][] = data.getInclosureMatrix();
|
||||||
|
double transp[][] = transpositionMatrix(inclosureMatrix);
|
||||||
|
Matrix S = new Matrix(inclosureMatrix).times(new Matrix(transp));
|
||||||
|
//int d = new Matrix(inclosureMatrix).rank(); //rank of matrix attachment
|
||||||
|
EigenvalueDecomposition decomposition = new EigenvalueDecomposition(S);
|
||||||
|
Matrix eigenvalue = decomposition.getD(); //matrix with eigenvalues
|
||||||
|
Matrix eigenvec = decomposition.getV(); //the matrix of eigenvectors
|
||||||
|
List<Double> eigenvalueList = new ArrayList<Double>();
|
||||||
|
//form the set of eigenvalues on the diagonal
|
||||||
|
for (int i = 0; i < eigenvalue.getRowDimension(); i++) {
|
||||||
|
for (int j = 0; j < eigenvalue.getRowDimension(); j++) {
|
||||||
|
if (i == j) {
|
||||||
|
eigenvalueList.add(eigenvalue.get(i, j));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Comparator comparator = Collections.reverseOrder();
|
||||||
|
/*
|
||||||
|
* own values must be in descending order, so
|
||||||
|
* We sort them in reverse order (initially ascending values
|
||||||
|
* order)
|
||||||
|
*/
|
||||||
|
Collections.sort(eigenvalueList, comparator);
|
||||||
|
data.setEigenValueList(eigenvalueList);
|
||||||
|
double sumValueList = 0;
|
||||||
|
List<Double> percentList;
|
||||||
|
List<Double> accruePercentList;
|
||||||
|
for (int i = 0; i < data.getEigenValueList().size(); i++) {
|
||||||
|
sumValueList = sumValueList + data.getEigenValueList().get(i);
|
||||||
|
}
|
||||||
|
//a percent of eigenvalues and accrued interest
|
||||||
|
percentList = new ArrayList<Double>();
|
||||||
|
accruePercentList = new ArrayList<Double>();
|
||||||
|
double accruePercent = 0;
|
||||||
|
for (int i = 0; i < data.getEigenValueList().size(); i++) {
|
||||||
|
percentList.add(data.getEigenValueList().get(i) / sumValueList * 100);
|
||||||
|
accruePercent += percentList.get(i);
|
||||||
|
accruePercentList.add(accruePercent);
|
||||||
|
}
|
||||||
|
data.setAccruePercentList(accruePercentList);
|
||||||
|
data.setPercentList(percentList);
|
||||||
|
|
||||||
|
int size = eigenvec.getColumnDimension();
|
||||||
|
Matrix V[] = new Matrix[size];
|
||||||
|
Matrix U[] = new Matrix[size];
|
||||||
|
Matrix X[] = new Matrix[size]; //Elementary matrix singular value decomposition
|
||||||
|
ArrayList listSeries = new ArrayList();
|
||||||
|
for (int j = 0; j < eigenvec.getColumnDimension(); j++) {
|
||||||
|
double uVec[][] = new double[size][1];
|
||||||
|
ArrayList series = new ArrayList();
|
||||||
|
for (int k = 0; k < eigenvec.getRowDimension(); k++) {
|
||||||
|
/*
|
||||||
|
* vectors must comply with its own number (!), so
|
||||||
|
* start with the last native vector
|
||||||
|
*/
|
||||||
|
uVec[k][0] = eigenvec.get(k, eigenvec.getColumnDimension() - j - 1);
|
||||||
|
series.add(uVec[k][0]);
|
||||||
|
}
|
||||||
|
listSeries.add(series);
|
||||||
|
U[j] = new Matrix(uVec);
|
||||||
|
V[j] = new Matrix(transp).times(U[j]);
|
||||||
|
}
|
||||||
|
data.setEigenVectors(listSeries);
|
||||||
|
for (int i = 0; i < V.length; i++) {
|
||||||
|
for (int j = 0; j < V[i].getRowDimension(); j++) {
|
||||||
|
for (int k = 0; k < V[i].getColumnDimension(); k++) {
|
||||||
|
double val = V[i].get(j, k) / Math.sqrt(eigenvalueList.get(i));
|
||||||
|
V[i].set(j, k, val);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
data.setV(V);
|
||||||
|
for (int i = 0; i < X.length; i++) {
|
||||||
|
X[i] = U[i].times(V[i].transpose());
|
||||||
|
for (int j = 0; j < X[i].getRowDimension(); j++) {
|
||||||
|
for (int k = 0; k < X[i].getColumnDimension(); k++) {
|
||||||
|
double val = X[i].get(j, k) * Math.sqrt(eigenvalueList.get(i));
|
||||||
|
X[i].set(j, k, val);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
data.setX(X);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* restoration of the time series (group stage)
|
||||||
|
*
|
||||||
|
* a JList model @param (group list)
|
||||||
|
* @param data data for analysis
|
||||||
|
*/
|
||||||
|
public static void grouping(List<SSAGroupList> model, SSADataset data) {
|
||||||
|
Matrix grouX[] = new Matrix[model.size()];
|
||||||
|
for (int i = 0; i < model.size(); i++) {
|
||||||
|
SSAGroupList obj = (SSAGroupList) model.get(i);
|
||||||
|
for (int j = 0; j < obj.getGroups().size(); j++) {
|
||||||
|
SSAUnselectList unselect = (SSAUnselectList) obj.getGroups().get(j);
|
||||||
|
if (j == 0) {
|
||||||
|
grouX[i] = data.getX()[unselect.getIndex()];
|
||||||
|
} else {
|
||||||
|
grouX[i] = grouX[i].plus(data.getX()[unselect.getIndex()]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
data.setGroupX(grouX);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* restoration of the time series (the stage diagonal averaging)
|
||||||
|
*
|
||||||
|
* @param data for analysis
|
||||||
|
*/
|
||||||
|
public static void diagonalAveraging(SSADataset data) {
|
||||||
|
int L;
|
||||||
|
int K;
|
||||||
|
int N;
|
||||||
|
List<List> list = new ArrayList<List>();
|
||||||
|
for (int i = 0; i < data.getGroupX().length; i++) {
|
||||||
|
if (data.getGroupX()[i].getRowDimension() < data.getGroupX()[i].getColumnDimension()) {
|
||||||
|
L = data.getGroupX()[i].getRowDimension();
|
||||||
|
K = data.getGroupX()[i].getColumnDimension();
|
||||||
|
} else {
|
||||||
|
K = data.getGroupX()[i].getRowDimension();
|
||||||
|
L = data.getGroupX()[i].getColumnDimension();
|
||||||
|
}
|
||||||
|
N = data.getGroupX()[i].getRowDimension() + data.getGroupX()[i].getColumnDimension() - 1;
|
||||||
|
List series = new ArrayList();
|
||||||
|
double element;
|
||||||
|
for (int k = 0; k <= N - 1; k++) {
|
||||||
|
element = 0;
|
||||||
|
if (k >= 0 && k < L - 1) {
|
||||||
|
for (int m = 0; m <= k; m++) {
|
||||||
|
if (data.getGroupX()[i].getRowDimension() <= data.getGroupX()[i].getColumnDimension()) {
|
||||||
|
element += data.getGroupX()[i].get(m, k - m);
|
||||||
|
} else if (data.getGroupX()[i].getRowDimension() > data.getGroupX()[i].getColumnDimension()) {
|
||||||
|
element += data.getGroupX()[i].get(k - m, m);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
element = element * (1.0 / (k + 1));
|
||||||
|
series.add(element);
|
||||||
|
}
|
||||||
|
if (k >= L - 1 && k < K - 1) {
|
||||||
|
for (int m = 0; m <= L - 2; m++) {
|
||||||
|
if (data.getGroupX()[i].getRowDimension() <= data.getGroupX()[i].getColumnDimension()) {
|
||||||
|
element += data.getGroupX()[i].get(m, k - m);
|
||||||
|
} else if (data.getGroupX()[i].getRowDimension() > data.getGroupX()[i].getColumnDimension()) {
|
||||||
|
element += data.getGroupX()[i].get(k - m, m);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
element = element * (1.0 / L);
|
||||||
|
series.add(element);
|
||||||
|
}
|
||||||
|
if (k >= K - 1 && k < N) {
|
||||||
|
for (int m = k - K + 1; m <= N - K; m++) {
|
||||||
|
if (data.getGroupX()[i].getRowDimension() <= data.getGroupX()[i].getColumnDimension()) {
|
||||||
|
element += data.getGroupX()[i].get(m, k - m);
|
||||||
|
} else if (data.getGroupX()[i].getRowDimension() > data.getGroupX()[i].getColumnDimension()) {
|
||||||
|
element += data.getGroupX()[i].get(k - m, m);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
element = element * (1.0 / (N - k));
|
||||||
|
series.add(element);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
list.add(series);
|
||||||
|
}
|
||||||
|
double sum;
|
||||||
|
//We summarize the series and get the original number
|
||||||
|
List<Double> reconstructionList = new ArrayList<Double>();
|
||||||
|
for (int j = 0; j < list.get(0).size(); j++) {
|
||||||
|
sum = 0;
|
||||||
|
for (int i = 0; i < list.size(); i++) {
|
||||||
|
sum += (Double) list.get(i).get(j);
|
||||||
|
}
|
||||||
|
reconstructionList.add(sum);
|
||||||
|
}
|
||||||
|
//added by Gianpaolo Coro
|
||||||
|
/*
|
||||||
|
double reconstructionratio = 1;
|
||||||
|
double ratiosum = 0;
|
||||||
|
int tssize = data.getTimeSeries().size();
|
||||||
|
for (int j = 0; j < tssize ; j++) {
|
||||||
|
double ratio = data.getTimeSeries().get(j)/reconstructionList.get(j);
|
||||||
|
ratiosum=ratiosum+ratio;
|
||||||
|
}
|
||||||
|
|
||||||
|
reconstructionratio = ratiosum/tssize;
|
||||||
|
System.out.println("Reconstruction ratio: "+reconstructionratio);
|
||||||
|
for (int j = 0; j < tssize ; j++) {
|
||||||
|
reconstructionList.set(j,reconstructionratio*reconstructionList.get(j));
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
data.setReconstructionList(reconstructionList);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* the transpose of a matrix
|
||||||
|
*
|
||||||
|
* the original matrix matrix @param
|
||||||
|
* @return the resulting matrix
|
||||||
|
*/
|
||||||
|
private static double[][] transpositionMatrix(double matrix[][]) {
|
||||||
|
double transpMatrix[][] = new double[matrix[0].length][matrix.length];
|
||||||
|
for (int i = 0; i < matrix.length; i++) {
|
||||||
|
for (int j = 0; j < matrix[i].length; j++) {
|
||||||
|
transpMatrix[j][i] = matrix[i][j];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return transpMatrix;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* formation of moving averages
|
||||||
|
*
|
||||||
|
* @param data data for analysis
|
||||||
|
*/
|
||||||
|
public static void setMovingAverage(SSADataset data) {
|
||||||
|
List<Double> SMA = new ArrayList<Double>();
|
||||||
|
int m = data.getTimeSeries().size() - data.getL() + 1; //период осреднения
|
||||||
|
for (int i = 0; i < data.getL(); i++) {
|
||||||
|
double sum = 0;
|
||||||
|
double avg = 0;
|
||||||
|
for (int j = i; j < m + i; j++) {
|
||||||
|
sum += data.getTimeSeries().get(j);
|
||||||
|
}
|
||||||
|
avg = sum / m;
|
||||||
|
SMA.add(avg);
|
||||||
|
data.setSMA(SMA);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* the diagonal of the covariance matrix averaging * (on the side diagonal)
|
||||||
|
* @param data data for analysis
|
||||||
|
*/
|
||||||
|
public static void averagedCovariance(SSADataset data) {
|
||||||
|
double avg;
|
||||||
|
double K = data.getTimeSeries().size() - data.getL() + 1; //the number of vectors of attachments
|
||||||
|
List<Double> covarianceList = new ArrayList<Double>();
|
||||||
|
double transp[][] = transpositionMatrix(data.getInclosureMatrix());
|
||||||
|
Matrix S = new Matrix(data.getInclosureMatrix()).times(new Matrix(transp));
|
||||||
|
S = S.times(1.0 / K); //covariance matrix
|
||||||
|
int size = S.getColumnDimension();
|
||||||
|
int N = size + size - 1;
|
||||||
|
int n;
|
||||||
|
for (int k = 0; k < N; k++) {
|
||||||
|
if ((k % 2) == 0) {
|
||||||
|
if (k >= 0 && k < size) {
|
||||||
|
avg = 0;
|
||||||
|
n = 0;
|
||||||
|
for (int m = 0; m <= k; m++) {
|
||||||
|
avg += S.get(m, size - 1 - (k - m));
|
||||||
|
n++;
|
||||||
|
}
|
||||||
|
avg = avg / (n);
|
||||||
|
covarianceList.add(avg);
|
||||||
|
}
|
||||||
|
if (k >= size && k < N) {
|
||||||
|
avg = 0;
|
||||||
|
n = 0;
|
||||||
|
for (int m = k - size + 1; m <= N - size; m++) {
|
||||||
|
avg += S.get(m, size - 1 - (k - m));
|
||||||
|
n++;
|
||||||
|
}
|
||||||
|
avg = avg / (n);
|
||||||
|
covarianceList.add(avg);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
data.setCov(covarianceList);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
*formation of the functions eigenvalues
|
||||||
|
* @param data data for analysis
|
||||||
|
*/
|
||||||
|
public static void functionEigenValue(SSADataset data) {
|
||||||
|
List<Double> lgList = new ArrayList<Double>();
|
||||||
|
List<Double> sqrtList = new ArrayList<Double>();
|
||||||
|
for (int i = 0; i < data.getEigenValueList().size(); i++) {
|
||||||
|
lgList.add((Double) Math.log(data.getEigenValueList().get(i)));
|
||||||
|
sqrtList.add(Math.sqrt(data.getEigenValueList().get(i)));
|
||||||
|
}
|
||||||
|
data.setLgEigenValue(lgList);
|
||||||
|
data.setSqrtEigenValue(sqrtList);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* author Gianpaolo Coro
|
||||||
|
* @param data
|
||||||
|
*/
|
||||||
|
public static void forecast(SSADataset data, int nPointsToForecast, boolean reconstructedSignal){
|
||||||
|
|
||||||
|
// List eigenvectors = data.getEigenVectors().subList(0, 11);
|
||||||
|
int nTotalEigenV = data.getPercentList().size();
|
||||||
|
int bestEigenVectors = nTotalEigenV;
|
||||||
|
//find the best number of eigenvectors to use for the forecast
|
||||||
|
for (int i=0;i<nTotalEigenV;i++){
|
||||||
|
double currentperc = data.getPercentList().get(i);
|
||||||
|
if (currentperc<data.getPercThreshold()){
|
||||||
|
bestEigenVectors=i+1;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
List eigenvectors = data.getEigenVectors().subList(0, bestEigenVectors);
|
||||||
|
int L = data.getL();
|
||||||
|
int lastcoordinate = L-1;
|
||||||
|
AnalysisLogger.getLogger().debug("SSA: value for L: "+L);
|
||||||
|
int nEigenVectors = eigenvectors.size();
|
||||||
|
AnalysisLogger.getLogger().debug("Total number of Eigenvectors: "+nEigenVectors);
|
||||||
|
double[] p = new double[nEigenVectors];
|
||||||
|
for (int i = 0;i<nEigenVectors;i++){
|
||||||
|
p[i] = (Double)((List)eigenvectors.get(i)).get(lastcoordinate);
|
||||||
|
}
|
||||||
|
double[][] P = new double[nEigenVectors][L-1];
|
||||||
|
|
||||||
|
for (int i = 0;i<nEigenVectors;i++){
|
||||||
|
List<Double> evec = (List)eigenvectors.get(i);
|
||||||
|
for (int j =0;j<(L-1);j++)
|
||||||
|
P[i][j] = evec.get(j);
|
||||||
|
}
|
||||||
|
|
||||||
|
double ni_sqr = 0d;
|
||||||
|
for (int i = 0;i<nEigenVectors;i++){
|
||||||
|
ni_sqr = ni_sqr+(p[i]*p[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
double [] R = new double[L-1];
|
||||||
|
|
||||||
|
for (int j=0;j<L-1;j++){
|
||||||
|
double rj = 0d;
|
||||||
|
for (int i=0;i<nEigenVectors;i++){
|
||||||
|
rj = rj+(p[i]*P[i][j]);
|
||||||
|
}
|
||||||
|
// R[i] = (1d/(1d-ni_sqr))*ri;
|
||||||
|
R[j] = rj/(1-ni_sqr);
|
||||||
|
}
|
||||||
|
|
||||||
|
int M = nPointsToForecast;
|
||||||
|
List<Double> y = new ArrayList<Double>();
|
||||||
|
int signalSize = data.getTimeSeries().size();
|
||||||
|
for (int j =0 ;j<(signalSize+M);j++){
|
||||||
|
if (j<signalSize){
|
||||||
|
if (reconstructedSignal)
|
||||||
|
y.add(j,data.getReconstructionList().get(j));
|
||||||
|
else
|
||||||
|
y.add(j,data.getTimeSeries().get(j));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
double sumprec = 0;
|
||||||
|
for (int g=0;g<L-1;g++){
|
||||||
|
double ag = R[L-2-g];
|
||||||
|
double yj_g = y.get(j-g-1);
|
||||||
|
sumprec=sumprec+ag*yj_g;
|
||||||
|
}
|
||||||
|
y.add(j, sumprec);
|
||||||
|
// System.out.println("Forecast: "+y.get(j));
|
||||||
|
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
AnalysisLogger.getLogger().debug("Length of the original signal: "+signalSize+" Length of the reconstructed signal: "+y.size());
|
||||||
|
|
||||||
|
data.setForecastList(y);
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue