// Convolution returns only space where the tot kernel fits in the base equivalent to matlab conv(a,b, 'valid') // Correction is irrelevant as only the portion with no need for correction is returned public static RealType[] ConvolveUniformValid <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> list_base, IList <RealType> list_kernel) { if (list_base.Count < list_kernel.Count) { throw new Exception("list_base must be must at least be of size of list_kernel"); } int offset = list_kernel.Count - 1; int lenght = list_base.Count - (list_kernel.Count - 1); return(ConvolveUniform(algebra, list_base, list_kernel, false, offset, lenght)); }
public static RealType[] QuantileSorted <RealType>( IAlgebraReal <RealType> algebra, IList <RealType> list_sorted, float[] quantiles) { //TODO this can be done much faster RealType[] values = new RealType[quantiles.Length]; for (int index = 0; index < quantiles.Length; index++) { values[index] = QuantileSorted(algebra, list_sorted, quantiles[index]); } return(values); }
public static RealType[] SubtractElements <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> list_0, IList <RealType> list_1) { if (list_0.Count != list_1.Count) { throw new Exception("Size mismatch: " + list_0.Count + " does not match with " + list_1.Count); } RealType[] result = new RealType[list_0.Count]; Parallel.For(0, result.Length, index => { result[index] = algebra.Subtract(list_0[index], list_1[index]); }); return(result); }
public static RealType[] AbsoluteDifference <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> list_0, IList <RealType> list_1) { if (list_0.Count != list_1.Count) { throw new Exception("Sizes do not match"); } RealType[] result = new RealType[list_0.Count]; Parallel.For(0, result.Length, index => { result[index] = algebra.Abs(algebra.Subtract(list_0[index], list_1[index])); }); return(result); }
public static RealType[] DivideElements <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> divided, IList <RealType> divisors) { if (divided.Count != divisors.Count) { throw new Exception("Size mismatch: " + divided.Count + " does not match with " + divisors.Count); } RealType[] result = new RealType[divided.Count]; Parallel.For(0, result.Length, index => { result[index] = algebra.Divide(divided[index], divisors[index]); }); return(result); }
public static int MaxIndex <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> array) { int max_index = 0; RealType max_value = array[0]; for (int index = 1; index < array.Count; index++) { if (algebra.CompareTo(array[index], max_value) == 1) { max_index = index; max_value = array[index]; } } return(max_index); }
/// <summary> /// Protected method which constructs a new KDNode. /// </summary> /// <param name="dimension_count">The number of dimensions for this node (all the same in the tree).</param> /// <param name="d_bucket_capacity">The initial capacity of the bucket.</param> protected KDNode(IAlgebraReal <DomainType> algebra, int dimension_count, int d_bucket_capacity) { // Algebra this.d_algebra = algebra; // Variables. this.d_dimension_count = dimension_count; this.d_bucket_capacity = d_bucket_capacity; this.Size = 0; this.bSinglePoint = true; // Setup leaf elements. this.d_points = new DomainType[d_bucket_capacity + 1][]; this.d_values = new LabelType[d_bucket_capacity + 1]; }
public static void Means1RBA <RealType>( IAlgebraReal <RealType> algebra, RealType[,] array_2d, IList <RealType> means) { for (int index_0 = 0; index_0 < array_2d.Length; index_0++) { for (int index_1 = 0; index_1 < means.Count; index_1++) { means[index_1] = algebra.Add(means[index_1], array_2d[index_0, index_1]); } } for (int index_1 = 0; index_1 < means.Count; index_1++) { means[index_1] = algebra.Divide(means[index_1], algebra.ToDomain((float)array_2d.Length)); } }
public Tuple <EdgeValueType[], EdgeValueType> CreateAlphaPartitionTreeElementArray <ElementValueType, EdgeValueType>( IAlgebraReal <EdgeValueType> algebra, IFunctionDissimilarity <ElementValueType, EdgeValueType> edge_function, ElementValueType[] element_values) { int element_count = ElementCount; EdgeValueType[] new_image = new EdgeValueType[element_count]; EdgeValueType max_value = algebra.MinValue; // do x edges for (int element_index = d_x_edge_offset; element_index < d_y_edge_offset; element_index++) { if (element_index % raster_size[0] != raster_size[0] - 1) { new_image[element_index] = edge_function.Compute( element_values[element_index - d_x_edge_offset], element_values[element_index - d_x_edge_offset + 1]); max_value = algebra.Max(max_value, new_image[element_index]); } } // do y edges for (int element_index = d_y_edge_offset; element_index < (element_count - raster_size[0]); element_index++) { new_image[element_index] = edge_function.Compute( element_values[element_index - d_y_edge_offset], element_values[element_index - d_y_edge_offset + raster_size[0]]); max_value = algebra.Max(max_value, new_image[element_index]); } // set node values for (int element_index = 0; element_index < d_x_edge_offset; element_index++) { new_image[element_index] = max_value; } // flip all edges for (int element_index = d_x_edge_offset; element_index < element_count; element_index++) { new_image[element_index] = algebra.Subtract(max_value, new_image[element_index]); } return(new Tuple <EdgeValueType[], EdgeValueType>(new_image, max_value)); }
public static RealType VariancePooled <RealType>( IAlgebraReal <RealType> algebra, IList <IList <RealType> > samples) { RealType variance = algebra.AddIdentity; RealType degrees_of_freedom = algebra.AddIdentity; foreach (IList <RealType> sample in samples) { RealType mean_0 = Mean(algebra, sample); for (int index = 0; index < sample.Count; index++) { variance = algebra.Add(variance, algebra.Sqr(algebra.Subtract(sample[index], mean_0))); } degrees_of_freedom = algebra.Add(degrees_of_freedom, algebra.ToDomain((float)(sample.Count - 1))); } return(algebra.Divide(variance, degrees_of_freedom)); }
public static void Means1RBA <RealType>( IAlgebraReal <RealType> algebra, IList <IList <RealType> > list_list, IList <RealType> means) { for (int index_0 = 0; index_0 < list_list.Count; index_0++) { for (int index_1 = 0; index_1 < means.Count; index_1++) { means[index_1] = algebra.Add(means[index_1], list_list[index_0][index_1]); } } for (int index_1 = 0; index_1 < means.Count; index_1++) { means[index_1] = algebra.Divide(means[index_1], algebra.ToDomain((float)list_list.Count)); } }
public ARendererImageSpace3DFloatProjection( IFunction <float, Color> converter, int[] resolution, float[] render_origen, float [] render_stride_x, float [] render_stride_y, float [] render_stride_z) { this.converter = converter; this.comparer = new ComparerNatural <float>(); this.algebra = new AlgebraRealFloat32(); this.resolution = resolution; this.coordinates_origen = render_origen; this.render_stride_x = render_stride_x; this.render_stride_y = render_stride_y; this.render_stride_z = render_stride_z; }
public static RealType VariancePooled <RealType>( IAlgebraReal <RealType> algebra, IList <RealType> sample_0, IList <RealType> sample_1) { RealType mean_0 = Mean(algebra, sample_0); RealType mean_1 = Mean(algebra, sample_1); RealType variance = algebra.AddIdentity; for (int index = 0; index < sample_0.Count; index++) { variance = algebra.Add(variance, algebra.Sqr(algebra.Subtract(sample_0[index], mean_0))); } for (int index = 0; index < sample_1.Count; index++) { variance = algebra.Add(variance, algebra.Sqr(algebra.Subtract(sample_1[index], mean_1))); } return(algebra.Divide(variance, algebra.ToDomain((float)(sample_0.Count + sample_1.Count - 2)))); }
public RendererImageSpace3DFloatZMIP(IFunction <float, Color> converter, int resolution_x, int resolution_y, int resolution_z, float[] render_origen, float render_stride_x, float render_stride_y, float render_stride_z) { this.converter = converter; this.comparer = new ComparerNatural <float>(); this.algebra = new AlgebraRealFloat32(); this.resolution_x = resolution_x; this.resolution_y = resolution_y; this.resolution_z = resolution_z; this.render_origen = render_origen; this.render_stride_x = new float[3]; this.render_stride_y = new float[3]; this.render_stride_z = new float[3]; this.render_stride_x[0] = render_stride_x; this.render_stride_y[1] = render_stride_y; this.render_stride_z[2] = render_stride_z; }
public static List <Tuple <int, int> > FindPeakIntervals <ValueType>(IAlgebraReal <ValueType> algebra, IFunction <int, ValueType> function, int min_index, int max_index, ValueType peak_rate) { int temp_index = min_index - 1; int start_index = min_index - 1; int index = min_index - 1; List <Tuple <int, int> > intervals = new List <Tuple <int, int> >(); while (index < max_index) { if ((algebra.Compare(function.Compute(index + 1), algebra.Multiply(peak_rate, function.Compute(start_index))) == -1) && (algebra.Compare(function.Compute(temp_index), (algebra.Multiply(peak_rate, function.Compute(start_index)))) == 1)) { int peak_index = start_index; while (algebra.Compare(function.Compute(peak_index - 1), (algebra.Multiply(peak_rate, function.Compute(start_index)))) != -1) { peak_index = peak_index - 1; } intervals.Add(new Tuple <int, int>(peak_index, index)); } if ((algebra.Compare(function.Compute(index + 1), function.Compute(temp_index)) == -1) || (algebra.Compare(function.Compute(index + 1), algebra.Multiply(peak_rate, function.Compute(start_index))) == -1)) { temp_index = index + 1; start_index = index + 1; index = index + 1; } else if (algebra.Compare(function.Compute(index + 1), function.Compute(start_index)) == -1) { start_index = index + 1; index = index + 1; } else { index = index + 1; } } return(intervals); }
/// <summary> /// Create a new KD-Tree given a number of dimensions and initial bucket capacity. /// </summary> /// <param name="dimension_count">The number of data sorting dimensions. i.e. 3 for a 3D point.</param> /// <param name="bucket_capacity">The default number of items that can be stored in each node.</param> public KDTree(IAlgebraReal <DomainType> algebra, int dimension_count, int bucket_capacity) : base(algebra, dimension_count, bucket_capacity) { this.algebra = algebra; DimensionCount = dimension_count; }
public ConvoluterGenericStepCorrectedUnoffsetted(IAlgebraReal <RealType> algebra, RealType sample_time) { this.algebra = algebra; this.sample_time = sample_time; }
public AlphaPartitionTreeMinTree(IAlgebraReal <EdgeValueType> algebra, IMaxTree <EdgeValueType> min_tree, EdgeValueType max_edge_value) { this.algebra = algebra; this.min_tree = min_tree; this.max_edge_value = max_edge_value; }
public static RealType[] DivideElements <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> divided, RealType divisor) { RealType[] result = new RealType[divided.Count]; DivideElementsRBA(algebra, divided, divisor, result); return(result); }
//should be analogeus to matlab interp1 with method 'linear' public static RealType[] Resample <RealType>(IAlgebraReal <RealType> algebra, RealType[] old_sample_times, RealType[] old_values, RealType[] new_sample_times) { RealType[] new_values = new RealType[new_sample_times.Length]; ResampleRBA(algebra, old_sample_times, old_values, new_sample_times, new_values); return(new_values); }
//Richardson Extrapolation http://en.wikipedia.org/wiki/Richardson_extrapolation // // @param value * original value // @param refined_value * with base times smaller intervals // @param base * refinement factor of value // @param power * order of scale //@return public static RealType RichardsonExtrapolation <RealType>(IAlgebraReal <RealType> algebra, RealType value, RealType refined_value, RealType base_value, RealType power) { RealType scale = algebra.Pow(base_value, power); return(algebra.Divide(algebra.Subtract(algebra.Multiply(scale, refined_value), value), algebra.Subtract(scale, algebra.MultiplyIdentity))); }
public static RealType Interpolation1DLinear <RealType>(IAlgebraReal <RealType> algebra, RealType fraction_0, RealType value_0, RealType value_1) { return(algebra.Add(algebra.Multiply(value_0, fraction_0), algebra.Multiply(value_1, algebra.Subtract(algebra.MultiplyIdentity, fraction_0)))); }
public FilterAlfaPartitionMean(IAlgebraReal <ElementType> algebra) { this.algebra = algebra; }
public AlphaPartitionTreeBuilderMinTree(IAlgebraReal <EdgeValueType> algebra, IMaxTreeBuilder <EdgeValueType> builder) { this.builder = builder; this.algebra = algebra; }
public FunctionWeigthed(IAlgebraReal <RealType> algebra, IList <IFunction <DomainType, RealType> > basis_function_list, IList <RealType> weight_list) { this.algebra = algebra; this.basis_function_list = basis_function_list; this.weight_list = weight_list; }
public FilterWindow(IAlgebraReal <RealType> algebra, IFilterWindow <RealType> window) { this.algebra = algebra; this.window = window; //d_time_offset_limit = this.algebra.FloorInt(window.HalfWindowWidth); }
/// <summary> /// Create a new KD-Tree given a number of dimensions. /// </summary> /// <param name="dimension_count">The number of data sorting dimensions. i.e. 3 for a 3D point.</param> public KDTree(IAlgebraReal <DomainType> algebra, int dimension_count) : this(algebra, dimension_count, 24) { }
public static RealType Interpolation1DLinear <RealType>(IAlgebraReal <RealType> algebra, RealType domain_0, RealType value_0, RealType domain_1, RealType value_1, RealType domain_new) { return(Interpolation1DLinear(algebra, algebra.Divide(algebra.Subtract(domain_new, domain_0), algebra.Subtract(domain_1, domain_0)), value_0, value_1)); }
public MaxTreeFilterMean(IFunction <IMaxTreeNode <ElementType>, bool> filter_function, IAlgebraReal <ElementType> algebra, ElementType[] source_values) { this.filter_function = filter_function; this.source_values = source_values; this.algebra = algebra; }
public static RealType Mean <RealType>( IAlgebraReal <RealType> algebra, IList <RealType> sample_0) { return(algebra.Divide(ToolsMathCollection.Sum(algebra, sample_0), algebra.ToDomain((float)sample_0.Count))); }