BurgAlgorithmVos (FsODE)

FsODE

Documentation for 0.0.2

BurgAlgorithmVos Type

Namespace: Altaxo.Calc.Regression
Assembly: AltaxoCore.Redist.dll
Base Type: obj

A faster algorithm than BurgAlgorithm, if the number of coefficients is less than 1/3 the length of the signal. This algorithm is based on a paper by Koen Vos, 2013.

Literature:

[1] Koen Vos, "A Fast Implementation of Burg's method, August 2013, Creative Commons"

Constructors

Constructor	Description
`BurgAlgorithmVos()` Full Usage: `BurgAlgorithmVos()`

Instance members

Instance member	Description
`this.Coefficients` Full Usage: `this.Coefficients` Returns: `IROVector<float>`	Returns the coefficients that were calculated during the last run of the algorithm. Returns: `IROVector<float>`
`this.Execute` Full Usage: `this.Execute` Parameters: x : `IReadOnlyList<float>` - Signal for building the model. numberOfCoefficients : `int` - Number of coefficients of the model. ?regularizationFactor : `float` - Default 1. Values greater than 1 leads to more and more regularization of the coefficients.	Uses the signal in vector x to build a model with `numberOfCoefficients` parameter. x : `IReadOnlyList<float>` Signal for building the model. numberOfCoefficients : `int` Number of coefficients of the model. ?regularizationFactor : `float` Default 1. Values greater than 1 leads to more and more regularization of the coefficients.
`this.GetFrequencyResponse` Full Usage: `this.GetFrequencyResponse` Parameters: fdt : `float` - Frequency. Must be given as f*dt, meaning the product of frequency and sample interval. Returns: `float` The complex frequency response at the given frequency. Modifiers: abstract	Calculates the frequency response for a given frequency. fdt : `float` Frequency. Must be given as f*dt, meaning the product of frequency and sample interval. Returns: `float` The complex frequency response at the given frequency.
`this.GetMeanPredictionErrorNonrecursivelyBackward` Full Usage: `this.GetMeanPredictionErrorNonrecursivelyBackward` Parameters: x : `IReadOnlyList<float>` - Signal for which to determine the mean backward prediction error. Returns: `float` Mean backward prediction error.	This algorithm determines the mean backward prediction error using the model stored in this instance. See remarks for details. 1. The prediction is done non recursively, i.e. part of the signal (the signal window) is used to predict the signal value before, and this predicted signal value is then compared with the original signal value stored in x to build the sum of errors. But the predicted signal value is not used to make further predictions. Instead, the signal window is moved by one point to the left and another prediction is made, with the original signal in x. This is repeated until the first point (index 0) is predicted. The return value is the square root of the sum of squared differences between predicted signal values and original values, divided by the number of predicted values. The number of predicted values is the length of the signal x minus the number of coefficents of the model. x : `IReadOnlyList<float>` Signal for which to determine the mean backward prediction error. Returns: `float` Mean backward prediction error.
`this.GetMeanPredictionErrorNonrecursivelyForward` Full Usage: `this.GetMeanPredictionErrorNonrecursivelyForward` Parameters: x : `IReadOnlyList<float>` - Signal for which to determine the mean forward prediction error. Returns: `float` Mean backward prediction error.	This algorithm determines the mean forward prediction error using the model stored in this instance. See remarks for details. 1. The prediction is done non recursively, i.e. part of the signal (the signal window) is used to predict the signal value immediately after the window, and this predicted signal value is then compared with the original signal value stored in x to build the sum of errors. But the predicted signal value is not used to make further predictions. Instead, the signal window is moved by one point to the right and another prediction is made, with the original signal in x. This is repeated until the last point is predicted. The return value is the square root of the sum of squared differences between predicted signal values and original values, divided by the number of predicted values. The number of predicted values is the length of the signal x minus the number of coefficents of the model. x : `IReadOnlyList<float>` Signal for which to determine the mean forward prediction error. Returns: `float` Mean backward prediction error.
`this.MeanSquareSignal` Full Usage: `this.MeanSquareSignal` Returns: `float`	Mean square of the signal values. Returns: `float`
`this.NumberOfCoefficients` Full Usage: `this.NumberOfCoefficients` Returns: `int`	Returns the number of coefficients that were used for the last run of the algorithm. Returns: `int`
`this.PredictRecursivelyBackward` Full Usage: `this.PredictRecursivelyBackward` Parameters: x : `IVector<float>` - Signal which holds at least BurgAlgorithmVos.NumberOfCoefficients valid points (the signal window to start the prediction with) from index (lastPoint+1) to (lastPoint+NumberOfCoefficents). The predicted values are then stored in the first part of this vector from indices (0) to (lastPoint). lastPoint : `int` - Index of the last point to predict.	Predict values towards the start of the vector. The predicted values are then used to predict more values. See remarks for details. The algorithm uses a signal window of `NumberOfCoefficients` signal points after the `lastPoint` to predict the value at `lastPoint`. Then the window is shifted by one towards the start of the vecctor, hence including the predicted value, and the point at `lastPoint-1` is predicted. The procedure is repeated until the value at index 0 is predicted. x : `IVector<float>` Signal which holds at least BurgAlgorithmVos.NumberOfCoefficients valid points (the signal window to start the prediction with) from index (lastPoint+1) to (lastPoint+NumberOfCoefficents). The predicted values are then stored in the first part of this vector from indices (0) to (lastPoint). lastPoint : `int` Index of the last point to predict.
`this.PredictRecursivelyBackward` Full Usage: `this.PredictRecursivelyBackward` Parameters: x : `IVector<float>` - Signal which holds at least BurgAlgorithmVos.NumberOfCoefficients valid points (the signal window to start the prediction with) from index (lastPoint+1) to (lastPoint+NumberOfCoefficents). The predicted values are then stored in the first part of this vector from indices (lastPoint-count+1) to (lastPoint). lastPoint : `int` - Index of the last point to predict. count : `int` - Number of points to predict.	Predict values towards the start of the vector. The predicted values are then used to predict more values. See remarks for details. The algorithm uses a signal window of `NumberOfCoefficients` signal points after the `lastPoint` to predict the value at `lastPoint`. Then the window is shifted by one towards the start of the vecctor, hence including the predicted value, and the point at `lastPoint-1` is predicted. The procedure is repeated until `count` points are predicted. x : `IVector<float>` Signal which holds at least BurgAlgorithmVos.NumberOfCoefficients valid points (the signal window to start the prediction with) from index (lastPoint+1) to (lastPoint+NumberOfCoefficents). The predicted values are then stored in the first part of this vector from indices (lastPoint-count+1) to (lastPoint). lastPoint : `int` Index of the last point to predict. count : `int` Number of points to predict.
`this.PredictRecursivelyForward` Full Usage: `this.PredictRecursivelyForward` Parameters: x : `IVector<float>` - Signal which holds at least BurgAlgorithmVos.NumberOfCoefficients valid points (the signal window to start the prediction with) from index (firstPoint-NumberOfCoefficents) to (firstPoint-1). The predicted values are then stored in this vector. firstPoint : `int` - Index of the first point to predict.	Predict values towards the end of the vector. The predicted values are then used to predict more values. See remarks for details. The algorithm uses a signal window of `NumberOfCoefficients` signal points before the `firstPoint` to predict the value at `firstPoint`. Then the window is shifted by one towards the end of the vecctor, hence including the predicted value, and the point at `firstPoint+1` is predicted. The procedure is repeated until all points to the end of the vector are predicted. x : `IVector<float>` Signal which holds at least BurgAlgorithmVos.NumberOfCoefficients valid points (the signal window to start the prediction with) from index (firstPoint-NumberOfCoefficents) to (firstPoint-1). The predicted values are then stored in this vector. firstPoint : `int` Index of the first point to predict.
`this.PredictRecursivelyForward` Full Usage: `this.PredictRecursivelyForward` Parameters: x : `IVector<float>` - Signal which holds at least BurgAlgorithmVos.NumberOfCoefficients valid points (the signal window to start the prediction with) from index (firstPoint-NumberOfCoefficents) to (firstPoint-1). The predicted values are then stored in this vector. firstPoint : `int` - Index of the first point to predict. count : `int` - Number of points to predict.	Predict values towards the end of the vector. The predicted values are then used to predict more values. See remarks for details. The algorithm uses a signal window of `NumberOfCoefficients` signal points before the `firstPoint` to predict the value at `firstPoint`. Then the window is shifted by one towards the end of the vecctor, hence including the predicted value, and the point at `firstPoint+1` is predicted. The procedure is repeated until `count` points are predicted. x : `IVector<float>` Signal which holds at least BurgAlgorithmVos.NumberOfCoefficients valid points (the signal window to start the prediction with) from index (firstPoint-NumberOfCoefficents) to (firstPoint-1). The predicted values are then stored in this vector. firstPoint : `int` Index of the first point to predict. count : `int` Number of points to predict.
`this.RMSSignal` Full Usage: `this.RMSSignal` Returns: `float`	Root of mean square of the signal values. Returns: `float`
`this.ReflectionCoefficients` Full Usage: `this.ReflectionCoefficients` Returns: `IROVector<float>`	Returns the reflection coefficients that were calculated during the last run of the algorithm. Returns: `IROVector<float>`

Static members

Static member Description

Static member	Description
`BurgAlgorithmVos.Execution(x, numberOfCoefficients, ?regularizationFactor)` Full Usage: `BurgAlgorithmVos.Execution(x, numberOfCoefficients, ?regularizationFactor)` Parameters: x : `IReadOnlyList<float>` - Signal for building the model. numberOfCoefficients : `int` - Number of coefficients of the model. ?regularizationFactor : `float` - Default 1. Values greater than 1 leads to more and more regularization of the coefficients. Returns: `IROVector<float> * float` The coefficient array, and the sum of squared signal values.	Uses the signal in vector x to build a model with `numberOfCoefficients` parameter. x : `IReadOnlyList<float>` Signal for building the model. numberOfCoefficients : `int` Number of coefficients of the model. ?regularizationFactor : `float` Default 1. Values greater than 1 leads to more and more regularization of the coefficients. Returns: `IROVector<float> * float` The coefficient array, and the sum of squared signal values.
`BurgAlgorithmVos.Execution(x, coefficients, ?regularizationFactor)` Full Usage: `BurgAlgorithmVos.Execution(x, coefficients, ?regularizationFactor)` Parameters: x : `IReadOnlyList<float>` - Signal for building the model. coefficients : `IVector<float>` - Vector of coefficients to be filled. ?regularizationFactor : `float` - Default 1. Values greater than 1 leads to more and more regularization of the coefficients. Returns: `float` The sum of squared signal values.	Uses the signal in vector x to build a model with `numberOfCoefficients` parameter. x : `IReadOnlyList<float>` Signal for building the model. coefficients : `IVector<float>` Vector of coefficients to be filled. ?regularizationFactor : `float` Default 1. Values greater than 1 leads to more and more regularization of the coefficients. Returns: `float` The sum of squared signal values.


                
                  
                    
                      BurgAlgorithmVos.Execution(x, numberOfCoefficients, ?regularizationFactor)

Full Usage: BurgAlgorithmVos.Execution(x, numberOfCoefficients, ?regularizationFactor)

Parameters:

x : IReadOnlyList<float> - Signal for building the model.

numberOfCoefficients : int - Number of coefficients of the model.

?regularizationFactor : float - Default 1. Values greater than 1 leads to more and more regularization of the coefficients.

Returns: IROVector<float> * float The coefficient array, and the sum of squared signal values.

Uses the signal in vector x to build a model with numberOfCoefficients parameter.

x : IReadOnlyList<float>: Signal for building the model.
numberOfCoefficients : int: Number of coefficients of the model.
?regularizationFactor : float: Default 1. Values greater than 1 leads to more and more regularization of the coefficients.

Returns: IROVector<float> * float: The coefficient array, and the sum of squared signal values.


                
                  
                    
                      BurgAlgorithmVos.Execution(x, coefficients, ?regularizationFactor)

Full Usage: BurgAlgorithmVos.Execution(x, coefficients, ?regularizationFactor)

Parameters:

x : IReadOnlyList<float> - Signal for building the model.

coefficients : IVector<float> - Vector of coefficients to be filled.

?regularizationFactor : float - Default 1. Values greater than 1 leads to more and more regularization of the coefficients.

Returns: float The sum of squared signal values.

Uses the signal in vector x to build a model with numberOfCoefficients parameter.

x : IReadOnlyList<float>: Signal for building the model.
coefficients : IVector<float>: Vector of coefficients to be filled.
?regularizationFactor : float: Default 1. Values greater than 1 leads to more and more regularization of the coefficients.

Returns: float: The sum of squared signal values.