/// <summary>
/// Reconstruct series by providing indices of list of elementary matrices
/// </summary>
/// <param name="signalIndex">list of indices of elementary matrices</param>
/// <returns></returns>
public double[] Reconstruct(params int[] group)
{
//reconstructed ts
var rts = MatrixEx.Zeros(_ts.Count());
for (int i = 0; i < group.Length; i++)
{
var sm = EM[group[i]];
var retVal = diagonalAveraging(sm);
rts = rts.Add(retVal);
}
return(rts);
}
void prepareForecast(int singularsValuesCount)
{
double vertCoeff = 0;
double[][] forecastOrthonormalVal;
var L = _xCom.GetLength(0);
var K = _xCom.GetLength(1);
var X_com_hat = MatrixEx.Zeros(L, K);
if (singularsValuesCount >= 0)
{
var len = Math.Min(singularsValuesCount, _orthonormalBase.Length);
forecastOrthonormalVal = new double[len][];
for (int i = 0; i < len; i++)
{
forecastOrthonormalVal[i] = _orthonormalBase[i];
}
}
else
{
forecastOrthonormalVal = _orthonormalBase;
}
var valR = MatrixEx.Zeros(forecastOrthonormalVal[0].Length, 1);
var tmp = valR.GetColumn(valR.GetLength(1) - 1);
_R = tmp.Take(tmp.Count() - 1).ToArray();
for (int i = 0; i < forecastOrthonormalVal.Length; i++)
{
//
var PI = forecastOrthonormalVal[i];
var prod = PI.ToMatrix(true).Dot(PI.ToMatrix(false));
var temp = prod.Dot(_xCom);
X_com_hat = X_com_hat.Add(temp);
//
var pi = PI.Last();
vertCoeff += pi * pi;
var rr = PI.Take(PI.Length - 1).ToArray().Multiply(pi);
_R = _R.Add(rr);
}
_R = _R.Divide((1.0 - vertCoeff));
X_com_tilde = diagonalAveraging(X_com_hat);
}
/// <summary>
/// Reconstruct time series component from the signal matrix
/// </summary>
/// <param name="xs">number of signal matrix</param>
/// <returns></returns>
public double[] Reconstruct(int signalCounts = -1)
{
double[] tsCumulative = null;
IEnumerable <KeyValuePair <int, double[, ]> > sM = _Xs;
if (signalCounts > 0)
{
sM = _Xs.Take(signalCounts);
}
//initi ts
tsCumulative = MatrixEx.Zeros(_ts.Count());
foreach (var sMat in sM)
{
var retVal = diagonalAveraging(sMat.Value);
tsCumulative = tsCumulative.Add(retVal);
}
return(tsCumulative);
}
/// <summary>
/// transform each matrix XIj of the grouped decomposition into a new series of length N
/// </summary>
/// <returns>elementary reconstructed series</returns>
private double[] diagonalAveraging(double[,] signalMatrix)
{
var L = signalMatrix.GetLength(0);
var K = signalMatrix.GetLength(1);
var Y = signalMatrix;
int lStar = Math.Min(L, K);
int kStar = Math.Max(L, K);
int N = L + K - 1;
//
var newM = MatrixEx.Zeros(L, K);
//
if (L >= K)
{
Y = Y.Transpose();
}
//reconstructed series
var y = new double[N];
for (int k = 1; k <= N; k++)
{
double yk = 0;
if (k >= 1 && k < lStar)
{
for (int m = 1; m <= k; m++)
{
int i = m;
int j = k - m + 1;
yk += Y[i - 1, j - 1];//zero based index
}
//
y[k - 1] = yk / k;
}
else if (k >= lStar && k <= kStar)
{
for (int m = 1; m <= lStar; m++)
{
int i = m;
int j = k - m + 1;
yk += Y[i - 1, j - 1];//zero based index
}
//
y[k - 1] = yk / lStar;
}
else if (k > kStar && k <= N)
{
for (int m = k - kStar + 1; m <= N - kStar + 1; m++)
{
int i = m;
int j = k - m + 1;
yk += Y[i - 1, j - 1];//zero based index
}
//
y[k - 1] = yk / (N - k + 1);
}
else
{
throw new Exception("This should not be happen!");
}
}
return(y);
}
/// <summary>
/// transform each matrix Xij of the grouped decomposition into a new series of length N
/// </summary>
/// <returns>elementary reconstructed series</returns>
private double[] diagonalAveraging(double[,] eMatrix)
{
//calculate number of cols, rows and
var LL = eMatrix.GetLength(0);
var KK = eMatrix.GetLength(1);
var Y = eMatrix;
int lStar = Math.Min(LL, KK);
int kStar = Math.Max(LL, KK);
int N = LL + KK - 1;
//
var newM = MatrixEx.Zeros(L, K);
//
if (LL >= KK)
{
Y = Y.Transpose();
}
//reconstructed series
var y = new double[N];
for (int k = 1; k <= N; k++)
{
double yk = 0;
if (k >= 1 && k < lStar)
{
for (int m = 1; m <= k; m++)
{
int i = m;
int j = k - m + 1;
yk += Y[i - 1, j - 1];
}
//
y[k - 1] = yk / k;
}
else if (k >= lStar && k <= kStar)
{
for (int m = 1; m <= lStar; m++)
{
int i = m;
int j = k - m + 1;
yk += Y[i - 1, j - 1];
}
//
y[k - 1] = yk / lStar;
}
else if (k > kStar && k <= N)
{
for (int m = k - kStar + 1; m <= N - kStar + 1; m++)
{
int i = m;
int j = k - m + 1;
yk += Y[i - 1, j - 1];
}
//
y[k - 1] = yk / (N - k + 1);
}
else
{
throw new Exception("This should not be happened!");
}
}
return(y);
}
