public void Add(FitElement e)
{
InnerList.Add(e);
e.Changed += new EventHandler(EhChildChanged);
OnChanged();
}
/// <summary>
/// Gets a new or recycled fit document for a given plot item <see cref="XYColumnPlotItem"/>.
/// </summary>
/// <param name="xyPlotItem">The xy plot item.</param>
/// <param name="ctrl">The control.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">xyPlotItem</exception>
private static Tuple <string, NonlinearFitDocument, string, XYPlotLayer> GetNewFitDocumentFor(XYColumnPlotItem xyPlotItem, Altaxo.Gui.Graph.Gdi.Viewing.IGraphController ctrl)
{
if (null == xyPlotItem)
{
throw new ArgumentNullException(nameof(xyPlotItem));
}
var activeLayer = Altaxo.Main.AbsoluteDocumentPath.GetRootNodeImplementing <XYPlotLayer>(xyPlotItem);
var xColumn = xyPlotItem.XYColumnPlotData.XColumn;
var yColumn = xyPlotItem.XYColumnPlotData.YColumn;
if (xColumn == null || xColumn.ItemType != typeof(double))
{
return(new Tuple <string, NonlinearFitDocument, string, XYPlotLayer>("The x-column is not numeric", null, null, activeLayer));
}
if (yColumn == null || yColumn.ItemType != typeof(double))
{
return(new Tuple <string, NonlinearFitDocument, string, XYPlotLayer>("The y-column is not numeric", null, null, activeLayer));
}
var localdoc = (ctrl.Doc.GetGraphProperty(FitDocumentPropertyName) as Calc.Regression.Nonlinear.NonlinearFitDocument) ??
(Altaxo.Calc.Regression.Nonlinear.NonlinearFitDocument)_lastFitDocument?.Clone() ??
new Altaxo.Calc.Regression.Nonlinear.NonlinearFitDocument();
if (localdoc.FitEnsemble.Count == 0) // if there was no fit before
{
var fitele = new Altaxo.Calc.Regression.Nonlinear.FitElement(
xyPlotItem.Data.DataTable,
xyPlotItem.Data.GroupNumber,
xyPlotItem.Data.DataRowSelection,
xColumn,
yColumn);
localdoc.FitEnsemble.Add(fitele);
}
else // there was a fit before, thus localdoc.FitEnsemble.Count>0
{
bool hasColumnsChanged = false;
hasColumnsChanged |= !(object.ReferenceEquals(localdoc.FitEnsemble[0].DataTable, xyPlotItem.Data.DataTable));
hasColumnsChanged |= !(object.ReferenceEquals(localdoc.FitEnsemble[0].GroupNumber, xyPlotItem.Data.GroupNumber));
hasColumnsChanged |= !(object.ReferenceEquals(localdoc.FitEnsemble[0].IndependentVariables(0), xColumn));
hasColumnsChanged |= !(object.ReferenceEquals(localdoc.FitEnsemble[0].DependentVariables(0), yColumn));
localdoc.FitEnsemble[0].SetIndependentVariable(0, xColumn);
localdoc.FitEnsemble[0].SetDependentVariable(0, yColumn);
if (hasColumnsChanged) // if some of the columns has changed, take the data row selection of the plot item
{
localdoc.FitEnsemble[0].DataRowSelection = xyPlotItem.Data.DataRowSelection;
}
}
return(new Tuple <string, NonlinearFitDocument, string, XYPlotLayer>(string.Empty, localdoc, null, activeLayer));
}
/// <summary>
/// Calculates the jacobian values, i.e. the derivatives of the fitting values with respect to the parameters.
/// </summary>
/// <param name="parameter">The parameter used to calculate the values.</param>
/// <param name="outputValues">You must provide an array to hold the calculated values. Size of the array must be
/// at least <see cref="NumberOfData" />*<see cref="FitElement.NumberOfParameters" />.</param>
/// <param name="adata">Currently ignored.</param>
/// <remarks>The values of the fit elements are stored in the order from element_0 to element_n*m. If there is more
/// than one used dependent variable per fit element, the output values are stored in interleaved order. The derivatives
/// on one fitting value are stored in successive order.
/// </remarks>
public void EvaluateFitJacobian(double[] parameter, double[] outputValues, object adata)
{
outputValues.Initialize(); // make sure every element contains zero
int outputValuesPointer = 0;
for (int ele = 0; ele < _cachedFitElementInfo.Length; ele++)
{
CachedFitElementInfo info = _cachedFitElementInfo[ele];
FitElement fitEle = _fitEnsemble[ele];
// make sure, that the dimension of the DYs is ok
if (info.DYs == null || info.DYs.Length != fitEle.NumberOfDependentVariables || info.DYs[0].Length != fitEle.NumberOfParameters)
{
info.DYs = LinearAlgebra.JaggedArrayMath.GetMatrixArray(fitEle.NumberOfDependentVariables, fitEle.NumberOfParameters);
}
// copy of the parameter to the temporary array
for (int i = 0; i < info.Parameters.Length; i++)
{
int idx = info.ParameterMapping[i];
info.Parameters[i] = idx >= 0 ? parameter[idx] : _constantParameters[-1 - idx];
}
IAscendingIntegerCollection validRows = info.ValidRows;
int numValidRows = validRows.Count;
// Evaluate the function for all points
for (int i = 0; i < numValidRows; ++i)
{
for (int k = info.Xs.Length - 1; k >= 0; k--)
{
info.Xs[k] = fitEle.IndependentVariables(k)[validRows[i]];
}
((IFitFunctionWithGradient)fitEle.FitFunction).EvaluateGradient(info.Xs, info.Parameters, info.DYs);
// copy the evaluation result to the output array (interleaved)
for (int k = 0; k < info.DependentVariablesInUse.Length; ++k)
{
for (int l = 0; l < info.Parameters.Length; ++l)
{
int idx = info.ParameterMapping[l];
if (idx >= 0)
{
outputValues[outputValuesPointer + idx] += info.DYs[info.DependentVariablesInUse[k]][l];
}
}
outputValuesPointer += parameter.Length; // increase output pointer only by the varying (!) number of parameters
}
}
}
}
public virtual void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info)
{
FitElement s = (FitElement)obj;
info.AddValue("FitFunction", s._fitFunction);
info.AddValue("NumberOfRows", s._rangeOfRows.Count);
info.AddValue("FirstRow", s._rangeOfRows.First);
info.AddArray("IndependentVariables", s._independentVariables, s._independentVariables.Length);
info.AddArray("DependentVariables", s._dependentVariables, s._dependentVariables.Length);
info.AddArray("VarianceEvaluation", s._errorEvaluation, s._errorEvaluation.Length);
info.AddArray("ParameterNames", s._parameterNames, s._parameterNames.Length);
info.AddValue("ParameterNameStart", s._parameterNameStart);
}
public virtual object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent)
{
FitElement s = o != null ? (FitElement)o : new FitElement();
s.FitFunction = (IFitFunction)info.GetValue("FitFunction", s);
int numRows = info.GetInt32("NumberOfRows");
int firstRow = info.GetInt32("FirstRow");
s._rangeOfRows = PositiveIntegerRange.NewFromFirstAndCount(firstRow, numRows);
int arraycount = info.OpenArray();
s._independentVariables = new NumericColumnProxy[arraycount];
for (int i = 0; i < arraycount; ++i)
{
s._independentVariables[i] = (NumericColumnProxy)info.GetValue(s);
}
info.CloseArray(arraycount);
arraycount = info.OpenArray();
s._dependentVariables = new NumericColumnProxy[arraycount];
for (int i = 0; i < arraycount; ++i)
{
s._dependentVariables[i] = (NumericColumnProxy)info.GetValue(s);
}
info.CloseArray(arraycount);
arraycount = info.OpenArray();
s._errorEvaluation = new IVarianceScaling[arraycount];
for (int i = 0; i < arraycount; ++i)
{
s._errorEvaluation[i] = (IVarianceScaling)info.GetValue(s);
}
info.CloseArray(arraycount);
info.GetArray("ParameterNames", out s._parameterNames);
for (int i = 0; i < s._parameterNames.Length; ++i)
{
if (s._parameterNames[i] == string.Empty)
{
s._parameterNames[i] = null; // serialization can not distinguish between an empty string and a null string
}
}
s._parameterNameStart = info.GetString("ParameterNameStart");
return(s);
}
public FitElement(FitElement from)
{
if (from._fitFunction is ICloneable fromFitFunc1)
{
_fitFunction = (IFitFunction)fromFitFunc1.Clone();
if (_fitFunction is Main.IDocumentLeafNode thisFitFunc1)
{
thisFitFunc1.ParentObject = this;
}
}
else
{
_fitFunction = from._fitFunction;
}
if (null != _fitFunction)
{
_fitFunction.Changed += EhFitFunctionChanged;
}
ChildCopyToMember(ref _dataTable, from._dataTable);
_groupNumber = from._groupNumber;
ChildCloneToMember(ref _rangeOfRows, from._rangeOfRows);
_independentVariables = new IReadableColumnProxy[from._independentVariables.Length];
for (int i = 0; i < _independentVariables.Length; ++i)
{
ChildCloneToMember(ref _independentVariables[i], from._independentVariables[i]);
}
_dependentVariables = new IReadableColumnProxy[from._dependentVariables.Length];
for (int i = 0; i < _dependentVariables.Length; ++i)
{
ChildCloneToMember(ref _dependentVariables[i], from._dependentVariables[i]);
}
_errorEvaluation = new IVarianceScaling[from._errorEvaluation.Length];
for (int i = 0; i < _errorEvaluation.Length; ++i)
{
if (from._errorEvaluation[i] != null)
{
_errorEvaluation[i] = (IVarianceScaling)from._errorEvaluation[i].Clone();
}
}
_parameterNames = (string[])from._parameterNames.Clone();
_parameterNameStart = from._parameterNameStart;
}
/// <summary>
/// Calculates the fitting values.
/// </summary>
/// <param name="parameter">The parameter used to calculate the values.</param>
/// <param name="outputValues">You must provide an array to hold the calculated values. Size of the array must be
/// at least <see cref="NumberOfData" />.</param>
/// <param name="calculateUnusedDependentVariablesAlso">If <c>true</c>, the unused dependent variables are also calculated (and plotted).</param>
/// <remarks>The values of the fit elements are stored in the order from element_0 to element_n. If there is more
/// than one used dependent variable per fit element, the output values are stored in interleaved order.
/// </remarks>
public void EvaluateFitValues(double[] parameter, double[] outputValues, bool calculateUnusedDependentVariablesAlso)
{
int outputValuesPointer = 0;
for (int ele = 0; ele < _cachedFitElementInfo.Length; ele++)
{
CachedFitElementInfo info = _cachedFitElementInfo[ele];
FitElement fitEle = _fitEnsemble[ele];
// copy of the parameter to the temporary array
for (int i = 0; i < info.Parameters.Length; i++)
{
int idx = info.ParameterMapping[i];
info.Parameters[i] = idx >= 0 ? parameter[idx] : _constantParameters[-1 - idx];
}
IAscendingIntegerCollection validRows = info.ValidRows;
int numValidRows = validRows.Count;
// Evaluate the function for all points
for (int i = 0; i < numValidRows; ++i)
{
for (int k = info.Xs.Length - 1; k >= 0; k--)
{
info.Xs[k] = fitEle.IndependentVariables(k)[validRows[i]];
}
fitEle.FitFunction.Evaluate(info.Xs, info.Parameters, info.Ys);
if (calculateUnusedDependentVariablesAlso)
{
// copy the evaluation result to the output array (interleaved)
for (int k = 0; k < fitEle.NumberOfDependentVariables; ++k)
{
outputValues[outputValuesPointer++] = info.Ys[k];
}
}
else
{
// copy the evaluation result to the output array (interleaved)
for (int k = 0; k < info.DependentVariablesInUse.Length; ++k)
{
outputValues[outputValuesPointer++] = info.Ys[info.DependentVariablesInUse[k]];
}
}
}
}
}
public FitElement this[int i]
{
get
{
return((FitElement)InnerList[i]);
}
set
{
FitElement oldValue = this[i];
oldValue.Changed -= new EventHandler(EhChildChanged);
InnerList[i] = value;
value.Changed += new EventHandler(EhChildChanged);
OnChanged();
}
}
/// <summary>
/// Creates an instance of this class. This constructor needs either
/// <paramref name="dataTable"/>, <paramref name="xCol"/> and <paramref name="yCol"/> to be valid, or all to be null.
/// If all null, consider to use the other provided constructor.
/// </summary>
/// <param name="fitFunc">Fitting function.</param>
/// <param name="parameter">Array of default parameters (length must match the expected number of parameter of fitFunc).</param>
/// <param name="dataTable">The data table from which the provided <paramref name="xCol"/> and <paramref name="yCol"/> originate.</param>
/// <param name="groupNumber">The group number of the columns <paramref name="xCol"/> and <paramref name="yCol"/>.</param>
/// <param name="xCol">Data column of independent values.</param>
/// <param name="yCol">Data column of dependent values.</param>
/// <param name="start">First point to be used for fitting.</param>
/// <param name="count">Number of points to be used for fitting.</param>
public SimpleNonlinearFit(FitEvaluationFunction fitFunc, double[] parameter, Altaxo.Data.DataTable dataTable, int groupNumber, Altaxo.Data.INumericColumn xCol, Altaxo.Data.INumericColumn yCol, int start, int count)
{
_fitDoc = new NonlinearFitDocument();
if (null == dataTable && null == xCol && null == yCol)
{
_fitEle = new FitElement(Altaxo.Data.Selections.RangeOfRowIndices.FromStartAndCount(start, count));
}
else
{
_fitEle = new FitElement(dataTable, groupNumber, Altaxo.Data.Selections.RangeOfRowIndices.FromStartAndCount(start, count), xCol, yCol);
}
_fitEle.FitFunction = new DummyFitFunc(fitFunc, parameter);
_fitDoc.FitEnsemble.Add(_fitEle);
_fitDoc.SetDefaultParametersForFitElement(0);
}
public double[] GetParametersForFitElement(int idx)
{
FitElement fitele = _fitEnsemble[idx];
System.Collections.Hashtable byName = new System.Collections.Hashtable();
for (int i = 0; i < _currentParameters.Count; i++)
{
byName.Add(_currentParameters[i].Name, _currentParameters[i].Parameter);
}
double[] result = new double[fitele.NumberOfParameters];
for (int i = 0; i < result.Length; ++i)
{
result[i] = (double)byName[fitele.ParameterName(i)];
}
return(result);
}
public double[] GetParametersForFitElement(int idx)
{
FitElement fitele = _fitEnsemble[idx];
var byName = new Dictionary <string, double>();
for (int i = 0; i < _currentParameters.Count; i++)
{
byName.Add(_currentParameters[i].Name, _currentParameters[i].Parameter);
}
double[] result = new double[fitele.NumberOfParameters];
for (int i = 0; i < result.Length; ++i)
{
result[i] = byName[fitele.ParameterName(i)];
}
return(result);
}
/// <summary>
/// Stores the dependent values of all elements in an array. The data
/// are stored from FitElement_0 to FitElement_n. For FitElements with more than one dependent
/// variable in use, the data are stored interleaved.
/// </summary>
/// <param name="values">The array used to store the values.</param>
public void GetDependentValues(double[] values)
{
int outputValuesPointer = 0;
for (int ele = 0; ele < _cachedFitElementInfo.Length; ele++)
{
CachedFitElementInfo info = _cachedFitElementInfo[ele];
FitElement fitEle = _fitEnsemble[ele];
IAscendingIntegerCollection validRows = info.ValidRows;
int numValidRows = validRows.Count;
// Evaluate the function for all points
for (int i = 0; i < numValidRows; ++i)
{
for (int j = 0; j < info.DependentVariablesInUse.Length; ++j)
{
values[outputValuesPointer++] = fitEle.DependentVariables(info.DependentVariablesInUse[j])[validRows[i]];
}
}
}
}
public FitElement(FitElement from)
{
this._fitFunction = from._fitFunction;
if (_fitFunction is ICloneable)
{
this._fitFunction = (IFitFunction)((ICloneable)from.FitFunction).Clone();
}
_rangeOfRows = PositiveIntegerRange.NewFromFirstAndCount(from._rangeOfRows.First, from._rangeOfRows.Count);
_independentVariables = new NumericColumnProxy[from._independentVariables.Length];
for (int i = 0; i < _independentVariables.Length; ++i)
{
if (from._independentVariables[i] != null)
{
_independentVariables[i] = (NumericColumnProxy)from._independentVariables[i].Clone();
}
}
_dependentVariables = new NumericColumnProxy[from._dependentVariables.Length];
for (int i = 0; i < _dependentVariables.Length; ++i)
{
if (from._dependentVariables[i] != null)
{
_dependentVariables[i] = (NumericColumnProxy)from._dependentVariables[i].Clone();
}
}
_errorEvaluation = new IVarianceScaling[from._errorEvaluation.Length];
for (int i = 0; i < _errorEvaluation.Length; ++i)
{
if (from._errorEvaluation[i] != null)
{
_errorEvaluation[i] = (IVarianceScaling)from._errorEvaluation[i].Clone();
}
}
_parameterNames = (string[])from._parameterNames.Clone();
_parameterNameStart = from._parameterNameStart;
}
protected void CollectParameterNames()
{
_ParametersSortedByName = new System.Collections.SortedList();
int nameposition = 0;
for (int i = 0; i < InnerList.Count; i++)
{
if (null == this[i].FitFunction)
{
continue;
}
IFitFunction func = this[i].FitFunction;
FitElement ele = this[i];
for (int k = 0; k < func.NumberOfParameters; k++)
{
if (!(_ParametersSortedByName.ContainsKey(ele.ParameterName(k))))
{
_ParametersSortedByName.Add(ele.ParameterName(k), nameposition++);
}
}
}
// now sort the items in the order of the namepositions
System.Collections.SortedList sortedbypos = new System.Collections.SortedList();
foreach (DictionaryEntry en in _ParametersSortedByName)
{
sortedbypos.Add(en.Value, en.Key);
}
_parameterNames = new string[sortedbypos.Count];
for (int i = 0; i < _parameterNames.Length; i++)
{
_parameterNames[i] = (string)sortedbypos[i];
}
}
/// <summary>
/// This will set all parameters in the ensembly with the same name than that of the parameter names
/// of fit function at index <c>idx</c> to their default values (those are provided by the fit function).
/// </summary>
/// <param name="idx">Index of the fit element.</param>
public void SetDefaultParametersForFitElement(int idx)
{
FitElement fitele = _fitEnsemble[idx];
if (fitele.FitFunction == null)
{
return;
}
var byName = new System.Collections.Hashtable();
for (int i = 0; i < _currentParameters.Count; i++)
{
byName.Add(_currentParameters[i].Name, i);
}
for (int i = 0; i < fitele.NumberOfParameters; ++i)
{
int k = (int)byName[fitele.ParameterName(i)];
_currentParameters[k].Parameter = fitele.FitFunction.DefaultParameterValue(i);
}
_currentParameters.OnInitializationFinished();
}
public void Initialize(FitElement fitElement)
{
_fitElement = fitElement;
_numberOfX = _fitElement.NumberOfIndependentVariables;
_numberOfY = _fitElement.NumberOfDependentVariables;
_numberOfParameter = _fitElement.NumberOfParameters;
_totalSlots = Math.Max(_numberOfParameter, _numberOfX + _numberOfY + 1);
_slotHeight = System.Windows.Forms.SystemInformation.MenuButtonSize.Height;
_pen = System.Drawing.Pens.Blue;
this.ClientSize = new Size(this.ClientSize.Width, _totalSlots * _slotHeight);
}
public void Initialize(Calc.Regression.Nonlinear.FitElement fitElement)
{
_fitElement = fitElement;
_numberOfX = _fitElement.NumberOfIndependentVariables;
_numberOfY = _fitElement.NumberOfDependentVariables;
_numberOfParameter = _fitElement.NumberOfParameters;
_totalSlots = Math.Max(_numberOfParameter, _numberOfX + _numberOfY + 4);
SetupElements();
}
void Select(IFitFunction func)
{
bool changed = false;
if (_doc.FitEnsemble.Count == 0) // Fitting is fresh, we can add the function silently
{
FitElement newele = new FitElement();
newele.FitFunction = func;
_doc.FitEnsemble.Add(newele);
_doc.SetDefaultParametersForFitElement(0);
changed = true;
}
else if (_doc.FitEnsemble.Count > 0 && _doc.FitEnsemble[_doc.FitEnsemble.Count - 1].FitFunction == null)
{
_doc.FitEnsemble[_doc.FitEnsemble.Count - 1].FitFunction = func;
_doc.SetDefaultParametersForFitElement(_doc.FitEnsemble.Count - 1);
changed = true;
}
else // Count>0, and there is already a fit function, we
{ // have to ask the user whether he wants to discard the old functions or keep them
System.Enum selchoice = _lastSelectionChoice;
if (Current.Gui.ShowDialog(ref selchoice, "As only or as additional?"))
{
_lastSelectionChoice = (SelectionChoice)selchoice;
if (_lastSelectionChoice == SelectionChoice.SelectAsAdditional)
{
FitElement newele = new FitElement();
newele.FitFunction = func;
_doc.FitEnsemble.Add(newele);
_doc.SetDefaultParametersForFitElement(_doc.FitEnsemble.Count - 1);
changed = true;
}
else // select as only
{
_doc.FitEnsemble[0].FitFunction = func;
_doc.SetDefaultParametersForFitElement(0);
for (int i = _doc.FitEnsemble.Count - 1; i >= 1; --i)
_doc.FitEnsemble.RemoveAt(i);
changed = true;
}
}
}
if (changed)
{
// _doc.FitEnsemble.InitializeParameterSetFromEnsembleParameters(_doc.CurrentParameters);
this._fitEnsembleController.Refresh();
}
}
public FitElementController(FitElement doc)
{
_doc = doc;
}
public FitElement(FitElement from)
{
this._fitFunction = from._fitFunction;
if (_fitFunction is ICloneable)
this._fitFunction = (IFitFunction)((ICloneable)from.FitFunction).Clone();
_rangeOfRows = PositiveIntegerRange.NewFromFirstAndCount(from._rangeOfRows.First, from._rangeOfRows.Count);
_independentVariables = new NumericColumnProxy[from._independentVariables.Length];
for (int i = 0; i < _independentVariables.Length; ++i)
{
if(from._independentVariables[i]!=null)
_independentVariables[i] = (NumericColumnProxy)from._independentVariables[i].Clone();
}
_dependentVariables = new NumericColumnProxy[from._dependentVariables.Length];
for (int i = 0; i < _dependentVariables.Length; ++i)
{
if (from._dependentVariables[i] != null)
_dependentVariables[i] = (NumericColumnProxy)from._dependentVariables[i].Clone();
}
_errorEvaluation = new IVarianceScaling[from._errorEvaluation.Length];
for (int i = 0; i < _errorEvaluation.Length; ++i)
{
if (from._errorEvaluation[i] != null)
_errorEvaluation[i] = (IVarianceScaling)from._errorEvaluation[i].Clone();
}
_parameterNames = (string[])from._parameterNames.Clone();
_parameterNameStart = from._parameterNameStart;
}
public FitElement(FitElement from)
{
this._fitFunction = from._fitFunction;
if (_fitFunction is ICloneable)
this._fitFunction = (IFitFunction)((ICloneable)from.FitFunction).Clone();
if (null != _fitFunction)
_fitFunction.Changed += EhFitFunctionChanged;
ChildCopyToMember(ref _dataTable, from._dataTable);
this._groupNumber = from._groupNumber;
ChildCloneToMember(ref _rangeOfRows, from._rangeOfRows);
_independentVariables = new IReadableColumnProxy[from._independentVariables.Length];
for (int i = 0; i < _independentVariables.Length; ++i)
{
if (from._independentVariables[i] != null)
_independentVariables[i] = (IReadableColumnProxy)from._independentVariables[i].Clone();
}
_dependentVariables = new IReadableColumnProxy[from._dependentVariables.Length];
for (int i = 0; i < _dependentVariables.Length; ++i)
{
if (from._dependentVariables[i] != null)
_dependentVariables[i] = (IReadableColumnProxy)from._dependentVariables[i].Clone();
}
_errorEvaluation = new IVarianceScaling[from._errorEvaluation.Length];
for (int i = 0; i < _errorEvaluation.Length; ++i)
{
if (from._errorEvaluation[i] != null)
_errorEvaluation[i] = (IVarianceScaling)from._errorEvaluation[i].Clone();
}
_parameterNames = (string[])from._parameterNames.Clone();
_parameterNameStart = from._parameterNameStart;
}
/// <summary>
/// Internal function to set up the cached data for the fitting procedure.
/// </summary>
/// <param name="paraSet">The set of parameters (the information which parameters are fixed is mainly used here).</param>
private void CalculateCachedData(ParameterSet paraSet)
{
// Preparation: Store the parameter names by name and index, and store
// all parameter values in _constantParameters
var paraNames = new System.Collections.Hashtable();
var varyingParaNames = new System.Collections.Hashtable();
_constantParameters = new double[paraSet.Count];
int numberOfVaryingParameters = 0;
for (int i = 0; i < paraSet.Count; ++i)
{
paraNames.Add(paraSet[i].Name, i);
_constantParameters[i] = paraSet[i].Parameter;
if (paraSet[i].Vary)
{
++numberOfVaryingParameters;
}
}
_cachedVaryingParameters = new double[numberOfVaryingParameters];
for (int i = 0, k = 0; i < paraSet.Count; ++i)
{
if (paraSet[i].Vary)
{
varyingParaNames.Add(paraSet[i].Name, k);
_cachedVaryingParameters[k++] = paraSet[i].Parameter;
}
}
_cachedNumberOfData = 0;
_cachedFitElementInfo = new CachedFitElementInfo[_fitEnsemble.Count];
for (int i = 0; i < _fitEnsemble.Count; i++)
{
var info = new CachedFitElementInfo();
_cachedFitElementInfo[i] = info;
FitElement fitEle = _fitEnsemble[i];
info.ValidRows = fitEle.CalculateValidNumericRows();
info.Xs = new double[fitEle.NumberOfIndependentVariables];
info.Parameters = new double[fitEle.NumberOfParameters];
info.Ys = new double[fitEle.NumberOfDependentVariables];
// Calculate the number of used variables
int numVariablesUsed = 0;
for (int j = 0; j < fitEle.NumberOfDependentVariables; ++j)
{
if (fitEle.DependentVariables(j) != null)
{
++numVariablesUsed;
}
}
info.DependentVariablesInUse = new int[numVariablesUsed];
for (int j = 0, used = 0; j < fitEle.NumberOfDependentVariables; ++j)
{
if (fitEle.DependentVariables(j) != null)
{
info.DependentVariablesInUse[used++] = j;
}
}
// calculate the total number of data points
_cachedNumberOfData += numVariablesUsed * info.ValidRows.Count;
// now create the parameter mapping
info.ParameterMapping = new int[fitEle.NumberOfParameters];
for (int j = 0; j < info.ParameterMapping.Length; ++j)
{
if (!paraNames.Contains(fitEle.ParameterName(j)))
{
throw new ArgumentException(string.Format("ParameterSet does not contain parameter {0}, which is used by function[{1}]", fitEle.ParameterName(j), i));
}
int idx = (int)paraNames[fitEle.ParameterName(j)];
if (paraSet[idx].Vary)
{
info.ParameterMapping[j] = (int)varyingParaNames[fitEle.ParameterName(j)];
}
else
{
info.ParameterMapping[j] = -idx - 1;
}
}
}
_cachedDependentValues = new double[_cachedNumberOfData];
GetDependentValues(_cachedDependentValues);
if (HasToUseWeights())
{
_cachedWeights = new double[_cachedNumberOfData];
GetWeights(_cachedWeights);
}
else
{
_cachedWeights = null;
}
}
public virtual object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent)
{
FitElement s = o != null ? (FitElement)o : new FitElement();
s.ChildSetMemberAlt(ref s._fitFunction, (IFitFunction)info.GetValue("FitFunction", s));
int numRows = info.GetInt32("NumberOfRows");
int firstRow = info.GetInt32("FirstRow");
s._rangeOfRows = RangeOfRowIndices.FromStartAndCount(firstRow, numRows);
if (null != s._rangeOfRows)
{
s._rangeOfRows.ParentObject = s;
}
int arraycount = info.OpenArray();
s._independentVariables = new IReadableColumnProxy[arraycount];
for (int i = 0; i < arraycount; ++i)
{
s._independentVariables[i] = (IReadableColumnProxy)info.GetValue("e", s);
if (null != s._independentVariables[i])
{
s._independentVariables[i].ParentObject = s;
}
}
info.CloseArray(arraycount);
arraycount = info.OpenArray();
s._dependentVariables = new IReadableColumnProxy[arraycount];
for (int i = 0; i < arraycount; ++i)
{
s._dependentVariables[i] = (IReadableColumnProxy)info.GetValue("e", s);
if (null != s._dependentVariables[i])
{
s._dependentVariables[i].ParentObject = s;
}
}
info.CloseArray(arraycount);
arraycount = info.OpenArray();
s._errorEvaluation = new IVarianceScaling[arraycount];
for (int i = 0; i < arraycount; ++i)
{
s._errorEvaluation[i] = (IVarianceScaling)info.GetValue("e", s);
}
info.CloseArray(arraycount);
info.GetArray("ParameterNames", out s._parameterNames);
for (int i = 0; i < s._parameterNames.Length; ++i)
{
if (s._parameterNames[i] == string.Empty)
{
s._parameterNames[i] = null; // serialization can not distinguish between an empty string and a null string
}
}
s._parameterNameStart = info.GetString("ParameterNameStart");
// now some afterwork
if (s.InternalCheckAndCorrectArraySize(false, false))
{
Current.Console.WriteLine("Error: Fitelement array size mismatch");
}
return(s);
}
public void Add(FitElement e)
{
InnerList.Add(e);
e.Changed += new EventHandler(EhChildChanged);
OnChanged();
}
/// <summary>
/// Creates an instance of this class.
/// </summary>
/// <param name="fitFunc">Fitting function.</param>
/// <param name="parameter">Array of default parameters (length must match the expected number of parameter of fitFunc).</param>
/// <param name="xCol">Data column of independent values.</param>
/// <param name="yCol">Data column of dependent values.</param>
/// <param name="start">First point to be used for fitting.</param>
/// <param name="count">Number of points to be used for fitting.</param>
public SimpleNonlinearFit(FitEvaluationFunction fitFunc, double[] parameter, Altaxo.Data.INumericColumn xCol, Altaxo.Data.INumericColumn yCol, int start, int count)
{
_fitDoc = new NonlinearFitDocument();
_fitEle = new FitElement(null, 0, Altaxo.Data.Selections.RangeOfRowIndices.FromStartAndCount(start, count), xCol, yCol);
_fitEle.FitFunction = new DummyFitFunc(fitFunc, parameter);
_fitDoc.FitEnsemble.Add(_fitEle);
_fitDoc.SetDefaultParametersForFitElement(0);
}
