private ComputationResult Sum(ComputationResult computationResult) { if (computationResult.IsVectorResult) { return(new ComputationResult(VectorHelper.Sum(computationResult.VectorData.GetFlatData(), 0, computationResult.VectorData.GetFlatData().Length))); } else if (computationResult.IsOdResult) { float total = 0.0f; var data = computationResult.OdData.GetFlatData(); var syncTarget = new object(); System.Threading.Tasks.Parallel.For(0, data.Length, () => 0.0f, (int i, ParallelLoopState _, float localSum) => { return(VectorHelper.Sum(data[i], 0, data[i].Length) + localSum); }, (float localTotal) => { lock (syncTarget) { total += localTotal; } }); return(new ComputationResult(total)); } return(new ComputationResult("Unknown data type to sum!")); }
public ComputationResult(ComputationResult res, VectorDirection direction) { OdData = res.OdData; LiteralValue = res.LiteralValue; VectorData = res.VectorData; Direction = direction; }
private ComputationResult TransposeOd(ComputationResult computationResult) { var ret = computationResult.Accumulator ? computationResult.OdData : computationResult.OdData.CreateSimilarArray <float>(); var flatRet = ret.GetFlatData(); var flatOrigin = computationResult.OdData.GetFlatData(); for (int i = 0; i < flatOrigin.Length; i++) { for (int j = i + 1; j < flatOrigin[i].Length; j++) { var temp = flatOrigin[i][j]; flatRet[i][j] = flatOrigin[j][i]; flatRet[j][i] = temp; } } // if this is a new matrix copy the diagonal if (!computationResult.Accumulator) { for (int i = 0; i < flatRet.Length; i++) { flatRet[i][i] = flatOrigin[i][i]; } } return(new ComputationResult(ret, true)); }
private ComputationResult Matrix(ComputationResult computationResult) { var vectorData = computationResult.VectorData; var newMatrix = vectorData.CreateSquareTwinArray <float>(); var flatVector = vectorData.GetFlatData(); var flatMatrix = newMatrix.GetFlatData(); switch (computationResult.Direction) { case ComputationResult.VectorDirection.Unassigned: return(new ComputationResult("Matrix was executed with an unassigned orientation vector!")); case ComputationResult.VectorDirection.Vertical: // each row is the single value for (int i = 0; i < flatMatrix.Length; i++) { VectorHelper.Set(flatMatrix[i], flatVector[i]); } break; case ComputationResult.VectorDirection.Horizontal: // each column is the single value for (int i = 0; i < flatMatrix.Length; i++) { Array.Copy(flatVector, flatMatrix[i], flatVector.Length); } break; } return(new ComputationResult(newMatrix, true)); }
private ComputationResult Length(ComputationResult computationResult) { if (computationResult.IsOdResult) { return(new ComputationResult(computationResult.OdData.Count)); } if (computationResult.IsVectorResult) { return(new ComputationResult(computationResult.VectorData.Count)); } return(new ComputationResult("An unknown data type was processed through Length!")); }
private ComputationResult SumRows(ComputationResult computationResult) { var data = computationResult.OdData; var ret = new SparseArray <float>(data.Indexes); var flatRet = ret.GetFlatData(); var flatData = data.GetFlatData(); System.Threading.Tasks.Parallel.For(0, flatData.Length, (int i) => { flatRet[i] = VectorHelper.Sum(flatData[i], 0, flatData[i].Length); }); return(new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical)); }
private ComputationResult AvgColumns(ComputationResult computationResult) { var data = computationResult.OdData; var ret = new SparseArray <float>(data.Indexes); var flatRet = ret.GetFlatData(); var flatData = data.GetFlatData(); System.Threading.Tasks.Parallel.For(0, flatData.Length, (int i) => { VectorHelper.Add(flatRet, 0, flatRet, 0, flatData[i], 0, flatData[i].Length); }); VectorHelper.Divide(flatRet, flatRet, flatData.Length); return(new ComputationResult(ret, true, ComputationResult.VectorDirection.Horizontal)); }
private ComputationResult Evaluate(ComputationResult mulLhs, ComputationResult mulRhs, ComputationResult add) { if (add.IsValue) { return(EvaluateAddIsValue(mulLhs, mulRhs, add)); } else if (add.IsVectorResult) { return(EvaluateAddIsVector(mulLhs, mulRhs, add)); } else { return(EvaluateAddIsMatrix(mulLhs, mulRhs, add)); } }
private ComputationResult LengthRows(ComputationResult computationResult) { if (computationResult.IsOdResult) { var data = computationResult.OdData; var ret = new SparseArray <float>(data.Indexes); var flatRet = ret.GetFlatData(); var flatData = data.GetFlatData(); for (int i = 0; i < flatData.Length; i++) { flatRet[i] = flatData[i].Length; } return(new ComputationResult(ret, true, ComputationResult.VectorDirection.Vertical)); } return(new ComputationResult("An unknown data type was processed through LengthRows!")); }
private ComputationResult Avg(ComputationResult computationResult) { if (computationResult.IsVectorResult) { var flat = computationResult.VectorData.GetFlatData(); return(new ComputationResult(VectorHelper.Sum(flat, 0, flat.Length) / flat.Length)); } else { var flat = computationResult.OdData.GetFlatData(); var total = 0.0f; var count = 0; for (int i = 0; i < flat.Length; i++) { total += VectorHelper.Sum(flat[i], 0, flat[i].Length); count += flat[i].Length; } return(new ComputationResult(total / count)); } }
private ComputationResult Abs(ComputationResult computationResult) { if (computationResult.IsValue) { return(new ComputationResult(Math.Abs(computationResult.LiteralValue))); } else if (computationResult.IsVectorResult) { var retVector = computationResult.Accumulator ? computationResult.VectorData : computationResult.VectorData.CreateSimilarArray <float>(); var flat = retVector.GetFlatData(); VectorHelper.Abs(flat, computationResult.VectorData.GetFlatData()); return(new ComputationResult(retVector, true)); } else { var retMatrix = computationResult.Accumulator ? computationResult.OdData : computationResult.OdData.CreateSimilarArray <float>(); var flat = retMatrix.GetFlatData(); VectorHelper.Abs(flat, computationResult.OdData.GetFlatData()); return(new ComputationResult(retMatrix, true)); } }
private ComputationResult IdentityMatrix(ComputationResult computationResult) { SparseTwinIndex <float> ret; if (computationResult.IsVectorResult) { var vector = computationResult.VectorData; ret = vector.CreateSquareTwinArray <float>(); } else { var matrix = computationResult.OdData; ret = matrix.CreateSimilarArray <float>(); } var flatRet = ret.GetFlatData(); for (int i = 0; i < flatRet.Length; i++) { flatRet[i][i] = 1.0f; } return(new ComputationResult(ret, true)); }
private ComputationResult LengthColumns(ComputationResult computationResult) { if (computationResult.IsOdResult) { var data = computationResult.OdData; var ret = new SparseArray <float>(data.Indexes); var flatRet = ret.GetFlatData(); var flatData = data.GetFlatData(); System.Threading.Tasks.Parallel.For(0, flatData.Length, (int i) => { int temp = 0; for (int j = 0; j < flatData.Length; j++) { if (flatData[j].Length > i) { temp++; } } flatRet[i] = temp; }); return(new ComputationResult(ret, true, ComputationResult.VectorDirection.Horizontal)); } return(new ComputationResult("An unknown data type was processed through LengthColumns!")); }
private ComputationResult EvaluateAddIsVector(ComputationResult lhs, ComputationResult rhs, ComputationResult add) { // Test the simple case of this really just being an add with a constant multiply if (lhs.IsValue && rhs.IsValue) { var retVector = add.Accumulator ? add.VectorData : add.VectorData.CreateSimilarArray <float>(); VectorHelper.Add(retVector.GetFlatData(), add.VectorData.GetFlatData(), lhs.LiteralValue * rhs.LiteralValue); return(new ComputationResult(retVector, true, add.Direction)); } if (lhs.IsOdResult || rhs.IsOdResult) { if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned) { return(new ComputationResult("Unable to multiply vector without directionality starting at position " + MulLhs.Start + "!")); } if (rhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned) { return(new ComputationResult("Unable to multiply vector without directionality starting at position " + MulRhs.Start + "!")); } if (add.Direction == ComputationResult.VectorDirection.Unassigned) { return(new ComputationResult("Unable to add vector without directionality starting at position " + Add.Start + "!")); } // if the lhs is a value just swap the two around if (!lhs.IsOdResult) { Swap(ref lhs, ref rhs); } //LHS is a matrix if (rhs.IsOdResult) { var retMatrix = rhs.Accumulator ? rhs.OdData : (lhs.Accumulator ? lhs.OdData : lhs.OdData.CreateSimilarArray <float>()); if (add.Direction == ComputationResult.VectorDirection.Vertical) { VectorHelper.FusedMultiplyAddVerticalAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.OdData.GetFlatData(), add.VectorData.GetFlatData()); } else { VectorHelper.FusedMultiplyAddHorizontalAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.OdData.GetFlatData(), add.VectorData.GetFlatData()); } return(new ComputationResult(retMatrix, true)); } else if (rhs.IsVectorResult) { var retMatrix = lhs.Accumulator ? lhs.OdData : lhs.OdData.CreateSimilarArray <float>(); if (rhs.Direction == ComputationResult.VectorDirection.Vertical) { if (add.Direction == ComputationResult.VectorDirection.Vertical) { VectorHelper.FusedMultiplyAddVerticalRhsVerticalAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.VectorData.GetFlatData(), add.VectorData.GetFlatData()); } else { VectorHelper.FusedMultiplyAddVerticalRhsHorizontalAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.VectorData.GetFlatData(), add.VectorData.GetFlatData()); } } else { if (add.Direction == ComputationResult.VectorDirection.Vertical) { VectorHelper.FusedMultiplyAddHorizontalRhsVerticalAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.VectorData.GetFlatData(), add.VectorData.GetFlatData()); } else { VectorHelper.FusedMultiplyAddHorizontalRhsHorizontalAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.VectorData.GetFlatData(), add.VectorData.GetFlatData()); } } return(new ComputationResult(retMatrix, true)); } else { //RHS is a scalar var retMatrix = lhs.Accumulator ? lhs.OdData : lhs.OdData.CreateSimilarArray <float>(); if (add.Direction == ComputationResult.VectorDirection.Vertical) { VectorHelper.FusedMultiplyAddVerticalAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.LiteralValue, add.VectorData.GetFlatData()); } else { VectorHelper.FusedMultiplyAddHorizontalAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.LiteralValue, add.VectorData.GetFlatData()); } return(new ComputationResult(retMatrix, true)); } } // vector cases else { // if the lhs is a value just swap the two around if (lhs.IsValue) { Swap(ref lhs, ref rhs); } // vector * vector + vector if (rhs.IsVectorResult) { var retVector = add.Accumulator ? add.VectorData : (rhs.Accumulator ? rhs.VectorData : (lhs.Accumulator ? lhs.VectorData : lhs.VectorData.CreateSimilarArray <float>())); VectorHelper.FusedMultiplyAdd(retVector.GetFlatData(), lhs.VectorData.GetFlatData(), rhs.VectorData.GetFlatData(), add.VectorData.GetFlatData()); return(new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned)); } // vector * lit + vector else { var retVector = add.Accumulator ? add.VectorData : (lhs.Accumulator ? lhs.VectorData : lhs.VectorData.CreateSimilarArray <float>()); VectorHelper.FusedMultiplyAdd(retVector.GetFlatData(), lhs.VectorData.GetFlatData(), rhs.LiteralValue, add.VectorData.GetFlatData()); return(new ComputationResult(retVector, true, add.Direction == lhs.Direction && add.Direction == rhs.Direction ? add.Direction : ComputationResult.VectorDirection.Unassigned)); } } }
private ComputationResult EvaluateAddIsMatrix(ComputationResult lhs, ComputationResult rhs, ComputationResult add) { if (lhs.IsVectorResult && lhs.Direction == ComputationResult.VectorDirection.Unassigned) { return(new ComputationResult("Unable to multiply vector without directionality starting at position " + MulLhs.Start + "!")); } if (rhs.IsVectorResult && rhs.Direction == ComputationResult.VectorDirection.Unassigned) { return(new ComputationResult("Unable to multiply vector without directionality starting at position " + MulRhs.Start + "!")); } // Ensure that the LHS is a higher or equal order to the RHS (Matrix > Vector > Scalar) if (!lhs.IsOdResult) { Swap(ref lhs, ref rhs); } if (lhs.IsValue) { Swap(ref lhs, ref rhs); } // LHS is now a higher or equal to the order of RHS if (lhs.IsOdResult) { if (rhs.IsOdResult) { var retMatrix = add.Accumulator ? add.OdData : (lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : add.OdData.CreateSimilarArray <float>())); VectorHelper.FusedMultiplyAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.OdData.GetFlatData(), add.OdData.GetFlatData()); return(new ComputationResult(retMatrix, true)); } else if (rhs.IsVectorResult) { var retMatrix = add.Accumulator ? add.OdData : (lhs.Accumulator ? lhs.OdData : add.OdData.CreateSimilarArray <float>()); if (rhs.Direction == ComputationResult.VectorDirection.Vertical) { VectorHelper.FusedMultiplyAddVerticalRhs(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.VectorData.GetFlatData(), add.OdData.GetFlatData()); } else { VectorHelper.FusedMultiplyAddHorizontalRhs(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.VectorData.GetFlatData(), add.OdData.GetFlatData()); } return(new ComputationResult(retMatrix, true)); } else { //RHS is scalar var retMatrix = add.Accumulator ? add.OdData : (lhs.Accumulator ? lhs.OdData : add.OdData.CreateSimilarArray <float>()); VectorHelper.FusedMultiplyAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.LiteralValue, add.OdData.GetFlatData()); return(new ComputationResult(retMatrix, true)); } } else if (lhs.IsVectorResult) { var retMatrix = add.Accumulator ? add.OdData : add.OdData.CreateSimilarArray <float>(); var tempVector = lhs.Accumulator ? lhs.VectorData : (rhs.IsVectorResult && rhs.Accumulator ? rhs.VectorData : lhs.VectorData.CreateSimilarArray <float>()); // compute the multiplication separately in this case for better performance (n multiplies instead of n^2) if (rhs.IsVectorResult) { if (lhs.Direction != rhs.Direction) { // if the directions don't add up then the sum operation would be undefined! return(new ComputationResult("Unable to add vector without directionality starting at position " + MulLhs.Start + "!")); } VectorHelper.Multiply(tempVector.GetFlatData(), 0, lhs.VectorData.GetFlatData(), 0, rhs.VectorData.GetFlatData(), 0, tempVector.GetFlatData().Length); } else { VectorHelper.Multiply(tempVector.GetFlatData(), lhs.VectorData.GetFlatData(), rhs.LiteralValue); } if (lhs.Direction == ComputationResult.VectorDirection.Vertical) { VectorHelper.AddVertical(retMatrix.GetFlatData(), add.OdData.GetFlatData(), tempVector.GetFlatData()); } else { VectorHelper.AddHorizontal(retMatrix.GetFlatData(), add.OdData.GetFlatData(), tempVector.GetFlatData()); } return(new ComputationResult(retMatrix, true)); } else { // in this case LHS is a scalar, and therefore RHS is also a scalar var retMatrix = add.Accumulator ? add.OdData : add.OdData.CreateSimilarArray <float>(); VectorHelper.Add(retMatrix.GetFlatData(), add.OdData.GetFlatData(), lhs.LiteralValue * rhs.LiteralValue); return(new ComputationResult(retMatrix, true)); } }
private ComputationResult EvaluateAddIsValue(ComputationResult lhs, ComputationResult rhs, ComputationResult add) { if (add.IsValue && lhs.IsValue && rhs.IsValue) { return(new ComputationResult(lhs.LiteralValue * rhs.LiteralValue + add.LiteralValue)); } // float / matrix if (lhs.IsValue) { if (rhs.IsVectorResult) { var retVector = rhs.Accumulator ? rhs.VectorData : rhs.VectorData.CreateSimilarArray <float>(); var flat = retVector.GetFlatData(); VectorHelper.FusedMultiplyAdd(flat, rhs.VectorData.GetFlatData(), lhs.LiteralValue, add.LiteralValue); return(new ComputationResult(retVector, true, rhs.Direction)); } else { var retMatrix = rhs.Accumulator ? rhs.OdData : rhs.OdData.CreateSimilarArray <float>(); // inverted lhs, rhs since order does not matter VectorHelper.FusedMultiplyAdd(retMatrix.GetFlatData(), rhs.OdData.GetFlatData(), lhs.LiteralValue, add.LiteralValue); return(new ComputationResult(retMatrix, true)); } } else if (rhs.IsValue) { if (lhs.IsVectorResult) { var retVector = lhs.Accumulator ? lhs.VectorData : lhs.VectorData.CreateSimilarArray <float>(); var flat = retVector.GetFlatData(); VectorHelper.FusedMultiplyAdd(flat, lhs.VectorData.GetFlatData(), rhs.LiteralValue, add.LiteralValue); return(new ComputationResult(retVector, true, lhs.Direction)); } else { // matrix / float var retMatrix = lhs.Accumulator ? lhs.OdData : lhs.OdData.CreateSimilarArray <float>(); VectorHelper.FusedMultiplyAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.LiteralValue, add.LiteralValue); return(new ComputationResult(retMatrix, true)); } } else { if (lhs.IsVectorResult || rhs.IsVectorResult) { if (lhs.IsVectorResult && rhs.IsVectorResult) { var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : lhs.VectorData.CreateSimilarArray <float>()); VectorHelper.FusedMultiplyAdd(retMatrix.GetFlatData(), lhs.VectorData.GetFlatData(), rhs.VectorData.GetFlatData(), add.LiteralValue); return(new ComputationResult(retMatrix, true, lhs.Direction)); } else if (lhs.IsVectorResult) { var retMatrix = rhs.Accumulator ? rhs.OdData : rhs.OdData.CreateSimilarArray <float>(); var flatRet = retMatrix.GetFlatData(); var flatRhs = rhs.OdData.GetFlatData(); var flatLhs = lhs.VectorData.GetFlatData(); if (lhs.Direction == ComputationResult.VectorDirection.Vertical) { System.Threading.Tasks.Parallel.For(0, flatRet.Length, i => { VectorHelper.FusedMultiplyAdd(flatRet[i], flatRhs[i], flatLhs[i], add.LiteralValue); }); } else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal) { System.Threading.Tasks.Parallel.For(0, flatRet.Length, i => { VectorHelper.FusedMultiplyAdd(flatRet[i], flatLhs, flatRhs[i], add.LiteralValue); }); } else { return(new ComputationResult("Unable to add vector without directionality starting at position " + MulLhs.Start + "!")); } return(new ComputationResult(retMatrix, true)); } else { var retMatrix = lhs.Accumulator ? lhs.OdData : lhs.OdData.CreateSimilarArray <float>(); var flatRet = retMatrix.GetFlatData(); var flatLhs = lhs.OdData.GetFlatData(); var flatRhs = rhs.VectorData.GetFlatData(); if (rhs.Direction == ComputationResult.VectorDirection.Vertical) { System.Threading.Tasks.Parallel.For(0, flatRet.Length, i => { VectorHelper.FusedMultiplyAdd(flatRet[i], flatLhs[i], flatRhs[i], add.LiteralValue); }); } else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal) { System.Threading.Tasks.Parallel.For(0, flatRet.Length, i => { VectorHelper.FusedMultiplyAdd(flatRet[i], flatRhs, flatLhs[i], add.LiteralValue); }); } else { return(new ComputationResult("Unable to add vector without directionality starting at position " + MulLhs.Start + "!")); } return(new ComputationResult(retMatrix, true)); } } else { var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : lhs.OdData.CreateSimilarArray <float>()); VectorHelper.FusedMultiplyAdd(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.OdData.GetFlatData(), add.LiteralValue); return(new ComputationResult(retMatrix, true)); } } }
public override ComputationResult Evaluate(IDataSource[] dataSources) { // first evaluate the parameters var values = new ComputationResult[Parameters.Length]; for (int i = 0; i < values.Length; i++) { values[i] = Parameters[i].Evaluate(dataSources); if (values[i].Error) { return(values[i]); } } switch (Type) { case FunctionType.AsHorizontal: if (values.Length != 1) { return(new ComputationResult("AsHorizontal at position " + Start + " was executed with the wrong number of parameters!")); } if (!values[0].IsVectorResult) { return(new ComputationResult("AsHorizontal at position " + Start + " was executed with a parameter that was not a vector!")); } return(new ComputationResult(values[0], ComputationResult.VectorDirection.Horizontal)); case FunctionType.AsVertical: if (values.Length != 1) { return(new ComputationResult("AsVertical at position " + Start + " was executed with the wrong number of parameters!")); } if (!values[0].IsVectorResult) { return(new ComputationResult("AsVertical at position " + Start + " was executed with a parameter that was not a vector!")); } return(new ComputationResult(values[0], ComputationResult.VectorDirection.Vertical)); case FunctionType.Transpose: { if (values.Length != 1) { return(new ComputationResult("Transpose at position " + Start + " was executed with the wrong number of parameters!")); } if (values[0].IsVectorResult) { switch (values[0].Direction) { case ComputationResult.VectorDirection.Horizontal: return(new ComputationResult(values[0], ComputationResult.VectorDirection.Vertical)); case ComputationResult.VectorDirection.Vertical: return(new ComputationResult(values[0], ComputationResult.VectorDirection.Horizontal)); case ComputationResult.VectorDirection.Unassigned: return(new ComputationResult("Unable to transpose an vector that does not have a directionality!")); } } if (values[0].IsValue) { return(new ComputationResult("The parameter to Transpose at position " + Start + " was executed against a scalar!")); } if (values[0].IsOdResult) { return(TransposeOd(values[0])); } return(new ComputationResult("Unsupported data type for Transpose at position " + Start + ".")); } case FunctionType.SumRows: if (values.Length != 1) { return(new ComputationResult("SumRows was executed with the wrong number of parameters!")); } if (!values[0].IsOdResult) { return(new ComputationResult("SumRows was executed with a parameter that was not a matrix!")); } return(SumRows(values[0])); case FunctionType.SumColumns: if (values.Length != 1) { return(new ComputationResult("SumColumns was executed with the wrong number of parameters!")); } if (!values[0].IsOdResult) { return(new ComputationResult("SumColumns was executed with a parameter that was not a matrix!")); } return(SumColumns(values[0])); case FunctionType.AvgRows: if (values.Length != 1) { return(new ComputationResult("AvgRows was executed with the wrong number of parameters!")); } if (!values[0].IsOdResult) { return(new ComputationResult("AvgRows was executed with a parameter that was not a matrix!")); } return(AvgRows(values[0])); case FunctionType.AvgColumns: if (values.Length != 1) { return(new ComputationResult("AvgColumns was executed with the wrong number of parameters!")); } if (!values[0].IsOdResult) { return(new ComputationResult("AvgColumns was executed with a parameter that was not a matrix!")); } return(AvgColumns(values[0])); case FunctionType.Sum: if (values.Length != 1) { return(new ComputationResult("Sum was executed with the wrong number of parameters!")); } if (values[0].IsValue) { return(new ComputationResult("Sum was executed with a parameter that was already a scalar value!")); } return(Sum(values[0])); case FunctionType.Abs: if (values.Length != 1) { return(new ComputationResult("Abs was executed with the wrong number of parameters!")); } return(Abs(values[0])); case FunctionType.Avg: if (values.Length != 1) { return(new ComputationResult("Avg was executed with the wrong number of parameters!")); } if (values[0].IsValue) { return(new ComputationResult("Avg was executed with a parameter that was already a scalar value!")); } return(Avg(values[0])); case FunctionType.E: return(new ComputationResult((float)Math.E)); case FunctionType.Pi: return(new ComputationResult((float)Math.PI)); case FunctionType.Length: if (values.Length != 1) { return(new ComputationResult("Length was executed with the wrong number of parameters!")); } if (values[0].IsValue) { return(new ComputationResult("Length can not be applied to a scalar!")); } return(Length(values[0])); case FunctionType.LengthColumns: if (values.Length != 1) { return(new ComputationResult("LengthColumns was executed with the wrong number of parameters!")); } if (values[0].IsOdResult) { return(new ComputationResult("LengthColumns must be applied to a Matrix!")); } return(LengthColumns(values[0])); case FunctionType.LengthRows: if (values.Length != 1) { return(new ComputationResult("LengthRows was executed with the wrong number of parameters!")); } if (values[0].IsOdResult) { return(new ComputationResult("LengthRows must be applied to a Matrix!")); } return(LengthRows(values[0])); case FunctionType.ZeroMatrix: if (values.Length != 1) { return(new ComputationResult("ZeroMatrix was executed with the wrong number of parameters!")); } if (values[0].IsValue) { return(new ComputationResult("ZeroMatrix must be applied to a vector, or a matrix!")); } return(ZeroMatrix(values)); case FunctionType.Matrix: if (values.Length != 1) { return(new ComputationResult("Matrix was executed with the wrong number of parameters!")); } if (!values[0].IsVectorResult) { return(new ComputationResult("Matrix must be applied to a vector!")); } return(Matrix(values[0])); case FunctionType.IdentityMatrix: if (values.Length != 1) { return(new ComputationResult("IdentityMatrix was executed with the wrong number of parameters!")); } if (values[0].IsValue) { return(new ComputationResult("IdentityMatrix must be applied to a vector, or a matrix!")); } return(IdentityMatrix(values[0])); case FunctionType.Log: if (values.Length != 1) { return(new ComputationResult("Log must be executed with one parameter!")); } return(Log(values)); case FunctionType.If: if (values.Length != 3) { return(new ComputationResult("If requires 3 parameters (condition, valueIfTrue, valueIfFalse)!")); } return(ComputeIf(values)); case FunctionType.IfNaN: if (values.Length != 2) { return(new ComputationResult("IfNaN requires 2 parameters (original,replacement)!")); } return(ComputeIfNaN(values)); } return(new ComputationResult("An undefined function was executed!")); }
public override ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs) { // see if we have two values, in this case we can skip doing the matrix operation if (lhs.IsValue && rhs.IsValue) { return(new ComputationResult(lhs.LiteralValue - rhs.LiteralValue)); } // float / matrix if (lhs.IsValue) { if (rhs.IsVectorResult) { var retVector = rhs.Accumulator ? rhs.VectorData : rhs.VectorData.CreateSimilarArray <float>(); var flat = retVector.GetFlatData(); VectorHelper.Subtract(flat, lhs.VectorData.GetFlatData(), rhs.LiteralValue); return(new ComputationResult(retVector, true, rhs.Direction)); } else { var retMatrix = rhs.Accumulator ? rhs.OdData : rhs.OdData.CreateSimilarArray <float>(); VectorHelper.Subtract(retMatrix.GetFlatData(), lhs.LiteralValue, rhs.OdData.GetFlatData()); return(new ComputationResult(retMatrix, true)); } } else if (rhs.IsValue) { if (lhs.IsVectorResult) { var retVector = lhs.Accumulator ? lhs.VectorData : lhs.VectorData.CreateSimilarArray <float>(); var flat = retVector.GetFlatData(); VectorHelper.Subtract(flat, lhs.VectorData.GetFlatData(), rhs.LiteralValue); return(new ComputationResult(retVector, true, lhs.Direction)); } else { // matrix / float var retMatrix = lhs.Accumulator ? lhs.OdData : lhs.OdData.CreateSimilarArray <float>(); VectorHelper.Subtract(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.LiteralValue); return(new ComputationResult(retMatrix, true)); } } else { if (lhs.IsVectorResult || rhs.IsVectorResult) { if (lhs.IsVectorResult && rhs.IsVectorResult) { var retMatrix = lhs.Accumulator ? lhs.VectorData : (rhs.Accumulator ? rhs.VectorData : lhs.VectorData.CreateSimilarArray <float>()); VectorHelper.Subtract(retMatrix.GetFlatData(), 0, lhs.VectorData.GetFlatData(), 0, rhs.VectorData.GetFlatData(), 0, retMatrix.GetFlatData().Length); return(new ComputationResult(retMatrix, true, lhs.Direction)); } else if (lhs.IsVectorResult) { var retMatrix = rhs.Accumulator ? rhs.OdData : rhs.OdData.CreateSimilarArray <float>(); var flatRet = retMatrix.GetFlatData(); var flatRhs = rhs.OdData.GetFlatData(); var flatLhs = lhs.VectorData.GetFlatData(); if (lhs.Direction == ComputationResult.VectorDirection.Vertical) { System.Threading.Tasks.Parallel.For(0, flatRet.Length, i => { VectorHelper.Subtract(flatRet[i], flatLhs[i], flatRhs[i]); }); } else if (lhs.Direction == ComputationResult.VectorDirection.Horizontal) { System.Threading.Tasks.Parallel.For(0, flatRet.Length, i => { VectorHelper.Subtract(flatRet[i], 0, flatLhs, 0, flatRhs[i], 0, flatRet[i].Length); }); } else { return(new ComputationResult("Unable to subtract vector without directionality starting at position " + Lhs.Start + "!")); } return(new ComputationResult(retMatrix, true)); } else { var retMatrix = lhs.Accumulator ? lhs.OdData : lhs.OdData.CreateSimilarArray <float>(); var flatRet = retMatrix.GetFlatData(); var flatLhs = lhs.OdData.GetFlatData(); var flatRhs = rhs.VectorData.GetFlatData(); if (rhs.Direction == ComputationResult.VectorDirection.Vertical) { System.Threading.Tasks.Parallel.For(0, flatRet.Length, i => { VectorHelper.Subtract(flatRet[i], flatLhs[i], flatRhs[i]); }); } else if (rhs.Direction == ComputationResult.VectorDirection.Horizontal) { System.Threading.Tasks.Parallel.For(0, flatRet.Length, i => { VectorHelper.Subtract(flatRet[i], 0, flatLhs[i], 0, flatRhs, 0, flatRet[i].Length); }); } else { return(new ComputationResult("Unable to subtract vector without directionality starting at position " + Lhs.Start + "!")); } return(new ComputationResult(retMatrix, true)); } } else { var retMatrix = lhs.Accumulator ? lhs.OdData : (rhs.Accumulator ? rhs.OdData : lhs.OdData.CreateSimilarArray <float>()); VectorHelper.Subtract(retMatrix.GetFlatData(), lhs.OdData.GetFlatData(), rhs.OdData.GetFlatData()); return(new ComputationResult(retMatrix, true)); } } }
public abstract ComputationResult Evaluate(ComputationResult lhs, ComputationResult rhs);