public void Standardize(double mean, double standardDeviation)
{
Descriptive.Standardize(this.Elements, mean, standardDeviation);
ClearAllMeasures();
InvalidateAll();
//this.Size = 0;
}
public virtual double Moment(int k, double c)
{
if (k < 0)
{
throw new ArgumentException(Cern.LocalizedResources.Instance().Exception_KMustBePositive);
}
//checkOrder(k);
if (!HasSumOfPowers(k))
{
return(Double.NaN);
}
int maxOrder = System.Math.Min(k, GetMaxOrderForSumOfPowers());
DoubleArrayList sumOfPows = new DoubleArrayList(maxOrder + 1);
sumOfPows.Add(Size);
sumOfPows.Add(Sum);
sumOfPows.Add(SumOfSquares);
for (int i = 3; i <= maxOrder; i++)
{
sumOfPows.Add(GetSumOfPowers(i));
}
return(Descriptive.Moment(k, c, Size, sumOfPows.ToArray()));
}
public override double GetSumOfPowers(int k)
{
// no chaching for this measure
if (k >= -1 && k <= 2)
{
return(base.GetSumOfPowers(k));
}
return(Descriptive.SumOfPowers(this.Elements, k));
}
public void PopulateDescriptiveStatistics(PlottableProperty plottableProperty)
{
var plottableValues = Array.ConvertAll(SampleInstances[plottableProperty.PropertyName].ToArray(), input => Convert.ToDouble(input));
if (plottableValues.Count() != 0)
{
PopulateBins(plottableValues, _numberBins, plottableProperty.PropertyName);
Descriptive descriptiveStats = new Descriptive(plottableValues);
descriptiveStats.Analyze();
Statistics = descriptiveStats.Result;
StatisticsList = new ObservableCollection <KeyValuePair <string, string> >(PlottingUtilities.GetFieldAndPropertyValueList(descriptiveStats.Result));
}
}
private double CalculateWindowThreshold(double[] list, double parameterOmega)
{
//lstDHG.DHGs.Select(x => x.HeartbeatScore).ToArray<double>()
if (list.Length == 1)
{
return(list[0]);
}
Descriptive desp = new Descriptive(list);
desp.Analyze();
return(desp.Result.Mean + parameterOmega * desp.Result.StdDev);
}
public void PopulateDescriptiveStatistics(PlottableProperty plottableProperty)
{
var plottableValues = SampleInstances.Select(i => new PlottableValue <T> {
X = SampleInstances.IndexOf(i), Value = i
}).ToList();
var plottablePoints = PlottingUtilities.ToPlottable <T>(plottableValues, plottableProperty).Select(p => p.Y).ToArray();
if (plottablePoints.Count() != 0)
{
PopulateBins(plottablePoints, _numberBins, plottableProperty.PropertyName);
Descriptive descriptiveStats = new Descriptive(plottablePoints);
descriptiveStats.Analyze();
Statistics = descriptiveStats.Result;
StatisticsList = new ObservableCollection <KeyValuePair <string, string> >(PlottingUtilities.GetFieldAndPropertyValueList(descriptiveStats.Result));
}
}
public override void AddAllOfFromTo(DoubleArrayList list, int from, int to)
{
base.AddAllOfFromTo(list, from, to);
if (_sumOfPowers != null)
{
//int max_k = this.min_k + this.SumOfPowers.Length-1;
Descriptive.IncrementalUpdateSumsOfPowers(list, from, to, 3, GetMaxOrderForSumOfPowers(), ref _sumOfPowers);
}
if (this.HasSumOfInversions)
{
this.SumOfInversions += Descriptive.SumOfInversions(list, from, to);
}
if (this.HasSumOfLogarithms)
{
this.SumOfLogarithms += Descriptive.SumOfLogarithms(list, from, to);
}
}
/// <summary>
/// assertion: isBasicParametersValid == false
///
/// </summary>
protected void UpdateIncrementalStats()
{
// prepare arguments
double[] arguments = new double[4];
arguments[0] = base.Min;
arguments[1] = base.Max;
arguments[2] = base.Sum;
arguments[3] = base.SumOfSquares;
Descriptive.IncrementalUpdate(this.Elements, this.Size, this.Elements.Size - 1, ref arguments);
// store the new parameters back
base.Min = arguments[0];
base.Max = arguments[1];
base.Sum = arguments[2];
base.SumOfSquares = arguments[3];
this.isIncrementalStatValid = true;
//this.Size = this.Elements.Count; // next time we don't need to redo the stuff we have just done..
}
public override void AddAllOfFromTo(DoubleArrayList list, int from, int to)
{
//if (this.arguments == null) setUpCache();
lock (arguments) {
// prepare arguments
arguments[0] = this.min;
arguments[1] = this.max;
arguments[2] = this.sum;
arguments[3] = this.sum_xx;
Descriptive.IncrementalUpdate(list, from, to, ref arguments);
// store the new parameters back
this.min = arguments[0];
this.max = arguments[1];
this.sum = arguments[2];
this.sum_xx = arguments[3];
this.size += to - from + 1;
}
}
public double TrimmedMean(int s, int l)
{
// no caching for this parameter.
return(Descriptive.TrimmedMean(sortedElements_unsafe(), Mean(), s, l));
}
protected void FillEstadisticas(int[] l,double[] li )
{
try
{
statistics s = new statistics();
s.list = l;
TxtMediana.Text = s.mediana().ToString();
TxtMediaAcot.Text = s.mean().ToString();
TxtPromedio.Text = s.mean().ToString();
Descriptive d = new Descriptive(li);
d.Analyze();
DescriptiveResult res = d.Result;
TxtDesviacionEs.Text = res.StdDev.ToString("0,0.00", CultureInfo.InvariantCulture);
if (res.StdDev <= 30)
{
TxtVarianza.Text = "7";
}
else if (res.StdDev <= 60)
{
TxtVarianza.Text = "6";
}
else if (res.StdDev <= 120)
{
TxtVarianza.Text = "5";
}
else if (res.StdDev <= 500)
{
TxtVarianza.Text = "4";
}
else if (res.StdDev <= 1000)
{
TxtVarianza.Text = "3";
}
else if (res.StdDev <= 2000)
{
TxtVarianza.Text = "2";
}
else
{
TxtVarianza.Text = "1";
}
//SI(E5<=30;7;SI(E5<=60;6;SI(E5<=120;5;SI(E5<=500;4;SI(E5<=1000;3;SI(E5<=2000;2;1))))))
}
catch (Exception ex)
{
Log.EscribirError(ex);
Log.EscribirTraza("Error al calcular estadisticas del acta" + Session["acta"].ToString());
}
}
/// <summary>
/// Test building blocks of interest rate swap exposure calculation.
/// </summary>
public void TestBasics(LinearGaussianModel model, IEnumerable <NArray> allZeroRatesT0,
TimePoint[] timePoints, SimulationGraph graph)
{
bool testModel = true;
if (testModel)
{
var check1 = model[1, timePoints[1].DateTime.AddDays(182)].First();
Assert.IsTrue(TestHelpers.AgreesAbsolute(check1, 1.0015314301020275));
var check2 = model[1, timePoints[1].DateTime.AddDays(91)].First();
Assert.IsTrue(TestHelpers.AgreesAbsolute(check2, 1.0007451895710209));
var check3 = model.ForwardRate(1,
timePoints[1].DateTime.AddDays(91), timePoints[1].DateTime.AddDays(182)).First();
Assert.IsTrue(TestHelpers.AgreesAbsolute(check3, -0.0031509366920208916));
}
bool testProfile = true;
if (testProfile)
{
var testVariates0 = graph.RegisterFactor <NormalVariates>("IR_DiscountFactor_EUR_Factor0");
var testVariates1 = graph.RegisterFactor <NormalVariates>("IR_DiscountFactor_EUR_Factor1");
var testVariates2 = graph.RegisterFactor <NormalVariates>("IR_DiscountFactor_EUR_Factor2");
var check = Descriptive.Correlation(testVariates1.Value, testVariates2.Value);
// check 3M rolling tenor
var percentiles = new double[] { 1, 10, 50, 90, 99 };
var measures = new List <IList <double> >();
for (int i = 0; i < timePoints.Length; ++i)
{
var tenorMonths = 3;
var tenorYears = tenorMonths / 12.0;
var df = model[i, timePoints[i].DateTime.AddMonths(3)];
var zeroRate = -NMath.Log(df) / tenorYears;
var values = NMath.Percentiles(zeroRate, percentiles).ToList();
measures.Add(values);
}
var times = timePoints.Select(p => p.YearsFromBaseDate).ToArray();
var profile10 = measures.Select(p => p[1]).ToArray();
var profile90 = measures.Select(p => p[3]).ToArray();
}
bool testForwardRate = true;
if (testForwardRate)
{
// check 3M rolling tenor
var percentiles = new double[] { 1, 10, 50, 90, 99 };
var measures = new List <IList <double> >();
for (int i = 0; i < timePoints.Length; ++i)
{
var tenorMonths = 3;
var tenorYears = tenorMonths / 12.0;
var forwardRate = model.ForwardRate(i, timePoints[i].DateTime.AddMonths(3), timePoints[i].DateTime.AddMonths(6));
var values = NMath.Percentiles(forwardRate, percentiles).ToList();
measures.Add(values);
}
var times = timePoints.Select(p => p.YearsFromBaseDate).ToArray();
var profile10 = measures.Select(p => p[1]).ToArray();
var profile90 = measures.Select(p => p[3]).ToArray();
}
bool testAAD = true;
if (testAAD)
{
// just get the result
var result0 = NArray.Evaluate(() =>
{
var df = model[10, timePoints[10].DateTime.AddMonths(3)];
return(df);
});
// get the result and single derivative
var result1 = NArray.Evaluate(() =>
{
var df = model[10, timePoints[10].DateTime.AddMonths(3)];
return(df);
}, model.ZeroRatesT0[6].Value);
var log = new StringBuilder();
// get the result and all derivatives (and log output)
var result2 = NArray.Evaluate(() =>
{
var df = model[10, timePoints[10].DateTime.AddMonths(3)];
return(df);
}, log, allZeroRatesT0.ToArray());
// now forward rate and all derivatives
var result3 = NArray.Evaluate(() =>
{
var df = model.ForwardRate(10, timePoints[10].DateTime.AddMonths(3), timePoints[10].DateTime.AddMonths(6));
return(df);
}, allZeroRatesT0.ToArray());
var unbumped0 = model[10, timePoints[10].DateTime.AddMonths(3)];
var expected0 = unbumped0.DebugDataView.ToArray();
var unbumped3 = model.ForwardRate(10, timePoints[10].DateTime.AddMonths(3), timePoints[10].DateTime.AddMonths(6));
var expected3 = unbumped3.DebugDataView.ToArray();
var obtained0 = result1[0].DebugDataView.ToArray();
var obtained1 = result1[0].DebugDataView.ToArray();
var obtained2 = result2[0].DebugDataView.ToArray();
var obtained3 = result3[0].DebugDataView.ToArray();
Assert.IsTrue(TestHelpers.AgreesAbsolute(expected0, obtained0));
Assert.IsTrue(TestHelpers.AgreesAbsolute(expected0, obtained1));
Assert.IsTrue(TestHelpers.AgreesAbsolute(expected0, obtained2));
Assert.IsTrue(TestHelpers.AgreesAbsolute(expected3, obtained3));
var logCheck = log.ToString();
var obtained_deriv1 = result1[1].DebugDataView.ToArray();
var obtained_deriv2 = result2[7].DebugDataView.ToArray();
var obtained_deriv3 = result3[7].DebugDataView.ToArray();
model.ZeroRatesT0.Data[6] = new DataPoint(model.ZeroRatesT0.Data[6].Time, model.ZeroRatesT0.Data[6].Value + 1e-6);
var bumped0 = model[10, timePoints[10].DateTime.AddMonths(3)];
var bumped3 = model.ForwardRate(10, timePoints[10].DateTime.AddMonths(3), timePoints[10].DateTime.AddMonths(6));
var expected_deriv1 = ((bumped0 - unbumped0) / 1e-6)
.DebugDataView.ToArray();
var expected_deriv3 = ((bumped3 - unbumped3) / 1e-6)
.DebugDataView.ToArray();
Assert.IsTrue(TestHelpers.AgreesAbsolute(expected_deriv1, obtained_deriv1, 1e-5));
Assert.IsTrue(TestHelpers.AgreesAbsolute(expected_deriv1, obtained_deriv2, 1e-5));
Assert.IsTrue(TestHelpers.AgreesAbsolute(expected_deriv3, obtained_deriv3, 1e-5));
}
bool checkTimings = true;
if (checkTimings)
{
// check timings
Console.WriteLine("Immediate execution");
VectorAccelerator.Tests.TestHelpers.Timeit(() =>
{
var df = model[10, timePoints[10].DateTime.AddMonths(3)];
}, 10, 10);
Console.WriteLine(); Console.WriteLine("Deferred execution no derivatives");
VectorAccelerator.Tests.TestHelpers.Timeit(() =>
{
NArray.Evaluate(() =>
{
var df = model[10, timePoints[10].DateTime.AddMonths(3)];
return(df);
});
}, 10, 10);
Console.WriteLine(); Console.WriteLine("Deferred execution all derivatives");
VectorAccelerator.Tests.TestHelpers.Timeit(() =>
{
NArray.Evaluate(() =>
{
var df = model[10, timePoints[10].DateTime.AddMonths(3)];
return(df);
}, allZeroRatesT0.ToArray());
}, 10, 10);
}
}
public override double Moment(int k, double c)
{
// currently no caching for this parameter
return(Descriptive.Moment(this.Elements, k, c));
}
/// <summary>
///
/// </summary>
protected void UpdateSumOfLogarithms()
{
base.SumOfLogarithms = Descriptive.SumOfLogarithms(this.Elements, 0, Size - 1);
this.isSumOfLogarithmsValid = true;
}
public virtual double Kurtosis()
{
return(Descriptive.Kurtosis(Moment(4, Mean()), StandardDeviation()));
}
public virtual double HarmonicMean()
{
return(Descriptive.HarmonicMean(Size, SumOfInversions));
}
public virtual double GeometricMean()
{
return(Descriptive.GeometricMean(Size, SumOfLogarithms));
}
public decimal Mean(dynamic DataPoints)
{
var Result = Descriptive.Mean(DataPoints);
return(Result);
}
public override double QuantileInverse(double element)
{
return(Descriptive.QuantileInverse(sortedElements_unsafe(), element));
}
/// <summary>
/// assertion: isBasicParametersValid == false
///
/// </summary>
protected void UpdateSumOfInversions()
{
base.SumOfInversions = Descriptive.SumOfInversions(this.Elements, 0, Size - 1);
this.isSumOfInversionsValid = true;
}
public double StandardError()
{
return(Descriptive.StandardError(Size, Variance()));
}
public void Frequencies(DoubleArrayList distinctElements, IntArrayList frequencies)
{
Descriptive.Frequencies(sortedElements_unsafe(), distinctElements, frequencies);
}
public double Rms()
{
return(Descriptive.Rms(Size, SumOfSquares));
}
public override double Quantile(double phi)
{
return(Descriptive.Quantile(sortedElements_unsafe(), phi));
}
public double Variance()
{
return(Descriptive.SampleVariance(Size, Sum, SumOfSquares));
}
/// <summary>
/// Returns the exact Quantiles of the specified percentages.
/// </summary>
/// <param name="percentages">the percentages for which Quantiles are to be computed.</param>
/// Each percentage must be in the interval <i>(0.0,1.0]</i>d <i>percentages</i> must be sorted ascending.
/// <returns>the exact Quantiles.</returns>
public override DoubleArrayList Quantiles(DoubleArrayList percentages)
{
return(Descriptive.Quantiles(sortedElements_unsafe(), percentages));
}
/// <summary>
/// Returns the product, which is <tt>Prod( x[i] )</tt>.
/// In other words: <tt>x[0]*x[1]*...*x[size()-1]</tt>.
/// </summary>
/// <returns>the product; <tt>Double.NaN</tt> if <tt>!hasSumOfLogarithms()</tt>.</returns>
public virtual double Product()
{
return(Descriptive.Product(Size, SumOfLogarithms));
}
public virtual double Skew()
{
return(Descriptive.Skew(Moment(3, Mean()), StandardDeviation()));
}
/// <summary>
/// Gets the Percentile value.
/// </summary>
/// <param name="percent">Pecentile, between 0 to 100</param>
/// <returns>Percentile value</returns>
public double Percentile(double percent)
{
return(Descriptive.Percentile(this.sortedData, percent));
}
