public void PartitionIntegerList2MixedNestedArray()
{
ScriptScope scope = this.engine.CreateScope();
AType f = this.engine.Execute <AType>("f := <{+}", scope);
AType expected = AArray.Create(
ATypes.ABox,
ABox.Create(
AArray.Create(
ATypes.ASymbol,
ASymbol.Create("a"),
ABox.Create(AInteger.Create(4))
)
),
ABox.Create(
AArray.Create(
ATypes.AFunc,
f
)
),
ABox.Create(Utils.ANull())
);
AType result = this.engine.Execute <AType>("2 2 1 bag `a , (< 4) , f", scope);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
Assert.AreEqual(expected, result);
}
public void ComplexAppendScalar()
{
AType expected = AArray.Create(ATypes.ABox,
ABox.Create(
AArray.Create(ATypes.AInteger, AInteger.Create(0), AInteger.Create(0), AInteger.Create(-3))
),
ABox.Create(
AArray.Create(ATypes.AInteger, AInteger.Create(2), AInteger.Create(2))
)
);
ScriptScope scope = this.engine.CreateScope();
scope.SetVariable(".a",
AArray.Create(
ATypes.ABox,
ABox.Create(AArray.Create(ATypes.AInteger, AInteger.Create(0), AInteger.Create(0))),
ABox.Create(AArray.Create(ATypes.AInteger, AInteger.Create(2), AInteger.Create(2)))
)
);
this.engine.Execute <AType>("(0 pick a)[,] := -3", scope);
Assert.AreEqual(expected, scope.GetVariable <AType>(".a"), "Incorrect value assigned");
}
public void IdentityBoxUni()
{
AType expected = ABox.Create(AArray.Create(ATypes.AInteger, AInteger.Create(1), AInteger.Create(2), AInteger.Create(3)));
AType result = this.engineUni.Execute <AType>("+ <1 2 3");
Assert.AreEqual(expected, result);
}
public void SelectiveAssignment()
{
AType expected =
Helpers.BuildStrand(
new AType[]
{
ASymbol.Create("b"),
ASymbol.Create("ctx"),
Utils.ANull(),
AInteger.Create(0),
ABox.Create(AArray.Create(ATypes.ASymbol, ASymbol.Create("Scalar"), ASymbol.Create("Vector"), ASymbol.Create("Matrix"))),
Helpers.BuildString("static")
}
);
ScriptScope scope = this.engine.CreateScope();
this.engine.Execute("$cx ctx", scope);
this.engine.Execute("b := (`scalar `vector `matrix; (3.14; 'abcdef'; iota 3 2))", scope);
this.engine.Execute("cbf{a;b;c;d;e;f}:{.result := (a;b;c;d;e;f)}", scope);
this.engine.Execute("_scb{`b;(cbf;'static')}", scope);
this.engine.Execute("(1 0 /b) := <`Scalar `Vector `Matrix", scope);
Assert.AreEqual(expected.CompareInfos(scope.GetVariable <AType>(".result")), InfoResult.OK);
Assert.AreEqual(expected, scope.GetVariable <AType>(".result"));
}
public void RestructureIntegerList2NestedArray()
{
ScriptScope scope = this.engine.CreateScope();
AType f = this.engine.Execute <AType>("f := {+}", scope);
AType expected = AArray.Create(
ATypes.ASymbol,
AArray.Create(
ATypes.ASymbol,
ASymbol.Create("a"),
ASymbol.Create("b")
),
AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(3)),
ABox.Create(AInteger.Create(4))
),
AArray.Create(
ATypes.AFunc,
ABox.Create(f),
ABox.Create(AInteger.Create(6))
)
);
AType result = this.engine.Execute <AType>("2 ! (`a`b , (3;4)) , (f;6)", scope);
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void TransposeAxisIntegerList2NestedMixedArray()
{
ScriptScope scope = this.engine.CreateScope();
AType f = this.engine.Execute <AType>("f := <{+}", scope);
AType expected = AArray.Create(
ATypes.ASymbol,
AArray.Create(
ATypes.ASymbol,
ASymbol.Create("a"),
f,
ABox.Create(AInteger.Create(2))
),
AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(4)),
ASymbol.Create("b"),
f
)
);
AType result = this.engine.Execute <AType>("1 0 flip 3 2 rho `a , (<4) , f , `b , (<2) , f", scope);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
Assert.AreEqual(expected, result);
}
public void ExpandIntegerList2NestedMixedMatrix2()
{
ScriptScope scope = this.engine.CreateScope();
AType f = this.engine.Execute <AType>("f := <{+}", scope);
AType expected = AArray.Create(
ATypes.ASymbol,
AArray.Create(
ATypes.ASymbol,
ASymbol.Create("a"),
ASymbol.Create(""),
ABox.Create(AInteger.Create(4))
),
AArray.Create(
ATypes.AFunc,
f,
ABox.Create(Utils.ANull()),
ASymbol.Create("b")
),
AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(2)),
ABox.Create(Utils.ANull()),
f
)
);
AType result = this.engine.Execute <AType>("1 0 1 \\@ 1 1 rtack 3 2 rho `a , (<4) , f , `b , (<2) , f", scope);
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void RestrucutreNegativeInteger2Strand()
{
AType expected = AArray.Create(
ATypes.ABox,
AArray.Create(
ATypes.AInteger,
ABox.Create(AInteger.Create(4)),
ABox.Create(AInteger.Create(5))
),
AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(5)),
ABox.Create(AInteger.Create(1))
),
AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(1)),
ABox.Create(AInteger.Create(4))
)
);
AType result = this.engine.Execute <AType>("-2 ! (4;5;1;4)");
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void ExpandIntegerVector2NestedMixedArray1()
{
ScriptScope scope = this.engine.CreateScope();
AType f = this.engine.Execute <AType>("f := <{+}", scope);
AType expected = AArray.Create(
ATypes.ASymbol,
AArray.Create(
ATypes.ASymbol,
ASymbol.Create("a"),
ABox.Create(AInteger.Create(4))
),
AArray.Create(
ATypes.ASymbol,
ASymbol.Create(""),
ASymbol.Create("")
),
AArray.Create(
ATypes.AFunc,
f,
ASymbol.Create("b")
),
AArray.Create(
ATypes.ASymbol,
ASymbol.Create(""),
ASymbol.Create("")
)
);
AType result = this.engine.Execute <AType>("1 0 1 0 \\ 2 2 rho `a , (<4) , f , `b", scope);
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public override AType Read()
{
AType message;
if (this.AipcAttributes.ReadPause)
{
return(Utils.ANull());
}
if (AipcAttributes.BurstMode)
{
message = AArray.Create(ATypes.ABox);
while (connectionSocket.Poll(1, SelectMode.SelectRead))
{
message.Add(ABox.Create(DoRead()));
}
}
else
{
message = DoRead();
}
this.MakeCallback("read", message);
return(message);
}
public void EachUseDyadicNonScalarFunctionStrand2Strand()
{
AType expected = AArray.Create(
ATypes.ABox,
ABox.Create(
AArray.Create(ATypes.AInteger, AInteger.Create(0), AInteger.Create(1))
),
ABox.Create(
AArray.Create(
ATypes.AInteger,
AArray.Create(
ATypes.AInteger,
AInteger.Create(8),
AInteger.Create(9),
AInteger.Create(10),
AInteger.Create(11)
)
)
)
);
AType result = this.engine.Execute <AType>("(2;-1) take each (iota 4; iota 3 4)");
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void MultipleEach2()
{
AType expected = AArray.Create(
ATypes.ABox,
ABox.Create(ABox.Create(ABox.Create(AInteger.Create(-4)))),
ABox.Create(
AArray.Create(
ATypes.ABox,
ABox.Create(ABox.Create(AInteger.Create(-7))),
ABox.Create(
AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(-3)),
ABox.Create(AInteger.Create(-7))
)
)
)
)
);
ScriptScope scope = this.engine.CreateScope();
this.engine.Execute <AType>("a := (((- each)each)each)", scope);
AType result = this.engine.Execute <AType>("a{(4;(7;(3;7)))}", scope);
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void AlsfExample()
{
AType titles = AArray.Create(ATypes.ASymbol,
ASymbol.Create("a"),
ASymbol.Create("b"),
ASymbol.Create("c")
);
AType content = AArray.Create(ATypes.ABox,
ABox.Create(AInteger.Create(1)),
ABox.Create(AInteger.Create(2)),
ABox.Create(AArray.Create(
ATypes.AInteger,
AInteger.Create(3),
AInteger.Create(4),
AInteger.Create(5)
)
)
);
AType expected =
AArray.Create(ATypes.ABox, ABox.Create(titles), ABox.Create(content));
AType result = this.engine.Execute <AType>(" _alsf{(`a;1;`b;2;`c;3 4 5)}");
Assert.AreEqual(expected, result);
}
public void AppendAssignPresetCallback()
{
AType expected =
Helpers.BuildStrand(
new AType[]
{
ASymbol.Create("b"),
ASymbol.Create(""),
Utils.ANull(),
ABox.Create(AArray.Create(ATypes.AInteger, AInteger.Create(2), AInteger.Create(3))),
AArray.Create(ATypes.AInteger, AInteger.Create(3), AInteger.Create(4)),
Helpers.BuildString("static")
}
);
AType expectedValue =
AArray.Create(ATypes.AInteger, AInteger.Create(1), AInteger.Create(2), AInteger.Create(3), AInteger.Create(4));
ScriptScope scope = this.engine.CreateScope();
this.engine.Execute("b := 1 2", scope);
this.engine.Execute("cbf{a;b;c;d;e;f}:{.result := (a;b;c;d;e;f); := b}", scope);
this.engine.Execute("_spcb{`b;(cbf;'static')}", scope);
this.engine.Execute("b[,] := 3 4", scope);
Assert.AreEqual(expected, scope.GetVariable <AType>(".result"));
Assert.AreEqual(expectedValue, scope.GetVariable <AType>(".b"));
}
public void ProtectedExecute()
{
ScriptScope scope = this.engine.CreateScope();
AType expected = ABox.Create(AInteger.Create(20));
AType result = this.engine.Execute <AType>("1 eval '10 + 10'", scope);
Assert.AreEqual <AType>(expected, result, "Incorrect result returned");
}
/// <summary>
/// Creates a result for the SyncRead/SyncWrite if it succeed
/// </summary>
protected AType SyncFillOk(AType message, bool isRead)
{
return(AArray.Create(
ATypes.ABox,
ABox.Create(ASymbol.Create("OK")),
ABox.Create(message),
ABox.Create(isRead ? Utils.ANull() : AipcAttributes.GetWriteQueue())
));
}
public void ComplexEach()
{
AType expected = ABox.Create(AInteger.Create(-5));
AType result = this.engine.Execute <AType>("(if 3 (-) else (*)) each 5");
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void PartitionInteger2Strand()
{
AType expected = ABox.Create(AArray.Create(ATypes.ANull));
AType result = this.engine.Execute <AType>("0 bag (4;3;4)");
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
Assert.AreEqual(expected, result);
}
public void MultipleFloatEnclose()
{
AType expected = ABox.Create(ABox.Create(AFloat.Create(2.2)));
AType result = this.engine.Execute <AType>("< < 2.2");
Assert.AreEqual <AType>(expected, result, "Incorrect boxed value was created");
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void VectorEnclose()
{
AType expected = ABox.Create(AArray.Create(ATypes.AInteger, AInteger.Create(1), AInteger.Create(2)));
AType result = this.engine.Execute <AType>("< 1 2");
Assert.AreEqual <AType>(expected, result, "Incorrect boxed value was created");
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void SimpleEncloseUni()
{
AType expected = ABox.Create(AInteger.Create(1));
AType result = this.engineUni.Execute <AType>("< 1");
Assert.AreEqual <AType>(expected, result, "Incorrect boxed value was created");
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
private AType Compute(AType inputItems, PartitionJobInfo info)
{
// the left side is equal with 0, then the result is Enclosed null
if (info.PartitionVector.Length == 1 && info.PartitionVector[0] == 0)
{
return(CreateEnclosedNull(inputItems));
}
// the result is a nested vector
AType result = AArray.Create(ATypes.AType);
int counter = 0;
// enclose y[i] items from x array
//for (int i = 0; i < arguments.PartitionVector.Length; i++)
foreach (int partitionNumber in info.PartitionVector)
{
AType item = AArray.Create(inputItems[counter].Type);
for (int j = 0; j < partitionNumber; j++)
{
item.AddWithNoUpdate(inputItems[counter]);
counter++;
}
item.Length = partitionNumber;
item.Shape = new List <int>()
{
partitionNumber
};
if (inputItems.Rank > 1)
{
item.Shape.AddRange(inputItems.Shape.GetRange(1, inputItems.Shape.Count - 1));
}
item.Rank = inputItems.Rank;
result.AddWithNoUpdate(ABox.Create(item));
}
// add the remainder Enclosed null
for (int i = 0; i < info.Remainder; i++)
{
result.AddWithNoUpdate(CreateEnclosedNull(inputItems));
}
result.Length = info.PartitionVector.Length + info.Remainder;
result.Shape = new List <int>()
{
result.Length
};
result.Rank = 1;
result.Type = result.Length > 0 ? ATypes.ABox : ATypes.ANull;
return(result);
}
public void DropRestrictedWholweNumber2BoxList()
{
AType expected = AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(1))
);
AType result = this.engine.Execute <AType>("2.0000000000000000009 drop (3;5;1)");
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public override AType Execute(AType argument, Aplus environment = null)
{
AType result = ABox.Create(argument);
if (argument.Type == ATypes.AFunc && !argument.IsFunctionScalar)
{
result.Type = ATypes.AFunc;
}
return(result);
}
public void BoxArgument()
{
AType expected = AArray.Create(ATypes.ABox,
ABox.Create(AArray.Create(ATypes.ANull)),
ABox.Create(AArray.Create(ATypes.ANull))
);
AType result = this.engine.Execute <AType>("_alsf{<()}");
Assert.AreEqual(expected, result);
}
public void SymbolArgument()
{
AType expected = AArray.Create(ATypes.ABox,
ABox.Create(ASymbol.Create("symbol")),
ABox.Create(ABox.Create(Utils.ANull()))
);
AType result = this.engine.Execute <AType>("_alsf{`symbol}");
Assert.AreEqual(expected, result);
}
public void EachUseDyadicScalarFunctionScalar2OneElementArray()
{
AType expected = AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(12))
);
AType result = this.engine.Execute <AType>(" 3 ((* each)) 1 rho 4");
Assert.AreEqual(expected, result);
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
}
public void BoxofVectorMember()
{
ScriptScope scope = this.engine.CreateScope();
scope.SetVariable(".a", ABox.Create(AInteger.Create(1)));
scope.SetVariable(".b", ABox.Create(AArray.Create(ATypes.AInteger, AInteger.Create(1), AInteger.Create(2))));
AType result = this.engine.Execute <AType>("a in b", scope);
Assert.AreEqual <AType>(AInteger.Create(0), result, "Invalid value produced");
Assert.AreEqual(InfoResult.OK, result.CompareInfos(AInteger.Create(0)));
}
public void DroppedNullExample()
{
AType expected =
AArray.Create(ATypes.ABox,
ABox.Create(AArray.Create(ATypes.ASymbol, ASymbol.Create("a"))),
ABox.Create(AArray.Create(ATypes.ABox, ABox.Create(AInteger.Create(1))))
);
AType result = this.engine.Execute <AType>("_alsf{(`a;1;)}");
Assert.AreEqual(expected, result);
}
public void TakeInteger2Box()
{
AType expected = AArray.Create(
ATypes.ABox,
ABox.Create(AInteger.Create(1)),
ABox.Create(AInteger.Create(5))
);
AType result = this.engine.Execute <AType>("2 take (1;5;7)");
Assert.AreEqual(InfoResult.OK, result.CompareInfos(expected));
Assert.AreEqual(expected, result);
}
