/// <summary>
/// </summary>
/// <param name="right"></param>
/// <param name="left"></param>
private LaminateJobInfo CreateLaminateJob(AType right, AType left)
{
LaminateJobInfo laminateInfo =
new LaminateJobInfo(left.Length != 0 ? left.Type : right.Type);
if (left.IsArray && !right.IsArray)
{
laminateInfo.Left = left.Clone();
laminateInfo.Right = DyadicFunctionInstance.Reshape.Execute(right, left.Shape.ToAArray());
}
else if (!left.IsArray && right.IsArray)
{
laminateInfo.Right = right.Clone();
laminateInfo.Left = DyadicFunctionInstance.Reshape.Execute(left, right.Shape.ToAArray());
}
else
{
laminateInfo.Right = right.Clone();
laminateInfo.Left = left.Clone();
}
// check if the types are same
if (right.Type != left.Type)
{
if (left.Type == ATypes.AFloat && right.Type == ATypes.AInteger)
{
right = right.ConvertToFloat();
}
else if (left.Type == ATypes.AInteger && right.Type == ATypes.AFloat)
{
left = left.ConvertToFloat();
}
else if (!(Utils.IsSameGeneralType(left, right)
|| left.Type == ATypes.ANull || right.Type == ATypes.ANull))
{
throw new Error.Type(TypeErrorText);
}
}
// check the length, shape and rank
if (laminateInfo.Left.Rank != laminateInfo.Right.Rank)
{
throw new Error.Rank(RankErrorText);
}
if (!laminateInfo.Left.Shape.SequenceEqual(laminateInfo.Right.Shape))
{
throw new Error.Length(LengthErrorText);
}
if (laminateInfo.Left.Rank >= 9 || laminateInfo.Right.Rank >= 9)
{
throw new Error.MaxRank(MaxRankErrorText);
}
return laminateInfo;
}
private AType ConvertToInt(AType argument)
{
AType result;
switch (argument.Type)
{
case ATypes.AInteger:
result = argument.Clone();
break;
case ATypes.AFloat:
result = ConvertFloatToInt(argument);
break;
case ATypes.AChar:
result = ConvertCharToInt(argument, false);
break;
case ATypes.ASymbol:
result = ConvertSymToInt(argument);
break;
default:
throw new Error.Domain(this.DomainErrorText);
}
return(result);
}
public override AType Execute(AType right, AType left, Aplus environment = null)
{
// First we check if one side is an ANull
if (right.Type == ATypes.ANull)
{
return AArray.Create(left.Type, left.Clone());
}
else if (left.Type == ATypes.ANull)
{
return AArray.Create(right.Type, right.Clone());
}
// Type check
if(!Utils.IsSameGeneralType(left, right))
{
throw new Error.Type(this.TypeErrorText);
}
AType result = CreateResult(right, left);
// Convert to float if one of the arguments is an AFloat and the other is an AInteger
if (Utils.DifferentNumberType(left, right))
{
result.ConvertToFloat();
}
return result;
}
internal static AType StringSearchandReplace(Aplus environment, AType replaceWith, AType replaceWhat, AType replaceIn)
{
if (replaceIn.Type != ATypes.AChar || replaceWhat.Type != ATypes.AChar || replaceWith.Type != ATypes.AChar)
{
throw new Error.Type("_ssr");
}
string withString = Monadic.MonadicFunctionInstance.Ravel.Execute(replaceWith, environment).ToString();
string whatString = Monadic.MonadicFunctionInstance.Ravel.Execute(replaceWhat, environment).ToString();
AType argument = (withString.Length == whatString.Length)
? replaceIn.Clone() : Monadic.MonadicFunctionInstance.Ravel.Execute(replaceIn, environment);
Queue<string> rows = new Queue<string>();
ExtractRows(argument, rows);
Queue<string> replacedRows = new Queue<string>();
foreach (string item in rows)
{
string replaced = item.Replace(whatString, withString);
replacedRows.Enqueue(replaced);
}
AType result = BuildAType(replacedRows, argument.Shape);
return result;
}
public override AType Execute(AType argument, Aplus environment)
{
AType result;
if (argument.SimpleArray())
{
result = argument.IsMemoryMappedFile ? argument : argument.Clone();
}
else
{
if (!argument.NestedArray())
{
throw new Error.Domain(DomainErrorText);
}
switch (argument.Rank)
{
case 0:
result = MonadicFunctionInstance.Disclose.Execute(argument);
break;
case 1:
result = NestedVector(argument);
break;
default:
throw new Error.Rank(RankErrorText);
}
}
return result;
}
public override AType Execute(AType argument, Aplus environment = null)
{
SetVariables(argument);
AType result;
//First dimension equal with zero case (as Null).
if (argument.Length == 0)
{
result = argument.Clone();
result.Type = this.type;
}
else
{
//Accepted types are float and integer.
if (argument.Type != ATypes.AFloat && argument.Type != ATypes.AInteger)
{
throw new Error.Type(TypeErrorText);
}
result = argument.IsArray ? ScanAlgorithm(argument) : PreProcess(argument);
}
return result;
}
private AType Compute(AType right, int dropCounter)
{
if (right.IsArray && dropCounter == 0)
{
return right.Clone();
}
AType result = AArray.Create(ATypes.AType);
if (right.IsArray)
{
if (right.Length - Math.Abs(dropCounter) > 0)
{
if (dropCounter > 0)
{
for (int i = dropCounter; i < right.Length; i++)
{
result.AddWithNoUpdate(right[i].Clone());
}
}
else
{
for (int i = 0; i < right.Length + dropCounter; i++)
{
result.AddWithNoUpdate(right[i].Clone());
}
}
result.Length = right.Length - Math.Abs(dropCounter);
result.Shape = new List<int>() { result.Length };
if (right.Rank > 1)
{
result.Shape.AddRange(right.Shape.GetRange(1, right.Shape.Count - 1));
}
result.Rank = right.Rank;
result.Type = result[0].Type;
}
else
{
result.Type = right.MixedType() ? ATypes.ANull : right.Type;
}
}
else
{
if (dropCounter == 0)
{
result.Add(right.Clone());
result.Length = 1;
result.Shape = new List<int>() { 1 };
result.Type = right.Type;
}
else
{
result.Type = right.MixedType() ? ATypes.ANull : right.Type;
}
}
return result;
}
/// <summary>
/// Transpose reduction to Transpose Axes.
/// As follows: (rot iota rho rho x) flip x
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
public override AType Execute(AType argument, Aplus environment)
{
if (argument.IsArray)
{
AType transposeVector = Enumerable.Range(0, argument.Rank).Reverse().ToAArray();
return DyadicFunctionInstance.TransposeAxis.Execute(argument, transposeVector);
}
else
{
return argument.Clone();
}
}
/// <summary>
/// Transpose reduction to Transpose Axes.
/// As follows: (rot iota rho rho x) flip x
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
public override AType Execute(AType argument, Aplus environment)
{
if (argument.IsArray)
{
AType transposeVector = Enumerable.Range(0, argument.Rank).Reverse().ToAArray();
return(DyadicFunctionInstance.TransposeAxis.Execute(argument, transposeVector));
}
else
{
return(argument.Clone());
}
}
/// <summary>
/// Select item from items array by pathVector.
/// </summary>
/// <param name="pathVector"></param>
/// <param name="arguments"></param>
/// <returns></returns>
private static AType GetItem(AType items, List <int> pathVector, int[] transposeVector)
{
int[] originalPathVector = GetOriginalIndex(pathVector, transposeVector);
AType result = items;
foreach (int pathElement in originalPathVector)
{
result = result[pathElement];
}
return(result.Clone());
}
internal static AType Alsf(Aplus environment, AType input)
{
if (input.Rank > 1)
{
throw new Error.Rank("_alsf");
}
if (input.IsSlotFiller())
{
return(input.Clone());
}
return((input.IsArray) ? ArrayInput(input) : NotArrayInput(input));
}
internal static AType Alsf(Aplus environment, AType input)
{
if (input.Rank > 1)
{
throw new Error.Rank("_alsf");
}
if (input.IsSlotFiller())
{
return input.Clone();
}
return (input.IsArray) ? ArrayInput(input) : NotArrayInput(input);
}
public static AType SimpleIndex(this AType input, List <AType> indexers, int indexpos, AType currentIdx, bool isAssign, bool isMemoryMapped)
{
// Get the current item, specified by the currentIdx
AType item = input[currentIdx];
if (item.IsArray && indexpos < indexers.Count - 1)
{
// If it is an array and we can index further, then do so
return(item.Indexing(indexers, indexpos + 1, isAssign, isMemoryMapped));
}
else
{
return(!isAssign && isMemoryMapped?item.Clone() : item);
}
}
public AType Compute(Aplus environment, AType right, AType left, out bool resultFromBox)
{
//Type Error!
if (left.Type == ATypes.AChar || (left.Type == ATypes.AFloat && left.asInteger != left.asFloat))
{
throw new Error.Type(TypeErrorText);
}
// Case 2: If the right argument is scalar than we wrap it to one-element vector.
AType rightArray;
if (right.IsArray)
{
rightArray = right;
}
else
{
rightArray =
AArray.Create(right.Type, right.IsMemoryMappedFile ? right.Clone() : right);
}
AType result;
if (left.IsBox) // Case 6
{
resultFromBox = true;
result =
ItemSelectWalker(NestedPathNumber2NestedArrayDelegate, left, rightArray, environment);
}
else if (left.Type == ATypes.ASymbol) // Case 3
{
resultFromBox = true;
result =
ItemSelectWalker(SymbolConstant2SlotFillerDelegate, left, rightArray, environment);
}
else if (right.IsBox) // Case 5
{
result = PathVector2NestedVector(left, rightArray, out resultFromBox);
}
else // Case 1-2-4
{
resultFromBox = false;
result = SimpleNumeric2SimpleRight(left, rightArray);
}
return(result);
}
private static void PerformIndexAssign(AType target, AType value)
{
if (target.Rank > 0)
{
for (int i = 0; i < target.Length; i++)
{
PerformIndexAssign(target[i], value.IsArray ? value[i] : value);
}
}
else
{
AValue result;
if (target.Type == value.Type)
{
result = value.Clone().Data;
}
else if (target.Type == ATypes.AInteger && value.Type == ATypes.AFloat)
{
int number;
if (!value.ConvertToRestrictedWholeNumber(out number))
{
throw new Error.Type("assign");
}
result = AInteger.Create(number).Data;
}
else if (target.Type == ATypes.AFloat && value.Type == ATypes.AInteger)
{
result = AFloat.Create(value.asInteger).Data;
}
else
{
throw new Error.Type("Assign");
}
if (target.IsMemoryMappedFile)
{
((IMapped)target.Data).Update(result);
}
else
{
target.Data = result;
}
}
}
/// <summary>
/// If right side length equal zero, then the result
/// is (1 drop x) rho identity, where identity is scalar
/// that depends on function.
/// </summary>
/// <param name="shape"></param>
/// <returns></returns>
private AType Fill(List <int> shape)
{
if (shape.Count > 0)
{
AType result = AArray.Create(this.type);
for (int i = 0; i < shape[0]; i++)
{
result.Add(Fill(shape.GetRange(1, shape.Count - 1)));
}
return(result);
}
else
{
return(fillerElement.Clone());
}
}
public override AType Execute(AType argument, Aplus environment = null)
{
if (argument.IsFunctionScalar)
{
return(GetFunction(argument));
}
else if (argument.IsBox)
{
if (argument.IsArray)
{
throw new Error.Rank(RankErrorText);
}
else
{
throw new Error.Type(TypeErrorText);
}
}
else if (argument.Type == ATypes.ANull)
{
throw new Error.Rank(RankErrorText);
}
else if (argument.Type == ATypes.AChar)
{
return(argument.Clone());
}
// use Printing precision system variable
int printingPrecision = (environment != null) ? environment.SystemVariables["pp"].asInteger : -1;
switch (printingPrecision)
{
case -1:
// system variable doesn't exist, so we write whole float number.
printingPrecision = 0;
break;
case 0:
// if `pp is 0, then it is reated as if it were one.
printingPrecision = 1;
break;
}
return(Compute(argument, printingPrecision));
}
public override AType Execute(AType argument, Aplus environment = null)
{
if (argument.SimpleArray())
{
//The argument is simple array/scalar and not mapped we clone it!
return(argument.IsMemoryMappedFile ?
argument :
argument.Clone());
}
else
{
if (!argument.NestedArray())
{
throw new Error.Domain(DomainErrorText);
}
return(DiscloseNestedArray(argument, environment));
}
}
public override AType Execute(AType argument, Aplus environment = null)
{
if (argument.SimpleArray())
{
//The argument is simple array/scalar and not mapped we clone it!
return argument.IsMemoryMappedFile ?
argument :
argument.Clone();
}
else
{
if (!argument.NestedArray())
{
throw new Error.Domain(DomainErrorText);
}
return DiscloseNestedArray(argument, environment);
}
}
public override AType Execute(AType argument, Aplus environment = null)
{
if (argument.Type == ATypes.ANull)
{
return(argument.Clone());
}
if (!argument.SimpleSymbolArray())
{
throw new Error.Type(TypeErrorText);
}
if (argument.Rank > 8)
{
throw new Error.MaxRank(MaxRankErrorText);
}
return(Walk(argument));
}
public override AType Execute(AType argument, Aplus environment = null)
{
if (argument.Type == ATypes.ANull)
{
return argument.Clone();
}
if (!argument.SimpleSymbolArray())
{
throw new Error.Type(TypeErrorText);
}
if (argument.Rank > 8)
{
throw new Error.MaxRank(MaxRankErrorText);
}
return Walk(argument);
}
/// <summary>
/// If argument is:
/// - integer then we clone it.
/// - null we return integer null.
/// - float then we use ConvertFloatConstantToIntegerConstant function.
/// - char we call ConvertCharConstantToNumberConstant function.
/// - symbol then we use ConvertSymbolConstantToNumber function.
/// </summary>
/// <param name="argument"></param>
/// <param name="arguments"></param>
/// <returns></returns>
private AType IntegerCase(AType argument)
{
AType result;
CastInfo castInfo = new CastInfo(ATypes.AInteger);
switch (argument.Type)
{
case ATypes.AInteger:
result = argument.Clone();
break;
case ATypes.ANull:
result = Utils.ANull(ATypes.AInteger);
break;
case ATypes.AFloat:
castInfo.Converter = new Converter(ConvertToInteger);
result = Walker(argument, castInfo);
break;
case ATypes.AChar:
castInfo.Converter = new Converter(ConvertCharacterToNumber);
result = Walker(argument, castInfo);
break;
case ATypes.ASymbol:
if (!argument.SimpleSymbolArray())
{
throw new Error.Type(TypeErrorText);
}
DetectLongestSymbol(argument, castInfo);
castInfo.Converter = new Converter(ConvertSymbolConstantToNumber);
result = Walker(argument, castInfo);
break;
default:
throw new Error.Domain(DomainErrorText);
}
return(result);
}
public override AType Execute(AType right, AType left, Aplus environment = null)
{
AType result;
int[] rotateVector = PrepareRotateVector(right, left);
if (right.Rank == 0)
{
// if the right argument is scalar, we clone it
result = right.Clone();
}
else if (right.Rank > 2)
{
result = TransformAndCompute(right, rotateVector);
}
else
{
result = Compute(right, rotateVector);
}
return result;
}
public override AType Execute(AType right, AType left, Aplus environment = null)
{
AType result;
int[] rotateVector = PrepareRotateVector(right, left);
if (right.Rank == 0)
{
// if the right argument is scalar, we clone it
result = right.Clone();
}
else if (right.Rank > 2)
{
result = TransformAndCompute(right, rotateVector);
}
else
{
result = Compute(right, rotateVector);
}
return(result);
}
private AType Compute(AType items, byte[] expandVector)
{
AType result = AArray.Create(ATypes.AType);
int index = 0;
// get the filler element based on the right argument
AType fillElementShape =
items.Rank > 1 ? items.Shape.GetRange(1, items.Shape.Count - 1).ToAArray() : null;
AType filler = Utils.FillElement(items.Type, fillElementShape);
for (int i = 0; i < expandVector.Length; i++)
{
if (expandVector[i] == 1)
{
result.AddWithNoUpdate(items[items.Length > 1 ? index++ : 0].Clone());
}
else
{
result.AddWithNoUpdate(filler.Clone());
}
}
result.Length = expandVector.Length;
result.Shape = new List <int>()
{
expandVector.Length
};
if (items.Rank > 1)
{
result.Shape.AddRange(items.Shape.GetRange(1, items.Shape.Count - 1));
}
result.Rank = items.Rank;
result.Type = result.Length > 0 ? result[0].Type : (items.MixedType() ? ATypes.ANull : items.Type);
return(result);
}
/// <summary>
/// Separate symbol constant by definiton.
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
private AType SeparateSymbol(AType argument)
{
AType result = AArray.Create(ATypes.ASymbol);
string symbol = argument.asString;
int index = symbol.LastIndexOf('.');
if (index != -1)
{
result.AddWithNoUpdate(ASymbol.Create(symbol.Substring(0, index)));
result.AddWithNoUpdate(ASymbol.Create(symbol.Substring(index + 1)));
}
else
{
result.AddWithNoUpdate(ASymbol.Create(""));
result.AddWithNoUpdate(argument.Clone());
}
result.Length = 2;
result.Shape = new List<int>() { 2 };
result.Rank = 1;
return result;
}
public override AType Execute(AType argument, Aplus environment = null)
{
if (argument.IsArray)
{
AType result = AArray.Create(ATypes.AArray);
for (int i = argument.Length - 1; i >= 0; i--)
{
result.AddWithNoUpdate(argument[i].Clone());
}
result.Length = argument.Length;
result.Shape = new List <int>(argument.Shape);
result.Rank = argument.Rank;
result.Type = result.Length > 0 ? result[0].Type : ATypes.ANull;
return(result);
}
else
{
return(argument.Clone());
}
}
public override AType Execute(AType argument, Aplus environment = null)
{
if (argument.IsArray)
{
AType result = AArray.Create(ATypes.AArray);
for (int i = argument.Length - 1; i >= 0; i--)
{
result.AddWithNoUpdate(argument[i].Clone());
}
result.Length = argument.Length;
result.Shape = new List<int>(argument.Shape);
result.Rank = argument.Rank;
result.Type = result.Length > 0 ? result[0].Type : ATypes.ANull;
return result;
}
else
{
return argument.Clone();
}
}
private static void PerformIndexAssign(AType target, AType value)
{
if (target.Rank > 0)
{
for (int i = 0; i < target.Length; i++)
{
PerformIndexAssign(target[i], value.IsArray ? value[i] : value);
}
}
else
{
AValue result;
if (target.Type == value.Type)
{
result = value.Clone().Data;
}
else if (target.Type == ATypes.AInteger && value.Type == ATypes.AFloat)
{
int number;
if (!value.ConvertToRestrictedWholeNumber(out number))
{
throw new Error.Type("assign");
}
result = AInteger.Create(number).Data;
}
else if (target.Type == ATypes.AFloat && value.Type == ATypes.AInteger)
{
result = AFloat.Create(value.asInteger).Data;
}
else
{
throw new Error.Type("Assign");
}
if (target.IsMemoryMappedFile)
{
((IMapped)target.Data).Update(result);
}
else
{
target.Data = result;
}
}
}
public AType Compute(Aplus environment, AType right, AType left, out bool resultFromBox)
{
//Type Error!
if (left.Type == ATypes.AChar || (left.Type == ATypes.AFloat && left.asInteger != left.asFloat))
{
throw new Error.Type(TypeErrorText);
}
// Case 2: If the right argument is scalar than we wrap it to one-element vector.
AType rightArray;
if (right.IsArray)
{
rightArray = right;
}
else
{
rightArray =
AArray.Create(right.Type, right.IsMemoryMappedFile ? right.Clone() : right);
}
AType result;
if (left.IsBox) // Case 6
{
resultFromBox = true;
result =
ItemSelectWalker(NestedPathNumber2NestedArrayDelegate, left, rightArray, environment);
}
else if (left.Type == ATypes.ASymbol) // Case 3
{
resultFromBox = true;
result =
ItemSelectWalker(SymbolConstant2SlotFillerDelegate, left, rightArray, environment);
}
else if (right.IsBox) // Case 5
{
result = PathVector2NestedVector(left, rightArray, out resultFromBox);
}
else // Case 1-2-4
{
resultFromBox = false;
result = SimpleNumeric2SimpleRight(left, rightArray);
}
return result;
}
public override AType Execute(AType argument, Aplus environment = null)
{
return argument.IsMemoryMappedFile ? argument.Clone() : argument;
}
protected virtual AType Process(AType argument)
{
return(argument.Clone());
}
/// <summary>
/// If argument is:
/// - char we clone it.
/// - null then we return char null.
/// - symbol then we use Unpack nonscalar function.
/// - null or symbol we just clone it.
/// - float or integer we use ConvertToCharConstant function.
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
private AType CharCase(AType argument)
{
AType result;
CastInfo castInfo = new CastInfo(ATypes.AChar);
switch (argument.Type)
{
case ATypes.AChar:
result = argument.Clone();
break;
case ATypes.ANull:
result = Utils.ANull(ATypes.AChar);
break;
case ATypes.ASymbol:
result = MonadicFunctionInstance.Unpack.Execute(argument);
break;
case ATypes.AInteger:
case ATypes.AFloat:
castInfo.Converter = new Converter(ConvertNumberToCharacter);
result = Walker(argument, castInfo);
break;
default:
throw new Error.Domain(DomainErrorText);
}
return result;
}
/// <summary>
/// Creates the resulting AArray
/// </summary>
/// <param name="right"></param>
/// <param name="left"></param>
/// <returns>AArray containing the concatenated elements.</returns>
private AType CreateResult(AType right, AType left)
{
AType result = AArray.Create(left.Type);
// Create a clone from the arguments to avoid side effects
AType clonedLeft = left.Clone();
AType clonedRight = right.Clone();
if (!clonedLeft.IsArray && !clonedRight.IsArray)
{
// example input: 1 , 2
result.AddWithNoUpdate(clonedLeft);
result.Add(clonedRight);
}
else if (clonedLeft.IsArray && !clonedRight.IsArray)
{
// example input: 1 2 , 3
result.AddRange(clonedLeft);
AType item = PrepareItem(clonedRight, clonedLeft);
result.Add(item);
}
else if (!clonedLeft.IsArray && clonedRight.IsArray)
{
// example input: 1 , 2 3
result.AddWithNoUpdate(PrepareItem(clonedLeft, clonedRight));
result.AddRange(clonedRight);
}
// now both left and right argument is an AArray
else if (clonedLeft.Rank == clonedRight.Rank)
{
// example input: (iota 2 2) , (iota 2 2)
CheckItemsShape(clonedLeft, clonedRight);
if (clonedLeft.Length > 0)
{
result.AddRange(clonedLeft);
}
if (clonedRight.Length > 0)
{
result.AddRange(clonedRight);
}
}
else if ((clonedLeft.Rank - clonedRight.Rank) == 1)
{
// example input: (iota 2 2 2) , (iota 2 2)
CheckShape(clonedLeft.Shape.GetRange(1, clonedLeft.Shape.Count - 1), clonedRight.Shape);
result.AddRange(clonedLeft);
result.Add(clonedRight);
}
else if ((clonedLeft.Rank - clonedRight.Rank) == -1)
{
// example input: (iota 2 2) , (iota 2 2 2)
CheckShape(clonedLeft.Shape, clonedRight.Shape.GetRange(1, clonedRight.Shape.Count - 1));
result.AddWithNoUpdate(clonedLeft);
result.AddRange(clonedRight);
}
else
{
// The rank difference was bigger than 1.
throw new Error.Rank(this.RankErrorText);
}
return result;
}
public override AType Execute(AType argument, Aplus environment = null)
{
return(argument.IsMemoryMappedFile ? argument.Clone() : argument);
}
protected virtual AType Process(AType argument)
{
return argument.Clone();
}
private AType Compute(AType right, int dropCounter)
{
if (right.IsArray && dropCounter == 0)
{
return(right.Clone());
}
AType result = AArray.Create(ATypes.AType);
if (right.IsArray)
{
if (right.Length - Math.Abs(dropCounter) > 0)
{
if (dropCounter > 0)
{
for (int i = dropCounter; i < right.Length; i++)
{
result.AddWithNoUpdate(right[i].Clone());
}
}
else
{
for (int i = 0; i < right.Length + dropCounter; i++)
{
result.AddWithNoUpdate(right[i].Clone());
}
}
result.Length = right.Length - Math.Abs(dropCounter);
result.Shape = new List <int>()
{
result.Length
};
if (right.Rank > 1)
{
result.Shape.AddRange(right.Shape.GetRange(1, right.Shape.Count - 1));
}
result.Rank = right.Rank;
result.Type = result[0].Type;
}
else
{
result.Type = right.MixedType() ? ATypes.ANull : right.Type;
}
}
else
{
if (dropCounter == 0)
{
result.Add(right.Clone());
result.Length = 1;
result.Shape = new List <int>()
{
1
};
result.Type = right.Type;
}
else
{
result.Type = right.MixedType() ? ATypes.ANull : right.Type;
}
}
return(result);
}
private AType Compute(AType items, int desiredCount)
{
AType result = AArray.Create(items.Type);
if (desiredCount > 0)
{
// Check how many we can copy from the right argument
int count = (desiredCount <= items.Length) ? desiredCount : items.Length;
int remainder = desiredCount - count;
for (int i = 0; i < count; i++)
{
result.AddWithNoUpdate(items[i].Clone());
}
// Check if there is some leftover we need to fill
if (remainder > 0)
{
AType filler = FillElement(items);
for (; remainder > 0; remainder--)
{
result.AddWithNoUpdate(filler.Clone());
}
}
}
else
{
// set the start point, which is the difference between the length of the items and
// the count we want to take from the end of the list
// NOTE: + is used because in this case the 'desiredCount' variable is a negative number
int start = items.Length + desiredCount;
if (start < 0)
{
// This case we need to add fill elements to the start of the array
AType filler = FillElement(items);
for (; start < 0; start++)
{
result.AddWithNoUpdate(filler.Clone());
}
// Now the 'start' is 0
}
for (; start < items.Length; start++)
{
result.AddWithNoUpdate(items[start].Clone());
}
}
result.Length = Math.Abs(desiredCount);
result.Shape = new List <int>()
{
result.Length
};
if (items.Rank > 1)
{
result.Shape.AddRange(items.Shape.GetRange(1, items.Shape.Count - 1));
}
result.Rank = items.Rank;
if (desiredCount == 0)
{
result.Type = items.MixedType() ? ATypes.ANull : items.Type;
}
else
{
result.Type = result[0].Type;
}
return(result);
}
/// <summary>
/// If argument is:
/// - integer then we clone it.
/// - null we return integer null.
/// - float then we use ConvertFloatConstantToIntegerConstant function.
/// - char we call ConvertCharConstantToNumberConstant function.
/// - symbol then we use ConvertSymbolConstantToNumber function.
/// </summary>
/// <param name="argument"></param>
/// <param name="arguments"></param>
/// <returns></returns>
private AType IntegerCase(AType argument)
{
AType result;
CastInfo castInfo = new CastInfo(ATypes.AInteger);
switch (argument.Type)
{
case ATypes.AInteger:
result = argument.Clone();
break;
case ATypes.ANull:
result = Utils.ANull(ATypes.AInteger);
break;
case ATypes.AFloat:
castInfo.Converter = new Converter(ConvertToInteger);
result = Walker(argument, castInfo);
break;
case ATypes.AChar:
castInfo.Converter = new Converter(ConvertCharacterToNumber);
result = Walker(argument, castInfo);
break;
case ATypes.ASymbol:
if (!argument.SimpleSymbolArray())
{
throw new Error.Type(TypeErrorText);
}
DetectLongestSymbol(argument, castInfo);
castInfo.Converter = new Converter(ConvertSymbolConstantToNumber);
result = Walker(argument, castInfo);
break;
default:
throw new Error.Domain(DomainErrorText);
}
return result;
}
private AType ConvertToFloat(AType argument)
{
AType result;
int typeSize = GetTypeSize(ATypes.AFloat);
switch (argument.Type)
{
case ATypes.AInteger:
result = ConvertToFloat(argument, typeSize, false);
break;
case ATypes.AFloat:
result = argument.Clone();
break;
case ATypes.AChar:
result = ConvertToFloat(argument, typeSize, false);
break;
case ATypes.ASymbol:
result = ConvertToFloat(ConvertToInt(argument));
break;
default:
throw new Error.Domain(this.DomainErrorText);
}
return result;
}
public override AType Execute(AType argument, Aplus environment = null)
{
if (argument.IsFunctionScalar)
{
return GetFunction(argument);
}
else if (argument.IsBox)
{
if (argument.IsArray)
{
throw new Error.Rank(RankErrorText);
}
else
{
throw new Error.Type(TypeErrorText);
}
}
else if (argument.Type == ATypes.ANull)
{
throw new Error.Rank(RankErrorText);
}
else if (argument.Type == ATypes.AChar)
{
return argument.Clone();
}
// use Printing precision system variable
int printingPrecision = (environment != null) ? environment.SystemVariables["pp"].asInteger : -1;
switch (printingPrecision)
{
case -1:
// system variable doesn't exist, so we write whole float number.
printingPrecision = 0;
break;
case 0:
// if `pp is 0, then it is reated as if it were one.
printingPrecision = 1;
break;
}
return Compute(argument, printingPrecision);
}
/// <summary>
/// Creates the resulting AArray
/// </summary>
/// <param name="right"></param>
/// <param name="left"></param>
/// <returns>AArray containing the concatenated elements.</returns>
private AType CreateResult(AType right, AType left)
{
AType result = AArray.Create(left.Type);
// Create a clone from the arguments to avoid side effects
AType clonedLeft = left.Clone();
AType clonedRight = right.Clone();
if (!clonedLeft.IsArray && !clonedRight.IsArray)
{
// example input: 1 , 2
result.AddWithNoUpdate(clonedLeft);
result.Add(clonedRight);
}
else if (clonedLeft.IsArray && !clonedRight.IsArray)
{
// example input: 1 2 , 3
result.AddRange(clonedLeft);
AType item = PrepareItem(clonedRight, clonedLeft);
result.Add(item);
}
else if (!clonedLeft.IsArray && clonedRight.IsArray)
{
// example input: 1 , 2 3
result.AddWithNoUpdate(PrepareItem(clonedLeft, clonedRight));
result.AddRange(clonedRight);
}
// now both left and right argument is an AArray
else if (clonedLeft.Rank == clonedRight.Rank)
{
// example input: (iota 2 2) , (iota 2 2)
CheckItemsShape(clonedLeft, clonedRight);
if (clonedLeft.Length > 0)
{
result.AddRange(clonedLeft);
}
if (clonedRight.Length > 0)
{
result.AddRange(clonedRight);
}
}
else if ((clonedLeft.Rank - clonedRight.Rank) == 1)
{
// example input: (iota 2 2 2) , (iota 2 2)
CheckShape(clonedLeft.Shape.GetRange(1, clonedLeft.Shape.Count - 1), clonedRight.Shape);
result.AddRange(clonedLeft);
result.Add(clonedRight);
}
else if ((clonedLeft.Rank - clonedRight.Rank) == -1)
{
// example input: (iota 2 2) , (iota 2 2 2)
CheckShape(clonedLeft.Shape, clonedRight.Shape.GetRange(1, clonedRight.Shape.Count - 1));
result.AddWithNoUpdate(clonedLeft);
result.AddRange(clonedRight);
}
else
{
// The rank difference was bigger than 1.
throw new Error.Rank(this.RankErrorText);
}
return(result);
}
private static AType AppendItem(AType value, AType target, Aplus environment)
{
if (target.Rank == 0)
{
throw new Error.Rank("assign");
}
if (!Utils.DifferentNumberType(target, value) && target.Type != value.Type)
{
// The target and value are not numbers and they are of a different type?
throw new Error.Type("assign");
}
if (target.Shape.SequenceEqual<int>(value.Shape))
{
for (int i = 0; i < value.Length; i++)
{
target.Add(value[i].Clone());
}
}
else if (target.Shape.GetRange(1, target.Shape.Count - 1).SequenceEqual<int>(value.Shape))
{
target.Add(value.Clone());
}
else if (value.Rank == 0)
{
AType item = DyadicFunctionInstance.Reshape.Execute(
value,
target.Shape.GetRange(1, target.Shape.Count - 1).ToAArray()
);
target.Add(item);
}
else if (value.Rank == target.Rank)
{
for (int i = 0; i < value.Length; i++)
{
target.Add(value[i].Clone());
}
}
else
{
throw new Error.Length("assign");
}
return value;
}
private AType ConvertToInt(AType argument)
{
AType result;
switch (argument.Type)
{
case ATypes.AInteger:
result = argument.Clone();
break;
case ATypes.AFloat:
result = ConvertFloatToInt(argument);
break;
case ATypes.AChar:
result = ConvertCharToInt(argument, false);
break;
case ATypes.ASymbol:
result = ConvertSymToInt(argument);
break;
default:
throw new Error.Domain(this.DomainErrorText);
}
return result;
}
