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)); }