}/*
* public static void FitToSin2(double[] xdata, double[] ydata, out double a, out double b, out double c)
* {// p = [ -0.287, 4.02, -1.46 ], hence f: x -> -0.287 + 4.02*sin(x) - 1.46*cos(x)
* var p = Fit.LinearCombination(xdata, ydata, z => 1.0, Math.Sin, Math.Cos);
*
* a = p[0];
* b = p[1];
* c = p[2];
* }//*/
public static void FitToSin2(double[] xdata, double[] ydata, out double a, out double b, out double c)
{// p = [ -0.287, 4.02, -1.46 ], hence f: x -> -0.287 + 4.02*sin(x) - 1.46*cos(x)
double minTime = double.MaxValue;
double maxTime = double.MinValue;
foreach (double val in xdata)
{
if (val > maxTime)
{
maxTime = val;
}
if (val < minTime)
{
minTime = val;
}
}
var omega = 1.0 / (maxTime - minTime);
double[] xNormed = new double[xdata.Length];
for (int i = 0; i < xdata.Length; i++)
{
xNormed[i] = xdata[i] * omega;
}
var p = Fit.LinearCombination(xNormed, ydata, z => 1.0, Math.Sin, Math.Exp);
a = p[0];
b = p[1];
c = p[2];
}
/// <summary>
/// 根据 公式ID，拟合数据，返回公式系数
/// </summary>
/// <param name="EQID"></param>
/// <param name="x_arr"></param>
/// <param name="y_arr"></param>
/// <returns></returns>
public static double[] CurveFitting(int EQID, double[] x_arr, double[] y_arr)
{
double[] Coefs_arr;
if (EQID == PPMConsts.PerformanceMD_power_ID)
{
double[] y_hat = Generate.Map(y_arr, Math.Log);
Coefs_arr = Fit.LinearCombination(x_arr, y_hat, DirectRegressionMethod.QR, t => 1.0, t => t);
return(new[] { Math.Exp(Coefs_arr[0]), Coefs_arr[1], 0 });
}
else if (EQID == PPMConsts.PerformanceMD_poly2nd_ID)
{
//var design = Matrix<double>.Build.Dense(x_arr.Length, 3, (i, j) => Math.Pow(x_arr[i], j));
//return MultipleRegression.QR(design, Vector<double>.Build.Dense(y_arr)).ToArray();
Coefs_arr = Fit.Polynomial(x_arr, y_arr, 2, DirectRegressionMethod.QR);
return(Coefs_arr);
}
else if (EQID == PPMConsts.PerformanceMD_mihanshu_ID)
{
Power_Paras Param = Power_ISM(x_arr, y_arr);
List <double> Coefs_list = new List <double>();
Coefs_list.Add(Param.C);
Coefs_list.Add(Param.m);
Coefs_list.Add(Param.P);
Coefs_arr = Coefs_list.ToArray();
return(Coefs_arr);
}
else
{
throw new Exception("Unknown Equation ID: 30id ");
}
}
/// <summary>
/// Performs an exponential regression.
/// </summary>
/// <param name="x">x data</param>
/// <param name="y">y data</param>
/// <param name="method">Regression method to use.</param>
public static double[] ExponentialFit(double[] x, double[] y, DirectRegressionMethod method = DirectRegressionMethod.QR)
{
double[] yHat = Generate.Map(y, Math.Log);
double[] pHat = Fit.LinearCombination(x, yHat, method, t => 1.0, t => t);
double[] coeffs = { Math.Exp(pHat[0]), pHat[1] };
return(Generate.Map(x, xi => coeffs[0] * Math.Exp(coeffs[1] * xi)));
}
double[] Exponential(double[] x, double[] y)
{
double[] y_hat = Generate.Map(y, Math.Log);
double[] p_hat = Fit.LinearCombination(x, y_hat, DirectRegressionMethod.QR, t => 1.0, t => t);
return(new[] { Math.Exp(p_hat[0]), p_hat[1] });
}
public Tuple <float, float> getParameters()
{
var X = new List <float>();
var Y = new List <float>();
foreach (dynamic point in this.points)
{
float x = point.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)[0].GetValue(point);
float y = point.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)[1].GetValue(point);
X.Add(x);
Y.Add(y);
}
double[] y_hat = Generate.Map(y, Math.Log);
double[] p_hat = Fit.LinearCombination(x, y_hat, method, t => 1.0, t => t);
return(new[] { Math.Exp(p_hat[0]), p_hat[1] });
}
public static double[] powerRegression(double[] x, double[] y)
{
var convert_log = y.Select(d => Math.Log(d)).ToArray();
double[] p = Fit.LinearCombination(x, convert_log,
d => 1.0,
d => Math.Log(d)
);
p[0] = Math.Exp(p[0]);
var R2 = GoodnessOfFit.RSquared(x.Select(d => p[0] * Math.Pow(d, p[1])), y);
double[] result = new double[3];
result[0] = R2;
result[1] = p[0];
result[2] = p[1];
return(result);
}
public void FitsToTrigonometricLinearCombination()
{
// Mathematica: Fit[{{1,4.986},{2,2.347},{3,2.061},{4,-2.995},{5,-2.352},{6,-5.782}}, {1, sin(x), cos(x)}, x]
// -> 4.02159 sin(x) - 1.46962 cos(x) - 0.287476
var x = Enumerable.Range(1, 6).Select(Convert.ToDouble).ToArray();
var y = new[] { 4.986, 2.347, 2.061, -2.995, -2.352, -5.782 };
var resp = Fit.LinearCombination(x, y, z => 1.0, Math.Sin, Math.Cos);
Assert.AreEqual(3, resp.Length);
Assert.AreEqual(-0.287476, resp[0], 1e-4);
Assert.AreEqual(4.02159, resp[1], 1e-4);
Assert.AreEqual(-1.46962, resp[2], 1e-4);
var resf = Fit.LinearCombinationFunc(x, y, z => 1.0, Math.Sin, Math.Cos);
foreach (var z in Enumerable.Range(-3, 10))
{
Assert.AreEqual(4.02159 * Math.Sin(z) - 1.46962 * Math.Cos(z) - 0.287476, resf(z), 1e-4);
}
}
public Tuple <double, Func <double, double>, Func <double, double>, Func <double, double> > fit_sinewave(double[] Angle_Rad, double[] Ypoint1, double[] Ypoint2)
{
var M = Matrix <double> .Build;
var V = Vector <double> .Build;
var omega = 1.0d;
double[] p1 = Fit.LinearCombination(Angle_Rad, Ypoint1,
x => 1.0,
x => Math.Sin(x * omega),
x => Math.Cos(x * omega));
var a = p1[0];
var b = SpecialFunctions.Hypotenuse(p1[1], p1[2]);
var c = Math.Atan2(p1[2], p1[1]);
double[] p2 = Fit.LinearCombination(Angle_Rad, Ypoint2,
x => 1.0,
x => Math.Sin(x * omega),
x => Math.Cos(x * omega));
var d = p2[0];
var e = SpecialFunctions.Hypotenuse(p2[1], p2[2]);
var f = Math.Atan2(p2[2], p2[1]);
//double[] p3 = Fit.LinearCombination(Angle_Rad, Ypoint2,
// x => 1.0,
// x => Math.Sin(x * omega),
// x => Math.Cos(x * omega));
//var g = p2[0];
//var h = SpecialFunctions.Hypotenuse(p3[1], p3[2]);
//var i = Math.Atan2(p3[2], p3[1]);
Console.WriteLine("Radius Lower Plane Circle " + b);
double ArcSinFuncLowerPlane = Math.Asin(1);
double XPointAtPeakLower = (ArcSinFuncLowerPlane - c);
double ArcSinFuncUpperPlane = Math.Asin(1);
double XPointAtPeakUpper = (ArcSinFuncUpperPlane - f);
double ThetaR = (XPointAtPeakUpper - XPointAtPeakLower);
Console.WriteLine("Theta in radians :-" + ThetaR);
double Rt = b;
double Rb = e;
double BTopSec = Rt * Rb * Math.Sin(ThetaR);
Console.WriteLine("BTopSec value: " + BTopSec);
double BBottomSec = Math.Sqrt(Math.Pow(Rt, 2) + Math.Pow(Rb, 2) - (2 * Rt * Rb * Math.Cos(ThetaR)));
Console.WriteLine("BBottomSec value: " + BBottomSec);
double B = BTopSec / BBottomSec;
Console.WriteLine("B value: " + B);
double Alpha_Deg;
double A;
double alpha;
if (ThetaR < Math.PI / 2) //if thetaR less than Pi/2
{
A = Math.Sqrt(Math.Pow(Rt, 2) - Math.Pow(B, 2)) - Math.Sqrt(Math.Pow(Rb, 2) - Math.Pow(B, 2));
Console.WriteLine("A value: " + A);
alpha = Math.Atan(A / 500);
Alpha_Deg = (alpha * 180) / Math.PI;
}
else
{
A = Math.Sqrt(Math.Pow(Rt, 2) - Math.Pow(B, 2)) + Math.Sqrt(Math.Pow(Rb, 2) - Math.Pow(B, 2));
Console.WriteLine("A value: " + A);
alpha = Math.Atan(A / 500);
Alpha_Deg = (alpha * 180) / Math.PI;
}
Console.WriteLine("Inclination Angle: " + Math.Abs(Alpha_Deg));
Func <double, double> sinewave = (x) => a + b * Math.Sin(x + c);
Func <double, double> sinewave_2 = (x) => d + e * Math.Sin(x + f);
Func <double, double> sinewave_3 = (x) => d + e * Math.Sin(x + f);
return(Tuple.Create(Math.Abs(Alpha_Deg), sinewave, sinewave_2, sinewave_3));
}
private void TimerCallback(object state)
{
string xText, yText, zText;
string Fitting_Result;
string statusText;
double dt = 1 / GraphData.Cycle;
/* Read and format accelerometer data */
for (int t = 0; t < cycle; t++)
{
time[t] = t * GraphData.dt;
}
try
{
Acceleration accel = ReadI2CAccel();
xText = String.Format("X Axis: {0:F3}G", accel.X);
yText = String.Format("Y Axis: {0:F3}G", accel.Y);
zText = String.Format("Z Axis: {0:F3}G", accel.Z);
acceleration[cycle - 1] = accel.X;
/*refresh the data in the fitting chunk*/
for (acc = 1; acc < cycle; acc++)
{
pre_acc = acc - 1;
acceleration[pre_acc] = acceleration[acc];
}
GraphData.Xdata = time;
GraphData.Ydata = acceleration;
//xdata = time;
//ydata = acceleration;
double[] p = Fit.LinearCombination(
//y = p0 + p1cos(wt) + p2sin(wt); Amplitude = (p1^2+p2^2)^1/2
time,
acceleration,
x => 1.0,
x => Math.Sin(2 * Math.PI * GraphData.Frequency * x),
x => Math.Cos(2 * Math.PI * GraphData.Frequency * x));
GraphData.Amplitude = Math.Sqrt(Math.Pow(p[1], 2) + Math.Pow(p[2], 2));
GraphData.Intercept = p[0];
GraphData.PhaseShift = Math.Acos(p[2] / GraphData.Amplitude);
Fitting_Result = String.Format("Fitting Result: {0:F3}G", GraphData.Amplitude);
statusText = "Status: Running";
//foreach (double acc in acceleration)
// Debug.WriteLine(acc);
}
catch (Exception ex)
{
xText = "X Axis: Error";
yText = "Y Axis: Error";
zText = "Z Axis: Error";
Fitting_Result = "Byeeeeeetch";
statusText = "Failed to read from Accelerometer: " + ex.Message;
}
/* UI updates must be invoked on the UI thread */
var task = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
Text_X_Axis.Text = xText;
Text_Y_Axis.Text = yText;
Text_Z_Axis.Text = zText;
Text_Fitting_Result.Text = Fitting_Result;
Text_Status.Text = statusText;
//plotView.Model = PlotModelDefine.ScatterTry();
});
}
