public void SaveState()
{
List <string[]> array_list = new List <string[]>();
array_list.Add(new string[]
{
LastUpdateDateTime.ToString(),
"",
"",
"",
""
});
foreach (TradingCalenderEvent trading_calender_event in event_list)
{
array_list.Add(new string[]
{
trading_calender_event.EventTimeUTC.ToString(),
trading_calender_event.Symbol,
trading_calender_event.Description,
trading_calender_event.IsAllDay.ToString(),
ToolsString.DictionaryToString(trading_calender_event.Tags)
});
}
ToolsIOCSV.WriteCSVFile(database_path, ToolsCollection.ConvertToArray2D(array_list));
}
//TODO implement 3 mean variants
//http://www.itl.nist.gov/div898/handbook/eda/section3/eda35a.htm
public static double TestStatic(IList <IList <double> > samples)
{
double total_count = ToolsCollection.CountElements(samples);
double total_mean = ToolsMathStatistics.MeanAll(samples);
//double[] sample_means = ToolsMathStatistics.Means0(samples);
//double total_mean = ToolsMathStatistics.MedianAll(samples);
double[] sample_means = ToolsMathStatistics.Medians0(samples);
double summed_varriance = 0.0;
for (int sample_index = 0; sample_index < samples.Count; sample_index++)
{
summed_varriance += samples[sample_index].Count * ToolsMath.Sqr(sample_means[sample_index] - total_mean);
}
double total_variance = 0.0;
for (int sample_index = 0; sample_index < samples.Count; sample_index++)
{
for (int measurement_index = 0; measurement_index < samples[sample_index].Count; measurement_index++)
{
total_variance += ToolsMath.Sqr(samples[sample_index][measurement_index] - sample_means[sample_index]);
}
}
double degrees_of_freedom_0 = samples.Count - 1;
double degrees_of_freedom_1 = total_count - samples.Count;
double f_statistic = (degrees_of_freedom_1 * summed_varriance) / (degrees_of_freedom_0 * total_variance);
return(FisherSnedecor.CDF(degrees_of_freedom_0, degrees_of_freedom_1, f_statistic));
}
//------------- public functions -----------//
/*
* processing functions
*/
public float[] process(float[] input)
{
//apply function y = f(Wx)
//store local copy of the input and create space for bias
ToolsCollection.CopyRBA(input, d_input);
d_input[d_input_size - 1] = 1.0f; //put in bias
//calculate and store activation
ToolsCollection.SetValue(d_activation, 0.0f);
for (int o = 0; o < d_output_size; o++)
{
for (int i = 0; i < d_input_size; i++)
{
d_activation[o] += d_weights[o, i] * d_input[i];
}
}
//calculate and store output
for (int o = 0; o < d_output_size; o++)
{
d_output[o] = d_output_function.Compute((float)d_activation[o]); //TODO double?
}
//and return the output to be processed by later layers
return(d_output);
}
public void SolverLinearGMRESMathNetTrivial0()
{
SolverLinearGMRESMathNet gmres = new SolverLinearGMRESMathNet();
double[,] a = new double[5, 5];
a[0, 0] = 1;
a[1, 1] = 2;
a[2, 2] = 3;
a[3, 3] = 4;
a[4, 4] = 5;
Matrix <double> A = new DenseMatrix(5, 5, ToolsCollection.ConvertToArray1D(a));
Vector <double> x0 = new DenseVector(new double[5]);
Vector <double> b = new DenseVector(new double[] { 1, 2, 3, 4, 5 });
SolverLinearResult result = gmres.Solve(A, b, x0, 4);
Assert.AreEqual(0.9203, result.SolutionList[4][0], 0.001);
Assert.AreEqual(1.0399, result.SolutionList[4][1], 0.001);
Assert.AreEqual(0.9823, result.SolutionList[4][2], 0.001);
Assert.AreEqual(1.0050, result.SolutionList[4][3], 0.001);
Assert.AreEqual(0.9994, result.SolutionList[4][4], 0.001);
//[~, solutions, ~, ~] = gmres_simple(A, b, x0, 4, 1)
//0 0 0 0 0 d
//0.2298 0.4597 0.6895 0.9193 1.1491
//0.4897 0.8318 1.0262 1.0729 0.9719
//0.7346 1.0209 1.0404 0.9747 1.0050
//0.9203 1.0399 0.9823 1.0050 0.9994
}
public ReportDiscrete(IModelDiscrete <DomainType, LabelType> model, int[,] confusion_matrix_instances)
{
this.Model = model;
this.confusion_matrix_instances = ToolsCollection.Copy(confusion_matrix_instances);
this.confusion_matrix_rates = new double[confusion_matrix_instances.GetLength(0), confusion_matrix_instances.GetLength(1)];
int instance_count = 0;
this.CorrectLabelCount = 0;
for (int index_0 = 0; index_0 < confusion_matrix_instances.GetLength(0); index_0++)
{
for (int index_1 = 0; index_1 < confusion_matrix_instances.GetLength(1); index_1++)
{
instance_count += confusion_matrix_instances[index_0, index_1];
if (index_0 == index_1)
{
CorrectLabelCount += confusion_matrix_instances[index_0, index_1];
}
}
}
CorrectLabelRate = CorrectLabelCount / (double)instance_count;
for (int index_0 = 0; index_0 < confusion_matrix_instances.GetLength(0); index_0++)
{
for (int index_1 = 0; index_1 < confusion_matrix_instances.GetLength(1); index_1++)
{
confusion_matrix_rates[index_0, index_1] = (double)confusion_matrix_instances[index_0, index_1] / (double)instance_count;
}
}
}
public IDataContext SelectLabelsAndFeatures(IList <int> selected_feature_indexes, IList <int> selected_label_indexes)
{
IList <VariableDescriptor> new_feature_descriptors = ToolsCollection.SelectList(feature_descriptors, selected_feature_indexes);
IList <VariableDescriptor> new_label_descriptors = ToolsCollection.SelectList(label_descriptors, selected_label_indexes);
return(new DataContext(new_feature_descriptors, new_label_descriptors));
}
public Bitmap Render(IImageSpace3D <float, float> source_image)
{
Bitmap destination_image = new Bitmap(resolution_x, resolution_y);
float[] coordinates_y = ToolsCollection.Copy(render_origen);
for (int index_y = 0; index_y < resolution_x; index_y++)
{
ToolsMathCollection.AddRBA <float>(algebra, coordinates_y, render_stride_y, coordinates_y);
float[] coordinates_x = ToolsCollection.Copy(coordinates_y);
for (int index_x = 0; index_x < resolution_y; index_x++)
{
float[] coordinates_z = ToolsCollection.Copy(coordinates_x);
float max_value = source_image.GetLocationValue(coordinates_z);
ToolsMathCollection.AddRBA(algebra, coordinates_z, render_stride_z, coordinates_z);
for (int index_z = 1; index_z < resolution_z; index_z++)
{
float value = source_image.GetLocationValue(coordinates_z);
if (this.comparer.Compare(max_value, value) == -1)
{
max_value = value;
}
ToolsMathCollection.AddRBA(algebra, coordinates_z, render_stride_z, coordinates_z);
}
destination_image.SetPixel(index_x, index_y, this.converter.Compute(max_value));
ToolsMathCollection.AddRBA(algebra, coordinates_x, render_stride_x, coordinates_x);
}
}
return(destination_image);
}
public static ArrayType[,,] Select3D <ArrayType>(this ArrayType[,,,,] source, int dim_0, int dim_1, int dim_2, int[] offsets)
{
if ((dim_0 == dim_1) || (dim_1 == dim_2) || (dim_0 == dim_1))
{
throw new Exception("Dimension must be different");
}
int size_0 = source.GetLength(dim_0);
int size_1 = source.GetLength(dim_1);
int size_2 = source.GetLength(dim_2);
ArrayType[,,] target = new ArrayType[size_0, size_1, size_2];
Parallel.For(0, size_0, index_0 =>
{
int[] source_index = ToolsCollection.Copy(offsets);
source_index[dim_0] = index_0;
for (int index_1 = 0; index_1 < size_1; index_1++)
{
source_index[dim_1] = index_1;
for (int index_2 = 0; index_2 < size_2; index_2++)
{
source_index[dim_2] = index_2;
target[index_0, index_1, index_2] = source[source_index[0], source_index[1], source_index[2], source_index[3], source_index[4]];
}
}
});
return(target);
}
public void Write(BinaryWriter writer, IBinaryWriter <FeatureType> writer_features, IBinaryWriter <LabelType> writer_labels)
{
this.DataContext.Write(writer);
writer_features.Write(ToolsCollection.ConvertToArray2D(this.feature_data));
writer.Write(ToolsCollection.ConvertToArray2D(this.missing_data));
writer_labels.Write(ToolsCollection.ConvertToArray2D(this.label_data));
}
public TopologyElementRaster4D8Connectivity(IRaster4DInteger raster)
: base(raster, 8)
{
this.raster_size = ToolsCollection.Copy(raster.SizeArray);
this.size_01 = raster_size[0] * raster_size[1];
this.size_012 = size_01 * raster_size[2];
}
public TopologyElementRaster3D6Connectivity(IRaster3DInteger raster, float[] voxel_spacing)
: base(raster, 6)
{
this.raster_size = ToolsCollection.Copy(raster.SizeArray);
this.size_xy = raster_size[0] * raster_size[1];
this.neigbour_distance = new float[] { voxel_spacing[0], voxel_spacing[0], voxel_spacing[1], voxel_spacing[1], voxel_spacing[2], voxel_spacing[2] };
}
public static double TestStatic(IList <IList <double> > samples)
{
double sample_count = samples.Count;
double total_count = ToolsCollection.CountElements(samples);
double total_mean = ToolsMathStatistics.MeanAll(samples);
IList <double> sample_means = ToolsMathStatistics.Means0(samples);
double sstr = 0.0;
for (int sample_index = 0; sample_index < samples.Count; sample_index++)
{
sstr += samples[sample_index].Count * ToolsMath.Sqr(sample_means[sample_index] - total_mean);
}
double sse = 0.0;
for (int sample_index = 0; sample_index < samples.Count; sample_index++)
{
for (int measurement_index = 0; measurement_index < samples[sample_index].Count; measurement_index++)
{
sse += ToolsMath.Sqr(samples[sample_index][measurement_index] - sample_means[sample_index]);
}
}
//FTransform
double degrees_of_freedom_0 = (sample_count - 1.0);
double degrees_of_freedom_1 = (total_count - sample_count);
double summed_variance = sstr / degrees_of_freedom_0;
double total_varaiance = sse / degrees_of_freedom_1;
double f_statistic = summed_variance / total_varaiance;
return(FisherSnedecor.CDF(degrees_of_freedom_0, degrees_of_freedom_1, f_statistic));
}
public static Tuple <int [], int []> acummulate_histogram_with_next(int [] histogram, int minimal_bin_value)
{
int accumulated_value = 0;
int acummulating_bin_index = 0;
int [] bin_mapping = new int [histogram.Length];
for (int index = 0; index < histogram.Length; index++)
{
accumulated_value += histogram[index];
bin_mapping[index] = acummulating_bin_index;
if (minimal_bin_value <= accumulated_value)
{
accumulated_value = 0;
bin_mapping[index] = acummulating_bin_index;
acummulating_bin_index++;
}
}
if (accumulated_value != 0)
{
ToolsCollection.ReplaceRBA(bin_mapping, acummulating_bin_index, acummulating_bin_index - 1);
}
int [] acummulated_histogram = new int [acummulating_bin_index];
for (int index = 0; index < histogram.Length; index++)
{
acummulated_histogram[bin_mapping[index]] += histogram[index];
}
return(new Tuple <int [], int []>(acummulated_histogram, bin_mapping));
}
public static float [,] covariance(
float [][] data)
{
data = ToolsCollection.Transpose(data);
int column_count = data.Length;
float [,] covariance_array = new float [column_count, column_count];
float [] means = new float [column_count];
for (int index_column = 0; index_column < column_count; index_column++)
{
means[index_column] = ToolsMathStatistics.Mean(data[index_column]);
}
for (int index_column = 0; index_column < column_count; index_column++)
{
covariance_array[index_column, index_column] = ToolsMathCollectionFloat
.covariance(data[index_column], data[index_column], means[index_column], means[index_column]);
}
for (int index_row = 0; index_row < column_count; index_row++)
{
for (int index_column = index_row + 1; index_column < column_count; index_column++)
{
float covariance = ToolsMathCollectionFloat
.covariance(data[index_row], data[index_column], means[index_row], means[index_column]);
covariance_array[index_row, index_column] = covariance;
covariance_array[index_column, index_row] = covariance;
}
}
return(covariance_array);
}
//preferred for nominal
public VariableDescriptor(
string feature_name,
DataLevel feature_level,
Dictionary <string, int> feature_value_levels)
: this(feature_name, feature_level, ToolsCollection.ConvertToArray1D(feature_value_levels))
{
}
public override double Test(IList <IList <double> > samples)
{
double total_count = ToolsCollection.CountElements(samples);
double pooled_mean = ToolsMathStatistics.MeanAll(samples);
double nominator_part = 0.0;
double denominator_part = 0.0;
for (int sample_index = 0; sample_index < samples.Count; sample_index++)
{
double sample_mean = ToolsMathStatistics.Mean(samples[sample_index]);
double sample_median = ToolsMathStatistics.Quantile(samples[sample_index], 0.5f);
nominator_part += (sample_mean - pooled_mean) * (sample_mean - pooled_mean) * samples[sample_index].Count;
for (int measurement_index = 0; measurement_index < samples[sample_index].Count; measurement_index++)
{
double diff = Math.Abs(sample_median - samples[sample_index][measurement_index]) - sample_mean; //This is the difference with brown forsythe test
denominator_part += diff * diff;
}
}
double degrees_of_freedom_0 = samples.Count - 1;
double degrees_of_freedom_1 = total_count - samples.Count;
double f_statistic = (degrees_of_freedom_1 * nominator_part) / (degrees_of_freedom_0 * denominator_part);
FisherSnedecor distribution = new FisherSnedecor(degrees_of_freedom_0, degrees_of_freedom_1, new Random());
return(distribution.CumulativeDistribution(f_statistic));
}
public static double ComputeROCAUCTrapeziod <RealType>(IList <bool> labels, IList <RealType> sample)
where RealType : IComparable <RealType>
{
int postive_count = ToolsCollection.CountOccurance(labels, true);
double true_positive_increment = 1.0 / postive_count;
double false_positive_increment = 1.0 / (labels.Count - postive_count);
double[] true_positive_rates = new double[labels.Count + 1];
double[] false_positive_rates = new double[labels.Count + 1];
List <int> ordering = ToolsMathCollection.Ordering(sample);
for (int index = 1; index < labels.Count + 1; index++)
{
if (labels[ordering[index - 1]])
{
true_positive_rates[index] = true_positive_rates[index - 1] + true_positive_increment;
false_positive_rates[index] = false_positive_rates[index - 1];
}
else
{
true_positive_rates[index] = true_positive_rates[index - 1];
false_positive_rates[index] = false_positive_rates[index - 1] + false_positive_increment;
}
}
return(IntegralEvaluatorTrapezoid.EvaluateStaticValue(false_positive_rates, true_positive_rates));
}
public void get_model(IList <int []> instances)
{
// Convert
List <float []> instances_converted = new List <float []>();
foreach (int [] instance in instances)
{
instances_converted.Add(ToolsCollection.ConvertToFloatArray(instance));
}
// Transform
TransformWhiteningOld <Matrix <double> > transform = new TransformWhiteningOld <Matrix <double> >(new AlgebraLinearReal64MathNet(), ToolsCollection.ConvertToTable(instances_converted));
IList <float[]> instances_transformed = new List <float[]>();
foreach (float [] instance in instances_converted)
{
instances_transformed.Add(transform.Compute(instance));
}
// Cluster
//IClusteringModel<float []> model = d_inner.get_model(instances_transformed); //TODO
//return new KMeansDefaultWhiteningIntegerArrayModel(transform, model);
//return null; // TODO
}
public MaxTreeAutoDual(IAlgebraReal <ElementType> algebra, IMaxTreeBuilder <ElementType> builder, ITopologyElement topology, ElementType[] element_values)
{
this.algebra = algebra;
this.max_tree = builder.BuildMaxTree(element_values, new ComparerNatural <ElementType>(), topology, element_values.Length);
this.min_tree = builder.BuildMaxTree(element_values, new ComparerNatural <ElementType>(true), topology, element_values.Length);
this.element_values = ToolsCollection.Copy(element_values);
}
public List <ParameterSet> GetNeighborsArea(ParameterSet parameter_set)
{
int[] source_location = GetLocation(parameter_set);
List <int[]> locations = new List <int[]>();
for (int axes_index = 0; axes_index < AxesList.Count; axes_index++)
{
int[] new_location_0 = ToolsCollection.Copy(source_location);
int[] new_location_1 = ToolsCollection.Copy(source_location);
new_location_0[axes_index]++;
new_location_1[axes_index]--;
if (Contains(new_location_0))
{
locations.Add(new_location_0);
}
if (Contains(new_location_1))
{
locations.Add(new_location_1);
}
}
List <ParameterSet> parameter_sets = new List <ParameterSet>();
foreach (int[] location in locations)
{
parameter_sets.Add(GetParameterSet(location));
}
return(parameter_sets);
}
public DomainType[] Minimize(DomainType[] state, IFunction <DomainType[], EvaluationType> evaluation_function)
{
DomainType[] new_state = ToolsCollection.Copy(state);
EvaluationType evaluation = evaluation_function.Compute(state);
for (int iteration_index = 0; iteration_index < IterationCount; iteration_index++)
{
int mutated_element = d_mutator.MutatePoint(d_random, new_state);
EvaluationType new_evaluation = evaluation_function.Compute(new_state);
// if new state is higher
if (new_evaluation.CompareTo(evaluation) == 1)
{
//accept it with a chance
if (d_random.Toss(d_accept_chance.Compute(iteration_index)))
{
state[mutated_element] = new_state[mutated_element];
evaluation = new_evaluation;
}
else
{
//reject it
new_state[mutated_element] = state[mutated_element];
}
}
else // if new state is lower or equal
{
//accept it
state[mutated_element] = new_state[mutated_element];
evaluation = new_evaluation;
}
}
return(state);
}
public static Tuple <double, double> TestStatic(IList <IList <double> > samples)
{
int sample_size = samples[0].Count;
foreach (IList <double> sample in samples)
{
if (sample.Count != sample_size)
{
throw new Exception("samples must be of equal size");
}
}
// Larsen Marx 4Th editiopn P779
double sample_count = samples.Count;
double total_count = ToolsCollection.CountElements(samples);
double total_mean = ToolsMathStatistics.MeanAll(samples);
double sum_squared_all = ToolsMathStatistics.SumSquaredAll(samples);
IList <double> sample_sums = ToolsMathCollection.Sums0(samples);
IList <double> measurement_sums = ToolsMathCollection.Sums1(samples);
// compute C
double c = ToolsMath.Sqr(total_mean * total_count) / (sample_size * sample_count);
double sstot = sum_squared_all - c;
double ssb = 0;
for (int measurement_index = 0; measurement_index < sample_size; measurement_index++)
{
ssb += ToolsMath.Sqr(measurement_sums[measurement_index]) / sample_count;
}
ssb -= c;
double sstr = 0.0;
for (int sample_index = 0; sample_index < samples.Count; sample_index++)
{
sstr += ToolsMath.Sqr(sample_sums[sample_index]) / sample_size;
}
sstr -= c;
double sse = sstot - ssb - sstr;
double degrees_of_freedom_0_samples = (sample_count - 1.0);
double degrees_of_freedom_0_measurements = (sample_size - 1.0);
double degrees_of_freedom_1 = degrees_of_freedom_0_samples * degrees_of_freedom_0_measurements;
//F-Transform samples
double f_statistic_samples = (sstr / degrees_of_freedom_0_samples) / (sse / degrees_of_freedom_1);
//F-Transform measurements
double f_statistic_measurements = (ssb / degrees_of_freedom_0_measurements) / (sse / degrees_of_freedom_1);
return(new Tuple <double, double>(
FisherSnedecor.CDF(degrees_of_freedom_0_samples, degrees_of_freedom_1, f_statistic_samples),
FisherSnedecor.CDF(degrees_of_freedom_0_measurements, degrees_of_freedom_1, f_statistic_measurements)));
}
public float[] RandomSample(int sample_size)
{
double[] sample = new double[sample_size];
Random random = new Random();
Normal.Samples(random, sample, Mean, StandardDeviation);
return(ToolsCollection.ConvertToFloatArray(sample));
}
public ITransform GenerateTransform(IDataSet <double> data_set)
{
AMatrix <MatrixType> data = algebra.Create(ToolsCollection.ConvertToArray2D(data_set.FeatureData));
SVD <MatrixType> svd = algebra.ComputeSVD(data);
AMatrix <MatrixType> projection = svd.VT.Transpose().GetColumns(0, destination_dimension_count);
return(new DimensionReductionPCA <MatrixType>(data_set.DataContext, projection));
}
public static RealType QuantileIP <RealType>(
IAlgebraReal <RealType> algebra,
IList <RealType> list,
float quantile)
{
list = ToolsCollection.Sort(list, algebra);
return(QuantileSorted(algebra, list, quantile));
}
public TransformRescale(
float [] lower_bounds,
float [] upper_bounds)
{
this.lower_bounds = ToolsCollection.Copy(lower_bounds);
this.upper_bounds = ToolsCollection.Copy(upper_bounds);
window_sizes = ToolsMathCollectionFloat.subtract(upper_bounds, lower_bounds);
}
public static DataSet <FeatureType, LabelType> Read <FeatureType2, LabelType2>(BinaryReader reader, IBinaryReader <FeatureType> reader_features, IBinaryReader <LabelType> reader_labels)
{
DataContext data_context = DataSet.DataContext.Read(reader);
IList <FeatureType[]> feature_data = ToolsCollection.ConvertToArrayArray(reader_features.ReadArray2D());
IList <bool []> missing_data = ToolsCollection.ConvertToArrayArray(reader.ReadBooleanArray2D());
IList <LabelType[]> label_data = ToolsCollection.ConvertToArrayArray(reader_labels.ReadArray2D());
return(new DataSet <FeatureType, LabelType>(data_context, feature_data, missing_data, label_data));
}
public override bool Equals(object other)
{
if (other is Raster4DInteger)
{
Raster4DInteger other_typed = (Raster4DInteger)other;
return(ToolsCollection.EqualsArray(SizeArray, other_typed.SizeArray));
}
return(false);
}
public FileTypeDescriptor(string tag, string description, int signature_offset, byte[] signature, string default_extension)
{
this.Tag = tag;
this.Description = description;
this.SignatureOffset = signature_offset;
this.signature = ToolsCollection.Copy(signature);
this.ascii_signature = ToolsBinary.ByteArrayToRegularString(signature);
this.IsHeaderType = true;
}
public static RealType Quantile <RealType>(
IAlgebraReal <RealType> algebra,
IList <RealType> array,
float quantile)
{
RealType[] copy = ToolsCollection.Copy(array);
Array.Sort(copy, algebra);
return(QuantileSorted(algebra, array, quantile));
}
