/**
* Performs the forward transform for the given array from time domain to
* Hilbert domain and returns a new array of the same size keeping
* coefficients of Hilbert domain and should be of length 2 to the power of p
* -- length = 2^p where p is a positive integer.
*
* Returns Tuple<LeftWaveletPacket, RightWaveletPacket>
*/
public Tuple <WaveletPacket, WaveletPacket> Forward(WaveletPacket parent)
{
if (parent.Coefficients.Length % 2 != 0)
{
throw new ArgumentException("Tree must contain an even number of features");
}
double[] arrHilbLeft = new double[parent.Coefficients.Length / 2];
double[] arrHilbRight = new double[parent.Coefficients.Length / 2];
int k = 0;
int h = parent.Coefficients.Length >> 1;
for (int i = 0; i < h; i++)
{
for (int j = 0; j < GetWaveLength(); j++)
{
k = (i << 1) + j;
while (k >= parent.Coefficients.Length)
{
k -= parent.Coefficients.Length;
}
arrHilbLeft[i] += parent.Coefficients[k] * GetScales()[j]; // low pass filter - energy (approximation)
arrHilbRight[i] += parent.Coefficients[k] * GetCoeffs()[j]; // high pass filter - details
} // wavelet
} // h
return(new Tuple <WaveletPacket, WaveletPacket>(new WaveletPacket(arrHilbLeft, parent.Identifier, parent, parent.SubspaceIndex * 2), new WaveletPacket(arrHilbRight, parent.Identifier, parent, parent.SubspaceIndex * 2 + 1)));
}
protected override List <Tuple <double, double[]> > GetTransformedRows(ISample sample, int[] columns)
{
if (sample.GetDataRows().Count != trainingRowCount)
{
throw new ArgumentException("Sample must match the length of the training samples");
}
// transform each applicable column with optimal wavelet packet decomposition
double[][] transformedColumns = new double[trainingColumnCount][];
for (int j = 0; j < trainingColumnCount; j++)
{
// only need to calculate optimal decomposition for applicable columns
if (columns.Contains(j))
{
WaveletPacket top = GetWaveletPacketDecomposition(sample, j, wavelet, toLevel);
transformedColumns[j] = optimalSubspace[j].Select(subspace => top.FindSubspace(subspace)).SelectMany(packet => packet.Coefficients).ToArray();
}
else
{
transformedColumns[j] = sample.GetDataRows(j);
}
}
List <Tuple <double, double[]> > waveletData = new List <Tuple <double, double[]> >();
for (int row = 0; row < trainingRowCount; row++)
{
waveletData.Add(new Tuple <double, double[]>(sample.GetDataRows()[row].Item1, transformedColumns.Select(coefficientList => coefficientList[row]).ToArray()));
}
return(waveletData);
}
public WaveletPacket GetWaveletPacketDecomposition(ISample sample, int column, Wavelet wavelet, int toLevel)
{
WaveletPacket top = new WaveletPacket(sample.GetDataRows(column), sample.GetIdentifier());
BuildWaveletTree(top, wavelet, toLevel);
return(top);
}
private double GetNormalizedEuclidean(WaveletPacket packet, String identifier, Dictionary <string, List <double> > means, List <double> standardDeviations, List <int> exclusionCriterion)
{
return(packet.Coefficients.Select((row, i) => row - means[identifier][i]) // 1 subtract vector V (all feature means in this feature set for this class) from Xk (all features in this trial [packet])
.Select((mean, i) => mean / standardDeviations[i]) // 2 divide the result vector by the respective standard deviation vector
.Where((mean, i) => !exclusionCriterion.Contains(i)) // 3 remove excluded features (ignore excluded features)
.Aggregate(0.0, (accumulated, next) => accumulated += Math.Pow(next, 2))); // 4 find the square of the euclidean magnitude for the resulting vector srt(x^2+y^2)^2 = x^2+y^2
}
public void SetChildren(WaveletPacket leftChild, WaveletPacket rightChild)
{
this.LeftChild = leftChild;
this.RightChild = rightChild;
this.LeftChild.Sibling = rightChild;
this.RightChild.Sibling = leftChild;
}
private void BuildWaveletTree(WaveletPacket parent, Wavelet wavelet, int toLevel)
{
if (parent.Coefficients.Length >= wavelet.GetWaveLength() && parent.DecompositionLevel < toLevel)
{
Tuple <WaveletPacket, WaveletPacket> forwardTransform = wavelet.Forward(parent);
parent.SetChildren(forwardTransform.Item1, forwardTransform.Item2); // set children and recurse down to desired level
BuildWaveletTree(parent.LeftChild, wavelet, toLevel);
BuildWaveletTree(parent.RightChild, wavelet, toLevel);
}
}
public WaveletPacket FindSubspace(WaveletSubspace subspace)
{
// if this isn't the top of the tree move to the top of the tree
WaveletPacket top = this;
while (top.Parent != null)
{
top = top.Parent;
}
if (subspace.DecompositionLevel == top.DecompositionLevel)
{
return(top);
}
// do a recursive tree search for the desired subspace and return it
return(SearchSubspace(top, subspace));
}
public WaveletPacket(double[] coefficients, string identifier, WaveletPacket parent = null, int subspaceIndex = 0)
{
if (parent != null)
{
this.DecompositionLevel = parent.DecompositionLevel + 1;
}
else
{
this.DecompositionLevel = 0;
}
this.SubspaceIndex = subspaceIndex;
this.Parent = parent;
this.Sibling = null;
this.LeftChild = null;
this.RightChild = null;
this.Coefficients = coefficients;
this.Identifier = identifier;
}
private WaveletPacket SearchSubspace(WaveletPacket top, WaveletSubspace subspace)
{
if (subspace.DecompositionLevel == top.LeftChild.DecompositionLevel)
{
if (subspace.SubspaceIndex == top.LeftChild.SubspaceIndex)
{
return(top.LeftChild);
}
return(top.RightChild);
}
else
{
int levelDiff = (subspace.DecompositionLevel - top.LeftChild.DecompositionLevel);
int maxLeftIndex = top.LeftChild.SubspaceIndex * (levelDiff * 2) + ((int)Math.Pow(2, levelDiff) - 1);
if (subspace.SubspaceIndex <= maxLeftIndex)
{
return(SearchSubspace(top.LeftChild, subspace));
}
return(SearchSubspace(top.RightChild, subspace));
}
}
