private AType ConvertFloatToInt(AType argument)
{
AType result = AArray.Create(ATypes.AInteger);
if (argument.IsArray)
{
foreach (AType item in argument)
{
AType convertedItem = ConvertFloatToInt(item);
if (item.IsArray)
{
result.Add(convertedItem);
}
else
{
result.AddRange(convertedItem);
}
}
}
else
{
int destinationTypeSize = GetTypeSize(ATypes.AInteger);
byte[] bytes = BitConverter.GetBytes(argument.asFloat);
for (int i = 0; i < bytes.Length; i += destinationTypeSize)
{
result.Add(AInteger.Create(BitConverter.ToInt32(bytes, i)));
}
}
return(result);
}
public AType BuildArray(List <int> shape, ref byte[] data, ATypes type, int index)
{
AType result = Utils.ANull();
int typeSize;
ItemConstructDelegate itemConstruct;
switch (type)
{
case ATypes.AInteger:
typeSize = sizeof(Int32);
itemConstruct = ConstructAInteger;
break;
case ATypes.AChar:
typeSize = sizeof(Char) / 2; // FIXMEEE!!!!! sizeof(Char) == 2 in C#!!!!!
itemConstruct = ConstructAChar;
break;
case ATypes.AFloat:
typeSize = sizeof(Double);
itemConstruct = ConstructAFloat;
break;
default:
throw new ADAPException(ADAPExceptionType.Import);
}
if (data.Length < (typeSize * shape.Product() + index))
{
throw new ADAPException(ADAPExceptionType.Import);
}
if (shape.Count == 0)
{
result = itemConstruct(ref data, index);
}
else if (shape.Count == 1)
{
for (int i = 0; i < shape[0]; i++)
{
result.Add(itemConstruct(ref data, index));
index += typeSize;
}
}
else
{
for (int i = 0; i < shape[0]; i++)
{
List <int> nextShape = shape.GetRange(1, shape.Count - 1);
int subDimensionLength = nextShape.Product() * typeSize;
result.Add(BuildArray(nextShape, ref data, type, index));
index += subDimensionLength;
}
}
return(result);
}
public override DLR.Expression Generate(AplusScope scope)
{
if (this.list.Count == 1)
{
return(this.list.First.Value.Generate(scope));
}
AType items = null;
if (this.type == ConstantType.Integer)
{
bool convertToFloat = false;
items = AArray.Create(ATypes.AInteger);
foreach (Constant item in this.list)
{
AType value = item.AsNumericAType;
items.Add(value);
if (value.Type == ATypes.AFloat)
{
convertToFloat = true;
}
}
// Convert integer items in previous array to float
if (convertToFloat)
{
items.ConvertToFloat();
}
}
// Treat the Infinite constants same as floats
else if (this.type == ConstantType.Double ||
this.type == ConstantType.PositiveInfinity ||
this.type == ConstantType.NegativeInfinity)
{
items = AArray.Create(ATypes.AFloat);
foreach (Constant item in this.list)
{
items.Add(AFloat.Create(item.AsFloat));
}
}
else if (this.type == ConstantType.Symbol)
{
items = AArray.Create(ATypes.ASymbol);
foreach (Constant item in this.list)
{
items.Add(ASymbol.Create(item.AsString));
}
}
else
{
throw new Error.Parse(String.Format("Unknow ConstantType({0}) in current context", this.type));
}
DLR.Expression result = DLR.Expression.Constant(items, typeof(AType));
// Example: .Constant<AplusCore.Types.AArray`1[AplusCore.Types.AInteger]>(1 2)
return(result);
}
private static AType PermissiveIndexingSubIndex(
AType index, AType array, AType defaultItem, Aplus environment)
{
AType result = AArray.Create(array.Type);
if (index.IsArray)
{
for (int i = 0; i < index.Length; i++)
{
result.Add(PermissiveIndexingSubIndex(index[i], array, defaultItem, environment));
}
}
else if (index.asInteger > array.Length - 1 || index.asInteger < 0)
{
if (defaultItem.Rank == 0 && array[0].Rank != 0)
{
result = DyadicFunctionInstance.Reshape.Execute(defaultItem, array[0].Shape.ToAArray(), environment);
}
else
{
result = defaultItem;
}
}
else
{
result = array[index];
}
return(result);
}
/// <summary>
/// Builds ASymbol.
/// </summary>
/// <param name="shape">The shape of the AType.</param>
/// <param name="symbolLengths">The lengths of the ASymbols contained by the AType.</param>
/// <param name="info">The class containing the informations for importing.</param>
/// <returns></returns>
private AType BuildSymbolArray(List <int> shape, IEnumerable <int> symbolLengths, ImportInfo info)
{
AType result = Utils.ANull();
if (shape.Count == 0)
{
StringBuilder toSymbol = new StringBuilder();
int length = symbolLengths.First();
for (int i = 0; i < length; i++)
{
toSymbol.Append((char)info.Data[info.DataIndex]);
info.DataIndex++;
}
result = ASymbol.Create(toSymbol.ToString());
}
else
{
List <int> nextShape = (shape.Count > 1) ? shape.GetRange(1, shape.Count - 1) : new List <int>();
int subDimensionLength = nextShape.Product();
for (int i = 0; i < shape[0]; i++)
{
IEnumerable <int> nextSymbolLengths = symbolLengths.Skip(i * subDimensionLength).Take(subDimensionLength);
result.Add(BuildSymbolArray(nextShape, nextSymbolLengths, info));
// advance the bytestream further.
}
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="indexers">List containing all of the indexes</param>
/// <param name="indexpos"></param>
/// <param name="currentIdx">Array containing the current indexes</param>
/// <returns></returns>
public static AType VectorIndexing(this AType input, List<AType> indexers, int indexpos, AType currentIdx, bool isAssign, bool isMemoryMapped)
{
if (currentIdx.Length == 0)
{
// A Null item found!, select all of the current items
for (int i = 0; i < input.Length; i++)
{
currentIdx.Add(AInteger.Create(i));
}
}
// Create an array for the results
AType result = AArray.Create(input.Type);
// Iterate over the indexes
foreach (AType index in currentIdx)
{
AType item =
index.IsArray ?
input.VectorIndexing(indexers, indexpos, index, isAssign, isMemoryMapped) :
input.SimpleIndex(indexers, indexpos, index, isAssign, isMemoryMapped);
result.AddWithNoUpdate(item);
}
result.UpdateInfo();
return result;
}
/// <summary>
///
/// </summary>
/// <param name="indexers">List containing all of the indexes</param>
/// <param name="indexpos"></param>
/// <param name="currentIdx">Array containing the current indexes</param>
/// <returns></returns>
public static AType VectorIndexing(this AType input, List <AType> indexers, int indexpos, AType currentIdx, bool isAssign, bool isMemoryMapped)
{
if (currentIdx.Length == 0)
{
// A Null item found!, select all of the current items
for (int i = 0; i < input.Length; i++)
{
currentIdx.Add(AInteger.Create(i));
}
}
// Create an array for the results
AType result = AArray.Create(input.Type);
// Iterate over the indexes
foreach (AType index in currentIdx)
{
AType item =
index.IsArray ?
input.VectorIndexing(indexers, indexpos, index, isAssign, isMemoryMapped) :
input.SimpleIndex(indexers, indexpos, index, isAssign, isMemoryMapped);
result.AddWithNoUpdate(item);
}
result.UpdateInfo();
return(result);
}
private AType ConvertNumberToChar(AType argument)
{
AType result = AArray.Create(ATypes.AChar);
if (argument.IsArray)
{
foreach (AType item in argument)
{
AType convertedItem = ConvertNumberToChar(item);
if (item.IsArray)
{
result.Add(convertedItem);
}
else
{
result.AddRange(convertedItem);
}
}
}
else
{
byte[] bytes = (argument.Type == ATypes.AFloat)
? BitConverter.GetBytes(argument.asFloat)
: BitConverter.GetBytes(argument.asInteger);
result.AddRange(bytes.Select <byte, AType>(item => AChar.Create((char)item)));
}
return(result);
}
private static AType ArrayInput(AType input)
{
AType result;
AType titles = AArray.Create(ATypes.ANull);
AType elements = AArray.Create(ATypes.ANull);
int odd = input.Length % 2;
for (int i = 0; i < input.Length - odd; i += 2)
{
AType key = MonadicFunctionInstance.Disclose.Execute(input[i]);
AType value = input[i + 1];
if (key.Type != ATypes.ASymbol)
{
throw new Error.Domain("_alsf");
}
if (!value.IsBox)
{
value = ABox.Create(value);
}
titles.Add(key);
elements.Add(value);
}
AType lastItem;
if (input.Length == 0)
{
lastItem = input;
}
else
{
lastItem = MonadicFunctionInstance.Disclose.Execute(input[input.Length - 1]);
}
if (odd != 0 && lastItem.Type != ATypes.ANull)
{
titles.Add(lastItem);
elements.Add(ABox.Create(AArray.Create(ATypes.ANull)));
}
result = AArray.Create(ATypes.AType, ABox.Create(titles), ABox.Create(elements));
return(result);
}
public AType WhatIs(int handle)
{
AType result = AArray.Create(ATypes.ASymbol);
AipcConnection connection = Lookup(handle);
if (connection == null)
{
result.Add(ASymbol.Create(""));
result.Add(ASymbol.Create(""));
}
else
{
result.Add(ASymbol.Create(connection.ConnectionAttributes.IsListener ? "listener" : "connector"));
result.Add(connection.ConnectionAttributes.Protocol);
}
return(result);
}
private AType VectorInverse(AType argument)
{
AType result = AArray.Create(ATypes.AFloat);
double sqrmagnitude = argument.Sum(item => item.asFloat * item.asFloat);
for (int i = 0; i < argument.Length; i++)
{
result.Add(AFloat.Create(argument[i].asFloat / sqrmagnitude));
}
return(result);
}
public AType Roster()
{
AType result = AArray.Create(ATypes.AInteger);
lock (mutex)
{
foreach (var item in this.roster)
{
result.Add(AInteger.Create(item.Key));
}
}
return(result);
}
/// <summary>
/// Creates an AArray from the input string with AChar type or
/// a simple AChar if the input is of length 1
/// </summary>
/// <param name="text">input string</param>
/// <returns>AArray of AChars or a single AChar</returns>
public static AType BuildString(string text)
{
if (text.Length == 1)
{
return(AChar.Create(text[0]));
}
AType characterArray = AArray.Create(ATypes.AChar);
foreach (char ch in text)
{
characterArray.Add(AChar.Create(ch));
}
characterArray.UpdateInfo();
return(characterArray);
}
internal static AType Loadfile(Aplus environment, AType filename)
{
string fileName = filename.ToString();
if (filename.Type != ATypes.AChar)
{
throw new Error.Type("_loadfile");
}
if (!File.Exists(fileName))
{
throw new Error.Invalid("_loadfile");
}
AType result = AArray.Create(ATypes.AChar);
using (FileStream fileStream = new FileStream(fileName, FileMode.Open))
{
int blockReadSize = 5 * 1024; // 5 KiB
long totalSize = fileStream.Length;
int readLength = blockReadSize < totalSize ? blockReadSize : (int)totalSize;
byte[] filePartialContent = new byte[readLength];
int sum = 0; // total number of bytes read
int count; // current number of bytes read
// read until Read method returns 0 (end of the stream has been reached)
while ((count = fileStream.Read(filePartialContent, 0, readLength)) > 0)
{
sum += count; // sum is a buffer offset for next reading
// build the array from the bytes that was read
for (int i = 0; i < count; i++)
{
result.Add(AChar.Create((char)filePartialContent[i]));
}
// calculate the next size of the read block
long leftover = totalSize - sum;
readLength = blockReadSize < leftover ? blockReadSize : (int)leftover;
}
return(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());
}
}
protected override AType ConvertToAObject(byte[] messageByte)
{
AType message = AArray.Create(ATypes.AChar);
foreach (byte b in messageByte)
{
try
{
message.Add(AChar.Create((char)b));
}
catch (InvalidCastException)
{
throw new ADAPException(ADAPExceptionType.Import);
}
}
return message;
}
protected override AType ConvertToAObject(byte[] message)
{
AType result = Utils.ANull();
for (int i = 0; i < message.Length; i++)
{
try
{
result.Add(AChar.Create((char)message[i]));
}
catch (InvalidCastException)
{
throw new ADAPException(ADAPExceptionType.Import);
}
}
return(result);
}
internal AType ToAType()
{
AType result = AArray.Create(ATypes.AFloat);
for (int i = 0; i < this.Rows; i++)
{
AType row = AArray.Create(ATypes.AFloat);
for (int j = 0; j < this.Columns; j++)
{
row.Add(AFloat.Create(this[i, j]));
}
result.Add(row);
}
return(result);
}
public override AType Execute(AType argument, Aplus environment = null)
{
AType result = AArray.Create(argument.Type);
if (argument.IsArray)
{
ExtractItems(argument, result);
result.Length = argument.Shape.Product();
result.Shape = new List <int>()
{
result.Length
};
result.Rank = 1;
}
else
{
result.Add(argument);
}
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);
}
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 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 static AType CalculateIndexes(AType value, AType target, Aplus environment, out AType indexes)
{
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");
}
int currentLength = target.Length;
if (target.Shape.SequenceEqual<int>(value.Shape))
{
indexes = AArray.Create(ATypes.AInteger);
for (int i = 0; i < value.Length; i++)
{
indexes.Add(AInteger.Create(currentLength));
currentLength++;
}
}
else if (target.Shape.GetRange(1, target.Shape.Count - 1).SequenceEqual<int>(value.Shape))
{
indexes = AInteger.Create(currentLength);
currentLength++;
}
else if (value.Rank == 0)
{
indexes = AInteger.Create(currentLength);
currentLength++;
}
else if (value.Rank == target.Rank)
{
indexes = AArray.Create(ATypes.AInteger);
for (int i = 0; i < value.Length; i++)
{
indexes.Add(AInteger.Create(currentLength));
currentLength++;
}
}
else
{
throw new Error.Length("assign");
}
indexes = ABox.Create(indexes);
return value;
}
/// <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);
}