private byte[] PrepareExpandVector(AType left) { // if the left side is User defined function, we throw Valence error. // this part belongs to Scan. if (left.Type == ATypes.AFunc) { throw new Error.Valence(ValenceErrorText); } if (!(left.Type == ATypes.AFloat || left.Type == ATypes.AInteger || left.Type == ATypes.ANull)) { throw new Error.Type(TypeErrorText); } if (left.Rank > 1) { throw new Error.Rank(RankErrorText); } //int element; AType scalar; byte[] expandVector; if (left.TryFirstScalar(out scalar, true)) { expandVector = new byte[] { ExtractExpandArgument(scalar) }; } else { expandVector = left.Select(item => ExtractExpandArgument(item)).ToArray(); } return(expandVector); }
private byte[] PrepareExpandVector(AType left) { // if the left side is User defined function, we throw Valence error. // this part belongs to Scan. if (left.Type == ATypes.AFunc) { throw new Error.Valence(ValenceErrorText); } if (!(left.Type == ATypes.AFloat || left.Type == ATypes.AInteger || left.Type == ATypes.ANull)) { throw new Error.Type(TypeErrorText); } if (left.Rank > 1) { throw new Error.Rank(RankErrorText); } //int element; AType scalar; byte[] expandVector; if (left.TryFirstScalar(out scalar, true)) { expandVector = new byte[] { ExtractExpandArgument(scalar) }; } else { expandVector = left.Select(item => ExtractExpandArgument(item)).ToArray(); } return expandVector; }
/// <summary> /// Extracts <see cref="DecodeInformation"/> from the arguments. /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <returns></returns> private DecodeInformation ExtractDecodeInformation(AType left, AType right) { // Error if the arguments are not numbers or Null if (!((left.IsNumber || left.Type == ATypes.ANull) && (right.IsNumber || right.Type == ATypes.ANull))) { throw new Error.Type(TypeErrorText); } // righ side must be array if (!right.IsArray) { throw new Error.Rank(RankErrorText); } // left side must be scalar or vector if (left.Rank > 1) { throw new Error.Rank(RankErrorText); } ATypes resultType = (left.Type == ATypes.AFloat || right.Type == ATypes.AFloat || right.Type == ATypes.ANull) ? ATypes.AFloat : ATypes.AInteger; double[] decodeValues; if (left.IsArray) { if (left.Length == 1) { // one-element vector case, then we reshape it: (#x) rho y. decodeValues = Enumerable.Repeat(left[0].asFloat, right.Length).ToArray(); } else { // left and right side length have to equal! if (left.Length != right.Length) { throw new Error.Length(LengthErrorText); } decodeValues = left.Select(item => item.asFloat).ToArray(); } } else { // scalar case, reshape it: (#x) rho y. decodeValues = Enumerable.Repeat(left.asFloat, right.Length).ToArray(); } return(new DecodeInformation(resultType, decodeValues)); }
private ReplicateJobInfo CreateReplicateJobInfo(AType right, AType left) { if (!(left.Type == ATypes.AFloat || left.Type == ATypes.AInteger || left.Type == ATypes.ANull)) { throw new Error.Type(TypeErrorText); } if (left.Rank > 1) { throw new Error.Rank(RankErrorText); } int[] replicateVector; AType scalar; if (left.TryFirstScalar(out scalar, true)) { replicateVector = new int[] { ExtractInteger(scalar) }; } else { if (left.Length > 0) { replicateVector = left.Select(item => ExtractInteger(item)).ToArray(); } else { replicateVector = new int[] { 0 }; } // lenght check should be the first than parse the left side, // but the A+ follow that order. if (right.Length != 1 && left.Length != right.Length) { throw new Error.Length(LengthErrorText); } } ReplicateJobInfo info = new ReplicateJobInfo( replicateVector, right.IsArray ? right : AArray.Create(right.Type, right) ); return info; }
private ReplicateJobInfo CreateReplicateJobInfo(AType right, AType left) { if (!(left.Type == ATypes.AFloat || left.Type == ATypes.AInteger || left.Type == ATypes.ANull)) { throw new Error.Type(TypeErrorText); } if (left.Rank > 1) { throw new Error.Rank(RankErrorText); } int[] replicateVector; AType scalar; if (left.TryFirstScalar(out scalar, true)) { replicateVector = new int[] { ExtractInteger(scalar) }; } else { if (left.Length > 0) { replicateVector = left.Select(item => ExtractInteger(item)).ToArray(); } else { replicateVector = new int[] { 0 }; } // lenght check should be the first than parse the left side, // but the A+ follow that order. if (right.Length != 1 && left.Length != right.Length) { throw new Error.Length(LengthErrorText); } } ReplicateJobInfo info = new ReplicateJobInfo( replicateVector, right.IsArray ? right : AArray.Create(right.Type, right) ); return(info); }
/// <summary> /// Type check, and extract data from left and right side. /// </summary> /// <param name="left"></param> /// <param name="right"></param> private EncodeInformation ExtractEncodeInformation(AType left, AType right) { // Error if the arguments are not numbers or Null if (!((left.IsNumber || left.Type == ATypes.ANull) && (right.IsNumber || right.Type == ATypes.ANull))) { throw new Error.Type(TypeErrorText); } // Left argument must be a scalar or vector. if (left.Rank > 1) { throw new Error.Rank(RankErrorText); } double[] encodeKeys; if (left.IsArray) { encodeKeys = left.Select(item => item.asFloat).ToArray(); } else { encodeKeys = new double[] { left.asFloat }; } ATypes resultingType; if (left.Type == ATypes.AFloat || right.Type == ATypes.AFloat || left.Type == ATypes.ANull || right.Type == ATypes.ANull) { resultingType = ATypes.AFloat; } else { resultingType = ATypes.AInteger; } List <double> encodeValues = new List <double>(); ExtractItems(encodeValues, right); EncodeInformation arguments = new EncodeInformation(encodeKeys, encodeValues.ToArray(), resultingType); return(arguments); }
/// <summary> /// Type check, and extract data from left and right side. /// </summary> /// <param name="left"></param> /// <param name="right"></param> private EncodeInformation ExtractEncodeInformation(AType left, AType right) { // Error if the arguments are not numbers or Null if (!((left.IsNumber || left.Type == ATypes.ANull) && (right.IsNumber || right.Type == ATypes.ANull))) { throw new Error.Type(TypeErrorText); } // Left argument must be a scalar or vector. if (left.Rank > 1) { throw new Error.Rank(RankErrorText); } double[] encodeKeys; if (left.IsArray) { encodeKeys = left.Select(item => item.asFloat).ToArray(); } else { encodeKeys = new double[] { left.asFloat }; } ATypes resultingType; if (left.Type == ATypes.AFloat || right.Type == ATypes.AFloat || left.Type == ATypes.ANull || right.Type == ATypes.ANull) { resultingType = ATypes.AFloat; } else { resultingType = ATypes.AInteger; } List<double> encodeValues = new List<double>(); ExtractItems(encodeValues, right); EncodeInformation arguments = new EncodeInformation(encodeKeys, encodeValues.ToArray(), resultingType); return arguments; }
public override AType Execute(AType rightArgument, AType leftArgument, Aplus environment = null) { if (leftArgument.Type != ATypes.AInteger) { throw new Error.Type(this.TypeErrorText); } AType left = Function.Monadic.MonadicFunctionInstance.Ravel.Execute(leftArgument); AType right = Function.Monadic.MonadicFunctionInstance.Ravel.Execute(rightArgument); AType result; switch (CheckVector(left)) { case State.NullFound: // Found a zero in the list, create an emtpy list with correct shape result = CreateResult(left, right); result.Shape = new List <int>(left.Select(item => { return(item.asInteger); })); result.Rank = result.Shape.Count; result.Length = result.Shape[0]; break; case State.DomainError: throw new Error.Domain(this.DomainErrorText); case State.MaxRankError: throw new Error.MaxRank(this.MaxRankErrorText); default: case State.OK: result = CreateResult(left, right); break; } return(result); }
/// <summary> /// Extracts <see cref="DecodeInformation"/> from the arguments. /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <returns></returns> private DecodeInformation ExtractDecodeInformation(AType left, AType right) { // Error if the arguments are not numbers or Null if (!((left.IsNumber || left.Type == ATypes.ANull) && (right.IsNumber || right.Type == ATypes.ANull))) { throw new Error.Type(TypeErrorText); } // righ side must be array if (!right.IsArray) { throw new Error.Rank(RankErrorText); } // left side must be scalar or vector if (left.Rank > 1) { throw new Error.Rank(RankErrorText); } ATypes resultType = (left.Type == ATypes.AFloat || right.Type == ATypes.AFloat || right.Type == ATypes.ANull) ? ATypes.AFloat : ATypes.AInteger; double[] decodeValues; if (left.IsArray) { if (left.Length == 1) { // one-element vector case, then we reshape it: (#x) rho y. decodeValues = Enumerable.Repeat(left[0].asFloat, right.Length).ToArray(); } else { // left and right side length have to equal! if (left.Length != right.Length) { throw new Error.Length(LengthErrorText); } decodeValues = left.Select(item => item.asFloat).ToArray(); } } else { // scalar case, reshape it: (#x) rho y. decodeValues = Enumerable.Repeat(left.asFloat, right.Length).ToArray(); } return new DecodeInformation(resultType, decodeValues); }
private AType SolveEquation(AType constants, AType equations) { AType lhs; AType rhs; if (constants.TryFirstScalar(out lhs, true) && equations.TryFirstScalar(out rhs, true)) { // both left and right values are one element arrays. return AFloat.Create(lhs.asFloat / rhs.asFloat); } Matrix constantsArray = new SimpleMatrix(ExtractConstants(constants)); Matrix originalEquations = new SimpleMatrix(FloatFromAType(equations)); int[] rowsSequence; Matrix eliminatedConstants; GaussianElimination(originalEquations, constantsArray, out rowsSequence, out eliminatedConstants); AType result = AArray.Create(ATypes.AFloat); if (equations.Shape[0] == equations.Shape[1]) { // square equation if (constants.Rank > 1) { foreach (int item in rowsSequence) { AType subArray = AArray.Create(ATypes.AFloat); for (int i = 0; i < eliminatedConstants.Columns; i++) { subArray.Add(AFloat.Create(eliminatedConstants[item, i])); } result.Add(subArray); } } else { foreach (int item in rowsSequence) { result.Add(AFloat.Create(eliminatedConstants[item, 0])); } } } else { double[][] independentConstants = BuildIndependentConstants(rowsSequence, eliminatedConstants); double[] beta; double[] actualconstants; if (constants.Rank == 1) { beta = independentConstants.Select(item => item[0]).ToArray(); actualconstants = constants.Select(item => item.asFloat).ToArray(); double[] solution = OverDeterminedEquationSolve(beta, actualconstants, originalEquations); foreach (double item in solution) { result.Add(AFloat.Create(item)); } } else { for (int objective = 0; objective < constants.Shape[1]; objective++) { beta = independentConstants.Select(item => item[objective]).ToArray(); actualconstants = constants.Select(item => item[objective].asFloat).ToArray(); double[] solution = OverDeterminedEquationSolve(beta, actualconstants, originalEquations); AType solutionArray = AArray.Create(ATypes.AFloat); foreach (double item in solution) { solutionArray.Add(AFloat.Create(item)); } result.Add(solutionArray); } } } return result; }
private AType SolveEquation(AType constants, AType equations) { AType lhs; AType rhs; if (constants.TryFirstScalar(out lhs, true) && equations.TryFirstScalar(out rhs, true)) { // both left and right values are one element arrays. return(AFloat.Create(lhs.asFloat / rhs.asFloat)); } Matrix constantsArray = new SimpleMatrix(ExtractConstants(constants)); Matrix originalEquations = new SimpleMatrix(FloatFromAType(equations)); int[] rowsSequence; Matrix eliminatedConstants; GaussianElimination(originalEquations, constantsArray, out rowsSequence, out eliminatedConstants); AType result = AArray.Create(ATypes.AFloat); if (equations.Shape[0] == equations.Shape[1]) { // square equation if (constants.Rank > 1) { foreach (int item in rowsSequence) { AType subArray = AArray.Create(ATypes.AFloat); for (int i = 0; i < eliminatedConstants.Columns; i++) { subArray.Add(AFloat.Create(eliminatedConstants[item, i])); } result.Add(subArray); } } else { foreach (int item in rowsSequence) { result.Add(AFloat.Create(eliminatedConstants[item, 0])); } } } else { double[][] independentConstants = BuildIndependentConstants(rowsSequence, eliminatedConstants); double[] beta; double[] actualconstants; if (constants.Rank == 1) { beta = independentConstants.Select(item => item[0]).ToArray(); actualconstants = constants.Select(item => item.asFloat).ToArray(); double[] solution = OverDeterminedEquationSolve(beta, actualconstants, originalEquations); foreach (double item in solution) { result.Add(AFloat.Create(item)); } } else { for (int objective = 0; objective < constants.Shape[1]; objective++) { beta = independentConstants.Select(item => item[objective]).ToArray(); actualconstants = constants.Select(item => item[objective].asFloat).ToArray(); double[] solution = OverDeterminedEquationSolve(beta, actualconstants, originalEquations); AType solutionArray = AArray.Create(ATypes.AFloat); foreach (double item in solution) { solutionArray.Add(AFloat.Create(item)); } result.Add(solutionArray); } } } return(result); }