public virtual void test_combineLenient() { System.Func <double, double, double> @operator = (a, b) => a / b; assertThat(DoubleArrayMath.combineLenient(ARRAY_1_2, ARRAY_3_4, @operator)).contains(1d / 3d, 2d / 4d); assertThat(DoubleArrayMath.combineLenient(ARRAY_1_2, ARRAY_3, @operator)).contains(1d / 3d, 2d); assertThat(DoubleArrayMath.combineLenient(ARRAY_3, ARRAY_1_2, @operator)).contains(3d / 1d, 2d); }
public virtual void test_mutate() { System.Func <double, double> @operator = a => 1 / a; double[] testArray = ARRAY_1_2.Clone(); DoubleArrayMath.mutate(testArray, @operator); assertThat(testArray).contains(1d, 1d / 2d); }
public virtual void test_sortPairs_doubledouble_2() { double[] keys = new double[] { 3d, 2d, 5d, 4d }; double[] values = new double[] { 6d, 4d, 10d, 8d }; DoubleArrayMath.sortPairs(keys, values); assertThat(keys).containsExactly(2d, 3d, 4d, 5d); assertThat(values).containsExactly(4d, 6d, 8d, 10d); }
public virtual void test_sortPairs_doubleObject_2() { double[] keys = new double[] { 3d, 2d, 5d, 4d }; int?[] values = new int?[] { 6, 4, 10, 8 }; DoubleArrayMath.sortPairs(keys, values); assertThat(keys).containsExactly(2d, 3d, 4d, 5d); assertThat(values).containsExactly(4, 6, 8, 10); }
public virtual void test_fuzzyEquals() { assertThat(DoubleArrayMath.fuzzyEquals(DoubleArrayMath.EMPTY_DOUBLE_ARRAY, ARRAY_0_0, 1e-2)).False; assertThat(DoubleArrayMath.fuzzyEquals(ARRAY_0_0, ARRAY_0_0, 1e-2)).True; assertThat(DoubleArrayMath.fuzzyEquals(ARRAY_1_2, ARRAY_1_2, 1e-2)).True; assertThat(DoubleArrayMath.fuzzyEquals(ARRAY_1_2, ARRAY_1_2B, 1e-2)).True; assertThat(DoubleArrayMath.fuzzyEquals(ARRAY_1_2, ARRAY_1_2B, 1e-3)).True; assertThat(DoubleArrayMath.fuzzyEquals(ARRAY_1_2, ARRAY_1_2B, 1e-4)).False; }
/// <summary> /// Multiplies values in two arrays, mutating the first array. /// <para> /// The arrays must be the same length. Each value in {@code array} is multiplied by the value at the /// corresponding index in {@code arrayToMultiplyBy}. /// /// </para> /// </summary> /// <param name="array"> the array to mutate </param> /// <param name="arrayToMultiplyBy"> the array containing values to multiply by </param> public static void mutateByMultiplication(double[] array, double[] arrayToMultiplyBy) { int length = DoubleArrayMath.length(array, arrayToMultiplyBy); for (int i = 0; i < length; i++) { array[i] *= arrayToMultiplyBy[i]; } }
/// <summary> /// Adds values in two arrays together, mutating the first array. /// <para> /// The arrays must be the same length. Each value in {@code arrayToAdd} is added to the value at the /// corresponding index in {@code array}. /// /// </para> /// </summary> /// <param name="array"> the array to mutate </param> /// <param name="arrayToAdd"> the array containing values to add </param> public static void mutateByAddition(double[] array, double[] arrayToAdd) { int length = DoubleArrayMath.length(array, arrayToAdd); for (int i = 0; i < length; i++) { array[i] += arrayToAdd[i]; } }
/// <summary> /// Combines two arrays, returning an array where each element is the combination of the two matching inputs. /// <para> /// Each element in the result will be the combination of the matching index in the two /// input arrays using the operator. The two input arrays must have the same length. /// </para> /// <para> /// The result is always a new array. The input arrays are not mutated. /// /// </para> /// </summary> /// <param name="array1"> the first array </param> /// <param name="array2"> the second array </param> /// <param name="operator"> the operator to use when combining values </param> /// <returns> an array combining the two input arrays using the operator </returns> public static double[] combine(double[] array1, double[] array2, System.Func <double, double, double> @operator) { int length = DoubleArrayMath.length(array1, array2); double[] result = new double[length]; for (int i = 0; i < length; i++) { result[i] = @operator(array1[i], array2[i]); } return(result); }
public virtual void test_mutateByMultiplication_byArray() { double[] testArray = ARRAY_1_2.Clone(); DoubleArrayMath.mutateByMultiplication(testArray, new double[] { 4d, 5d }); assertThat(testArray).contains(4d, 10d); }
public virtual void toObject() { assertThat(DoubleArrayMath.toObject(new double[] {})).isEqualTo(new double?[] {}); assertThat(DoubleArrayMath.toObject(new double[] { 1d, 2.5d })).isEqualTo(new double?[] { 1d, 2.5d }); }
public virtual void test_mutateByMultiplication_byConstant() { double[] testArray = ARRAY_1_2.Clone(); DoubleArrayMath.mutateByMultiplication(testArray, 4d); assertThat(testArray).contains(4d, 8d); }
public virtual void test_mutateByAddition_byArray() { double[] testArray = ARRAY_1_2.Clone(); DoubleArrayMath.mutateByAddition(testArray, new double[] { 2d, 3d }); assertThat(testArray).contains(3d, 5d); }
public virtual void test_apply() { System.Func <double, double> @operator = a => 1 / a; assertThat(DoubleArrayMath.apply(ARRAY_1_2, @operator)).contains(1d, 1d / 2d); }
//------------------------------------------------------------------------- public virtual void test_mutateByAddition_byConstant() { double[] testArray = ARRAY_1_2.Clone(); DoubleArrayMath.mutateByAddition(testArray, 2d); assertThat(testArray).contains(3d, 4d); }
public virtual void test_applyMultiplication() { assertThat(DoubleArrayMath.applyMultiplication(ARRAY_1_2, 4d)).contains(4d, 8d); }
//------------------------------------------------------------------------- public virtual void test_applyAddition() { assertThat(DoubleArrayMath.applyAddition(ARRAY_1_2, 2d)).contains(3d, 4d); }
public virtual void test_combineByMultiplication() { assertThat(DoubleArrayMath.combineByMultiplication(ARRAY_1_2, ARRAY_3_4)).contains(3d, 8d); assertThrowsIllegalArg(() => DoubleArrayMath.combineByMultiplication(ARRAY_1_2, ARRAY_3)); }
public virtual void test_combine() { System.Func <double, double, double> @operator = (a, b) => a / b; assertThat(DoubleArrayMath.combine(ARRAY_1_2, ARRAY_3_4, @operator)).contains(1d / 3d, 2d / 4d); assertThrowsIllegalArg(() => DoubleArrayMath.combine(ARRAY_1_2, ARRAY_3, @operator)); }
public virtual void test_sortPairs_doubleObject_sizeDifferent() { double[] keys = new double[] { 3d, 2d, 5d, 4d }; int?[] values = new int?[] { 6, 4 }; assertThrowsIllegalArg(() => DoubleArrayMath.sortPairs(keys, values)); }
//------------------------------------------------------------------------- public virtual void test_sum() { assertThat(DoubleArrayMath.sum(ARRAY_1_2)).isEqualTo(3d); }
public virtual void test_mutateByMultiplication_byArray_sizeDifferent() { double[] testArray = ARRAY_1_2.Clone(); assertThrowsIllegalArg(() => DoubleArrayMath.mutateByMultiplication(testArray, new double[] { 4d })); }