public static RealType[] ConvolveUniform <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> list_base, IList <RealType> list_kernel, bool corrected, int offset, int lenght)
{
if ((list_base.Count == 0) || (list_kernel.Count == 0))
{
throw new Exception("list_base and list_kernel must at least be of size 1");
}
RealType kernel_total = algebra.AddIdentity;
if (corrected)
{
for (int kernel_index = 0; kernel_index < list_kernel.Count; kernel_index++)
{
kernel_total = algebra.Add(kernel_total, list_kernel[kernel_index]);
}
}
RealType[] result = new RealType[lenght];
for (int result_index = 0; result_index < result.Length; result_index++)
{
RealType kernel_part = algebra.AddIdentity;
for (int kernel_index = 0; kernel_index < list_kernel.Count; kernel_index++)
{
if ((0 <= result_index + offset - kernel_index) && (result_index + offset - kernel_index < list_base.Count))
{
result[result_index] = algebra.Add(result[result_index], algebra.Multiply(list_base[result_index + offset - kernel_index], list_kernel[kernel_index]));
kernel_part = algebra.Add(kernel_part, list_kernel[kernel_index]);
}
}
if (corrected)
{
result[result_index] = algebra.Multiply(result[result_index], (algebra.Divide(kernel_total, kernel_part)));
}
}
return(result);
}
public static RealType MeanAll <RealType>(IAlgebraReal <RealType> algebra, IList <IList <RealType> > samples)
{
RealType total_count = algebra.AddIdentity;
RealType total_sum = algebra.AddIdentity;
foreach (IList <RealType> sample in samples)
{
total_count = algebra.Add(total_count, algebra.ToDomain((float)sample.Count));
total_sum = algebra.Add(total_sum, ToolsMathCollection.Sum(algebra, sample));
}
return(algebra.Divide(total_sum, total_count));
}
public static void AddRBA <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> array_0, IList <RealType> array_1, IList <RealType> array_destination)
{
for (int index = 0; index < array_0.Count; index++)
{
array_destination[index] = algebra.Add(array_0[index], array_1[index]);
}
}
public static RealType QuantileSorted <RealType>(
IAlgebraReal <RealType> algebra,
IList <RealType> array_sorted,
double quantile)
{
if ((quantile < 0.0f) || (1.0f < quantile))
{
throw new Exception("Out of range");
}
double index_real = array_sorted.Count * quantile;
int index_low = (int)Math.Floor(index_real);
if (index_low == array_sorted.Count)
{
return(array_sorted[array_sorted.Count - 1]);
}
else
{
RealType index_low_weight = algebra.ToDomain(index_real - (double)index_low);
RealType index_high_weight = algebra.Subtract(algebra.ToDomain(index_low + 1), algebra.ToDomain(index_real));
return(algebra.Add(
algebra.Multiply(array_sorted[index_low], index_low_weight),
algebra.Multiply(array_sorted[index_low + 1], index_high_weight)));
}
}
public static RealType[] AddMultiple <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> values_source, IList <RealType> values_add, RealType multiple)
{
RealType[] result = new RealType[values_source.Count];
for (int index = 0; index < values_source.Count; index++)
{
result[index] = algebra.Add(values_source[index], algebra.Multiply(values_add[index], multiple));
}
return(result);
}
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 RealType WeightedMean <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> values, IList <RealType> weights)
{
RealType value = algebra.AddIdentity;
for (int index = 0; index < values.Count; index++)
{
value = algebra.Add(value, algebra.Multiply(values[index], weights[index]));
}
return(algebra.Divide(value, Sum(algebra, weights)));
}
public static RealType Sum <RealType>(IAlgebraReal <RealType> algebra, IList <RealType> array)
{
RealType sum = algebra.AddIdentity;
for (int index = 0; index < array.Count; index++)
{
sum = algebra.Add(sum, array[index]);
}
return(sum);
}
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 RealType Compute(DomainType domain_value_0)
{
RealType value = algebra.AddIdentity;
for (int index = 0; index < basis_function_list.Count; index++)
{
value = algebra.Add(value, algebra.Multiply(basis_function_list[index].Compute(domain_value_0), weight_list[index]));
}
return(value);
}
public ElementType[] GetDisplayValues()
{
ElementType[] display_values = new ElementType[this.max_tree.RealElementCount];
ElementType[] display_values_max = this.max_tree.GetDisplayValues();
ElementType[] display_values_min = this.min_tree.GetDisplayValues();
for (int index = 0; index < display_values.Length; index++)
{
display_values[index] = algebra.Subtract(algebra.Add(display_values_max[index], display_values_min[index]), element_values[index]);
}
return(display_values);
}
public static RealType[] Sums1 <RealType>(IAlgebraReal <RealType> algebra, IList <IList <RealType> > list_list)
{
RealType[] sums_1 = new RealType[list_list[0].Count];
for (int index_0 = 0; index_0 < list_list.Count; index_0++)
{
for (int index_1 = 0; index_1 < list_list[0].Count; index_1++)
{
sums_1[index_1] = algebra.Add(sums_1[index_1], list_list[index_0][index_1]);
}
}
return(sums_1);
}
public static RealType[] Sums1 <RealType>(IAlgebraReal <RealType> algebra, RealType[,] array2d)
{
RealType[] sums_1 = new RealType[array2d.GetLength(1)];
for (int index_0 = 0; index_0 < array2d.GetLength(0); index_0++)
{
for (int index_1 = 0; index_1 < array2d.GetLength(1); index_1++)
{
sums_1[index_1] = algebra.Add(sums_1[index_1], array2d[index_0, index_1]);
}
}
return(sums_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 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 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))));
}