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); }