public void TestModulo()
{
Assert.AreEqual(AtomHelper.NumberFromComplex(1), Eval("(modulo 13 4)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(3), Eval("(modulo -13 4)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-3), Eval("(modulo 13 -4)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-1), Eval("(modulo -13 -4)"));
}
protected ISExpression Continuation(Stack <IFrame> s, ISchemeVM vm)
{
var v = AtomHelper.SymbolFromString("v");
return(Closure(new NuateInstruction(s, v), AtomHelper.CreateEnvironment(),
AtomHelper.CreateList(v)));
}
public void TestScripts()
{
var path = Path.GetDirectoryName(typeof(ScriptTests).GetTypeInfo().Assembly.Location);
var tests = File.ReadAllText(Path.Combine(path, "tests.scm"));
var def = AtomHelper.CreateList(
AtomHelper.SymbolFromString("define"),
AtomHelper.SymbolFromString("test"),
AtomHelper.CreateList(AtomHelper.SymbolFromString("lambda"), AtomHelper.Nil, AtomHelper.CreateProcedure("test", Test, false))
);
Eval(def);
var errors = "";
var exprs = EvalAll(tests).ToArray();
for (var i = 0; i < exprs.Count(); i++)
{
var result = exprs[i];
if (result == null)
{
continue;
}
if (result.IsString())
{
errors += result.String() + "\n";
}
}
if (errors != "")
{
Assert.Fail(errors);
}
}
//*** Protein Ingredients ****//
public void AddProteinIngredientToCPUBuffer(Ingredient ingredient, List <Atom> atoms, List <List <Vector4> > clusterLevels = null)
{
if (SceneHierarchy.Contains(ingredient.path))
{
throw new Exception("Invalid protein path: " + ingredient.path);
}
if (ProteinIngredientNames.Contains(ingredient.path))
{
throw new Exception("Invalid protein path: " + ingredient.path);
}
if (clusterLevels != null)
{
if (NumLodLevels != 0 && NumLodLevels != clusterLevels.Count)
{
throw new Exception("Uneven cluster levels number: " + ingredient.path);
}
}
AddIngredientToHierarchy(ingredient.path);
ProteinIngredientNames.Add(ingredient.path);
CPUBuffers.Get.ProteinToggleFlags.Add(1);
CPUBuffers.Get.ProteinIngredientsRadii.Add(AtomHelper.ComputeRadius(atoms));
CPUBuffers.Get.ProteinAtomCount.Add(atoms.Count);
CPUBuffers.Get.ProteinAtomStart.Add(CPUBuffers.Get.ProteinAtoms.Count);
for (var i = 0; i < atoms.Count; i++)
{
var helix = atoms[i].helixIndex >= 0;
var sheet = atoms[i].sheetIndex >= 0;
//if (helix && sheet) throw new Exception("Da fuk just happened");
var secondaryStructure = 0;
secondaryStructure = (helix) ? atoms[i].helixIndex : secondaryStructure;
secondaryStructure = (sheet) ? -atoms[i].sheetIndex : secondaryStructure;
//if (sheet)
//{
// int a = 0;
//}
CPUBuffers.Get.ProteinAtoms.Add(new Vector4(atoms[i].position.x, atoms[i].position.y, atoms[i].position.z, atoms[i].radius));
CPUBuffers.Get.ProteinAtomInfo.Add(new Vector4(secondaryStructure, atoms[i].symbolId, atoms[i].residueId, atoms[i].chainId));
CPUBuffers.Get.ProteinAtomInfo2.Add(new Vector4(atoms[i].helixIndex, atoms[i].nbHelicesPerChain, atoms[i].sheetIndex, atoms[i].nbSheetsPerChain));
}
if (clusterLevels != null)
{
NumLodLevels = clusterLevels.Count;
foreach (var level in clusterLevels)
{
CPUBuffers.Get.ProteinAtomClusterCount.Add(level.Count);
CPUBuffers.Get.ProteinAtomClusterStart.Add(CPUBuffers.Get.ProteinAtomClusters.Count);
CPUBuffers.Get.ProteinAtomClusters.AddRange(level);
}
}
}
public override ISExpression Compile(ISchemeVM vm, ISExpression expr)
{
if (!expr.IsList() || expr == AtomHelper.Nil)
{
return(expr);
}
var c = (Cons)expr;
var op = c.Get(0);
if (op == CompilerConstants.If)
{
var count = c.ListCount();
if (count < 3 || count > 4)
{
ThrowErr("if", "invalid number of arguments", expr.String());
}
if (count == 3)
{
var test = Compile(vm, c.Get(1));
var then = Compile(vm, c.Get(2));
return(AtomHelper.CreateList(CompilerConstants.If, test, then, AtomHelper.Nil));
}
}
return(expr);
}
public override IInstruction Execute(ISchemeVM vm)
{
IEnvironment e = vm.E;
if (vm.A.IsClosure())
{
var c = vm.A as Closure;
if (c.Body.Name != "native")
{
if (c.Vars.IsSymbol())
{
e = Extend(vm.E, CreateMap(AtomHelper.CreateList(c.Vars), vm.R));
}
else if (c.Vars.IsList())
{
e = Extend(vm.E, CreateMap(c.Vars, vm.R));
}
else if (!c.Vars.IsNil())
{
ThrowErr("apply", "attempted application with invalid binding parameter", $"parameter vars: {c.Vars.String()}");
}
}
SetE(vm, e);
return(c.Body);
}
ThrowErr("apply", "attempted application of non-function", $"({vm.A.String()})");
return(null);
}
private ISExpression RewriteLetStar(ISchemeVM vm, ISExpression expr)
{
var x = expr as Cons;
var c = x.ListCount();
if (c < 3)
{
ThrowErr("let*", "invalid number of arguments", expr.String());
}
var bindings = x.Get(1);
var body = x.Get(2);
if (!bindings.IsList())
{
ThrowErr("let*", "invalid argument 'bindings'", expr.String());
}
if (bindings == AtomHelper.Nil || bindings.GetUnsafeCdr() == AtomHelper.Nil)
{
return(RewriteLet(vm, expr));
}
var first = bindings.GetUnsafeCar();
var remain = bindings.GetUnsafeCdr();
return(RewriteLet(vm, AtomHelper.CreateList(CompilerConstants.Let, AtomHelper.CreateList(Compile(vm, first)),
AtomHelper.CreateList(CompilerConstants.LetStar, Compile(vm, remain), Compile(vm, body)))));
}
public void TestRemainder()
{
Assert.AreEqual(AtomHelper.NumberFromComplex(1), Eval("(remainder 13 4)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-1), Eval("(remainder -13 4)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(1), Eval("(remainder 13 -4)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-1), Eval("(remainder -13 -4)"));
}
public override object VisitVector([NotNull] SchemeParser.VectorContext context)
{
var elements = context.datum().Select(d => Visit(d))
.Cast <ISExpression>();
return(AtomHelper.CreateVector(elements));
}
public void TestMinMax()
{
Assert.AreEqual(AtomHelper.NumberFromComplex(3), Eval("(max 0 1 2 3)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(3), Eval("(max -1 1 2 3)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(0), Eval("(min 0 1 2 3)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-1), Eval("(min -1 1 2 3)"));
}
public void AddProteinIngredient(string path, Bounds bounds, List <Vector4> atomSpheres, Color color,
List <float> clusterLevels = null,
bool nolod = false)
{
if (SceneHierarchy.Contains(path))
{
throw new Exception("Invalid protein path: " + path);
}
if (ProteinIngredientNames.Contains(path))
{
throw new Exception("Invalid protein path: " + path);
}
if (clusterLevels != null)
{
if (NumLodLevels != 0 && NumLodLevels != clusterLevels.Count)
{
throw new Exception("Uneven cluster levels number: " + path);
}
}
if (color == null)
{
color = MyUtility.GetRandomColor();
}
AddIngredientToHierarchy(path);
ProteinColors.Add(color);
ProteinToggleFlags.Add(1);
ProteinIngredientNames.Add(path);
ProteinRadii.Add(AtomHelper.ComputeRadius(atomSpheres));
ProteinAtomCount.Add(atomSpheres.Count);
ProteinAtomStart.Add(ProteinAtoms.Count);
ProteinAtoms.AddRange(atomSpheres);
if (clusterLevels != null)
{
NumLodLevels = clusterLevels.Count;
foreach (var level in clusterLevels)
{
var numClusters = Math.Max(atomSpheres.Count * level, 5);
List <Vector4> clusterSpheres;
if (!nolod)
{
clusterSpheres = KMeansClustering.GetClusters(atomSpheres, (int)numClusters);
}
else
{
clusterSpheres = new List <Vector4>(atomSpheres);
}
ProteinAtomClusterCount.Add(clusterSpheres.Count);
ProteinAtomClusterStart.Add(ProteinAtomClusters.Count);
ProteinAtomClusters.AddRange(clusterSpheres);
}
}
}
public override object VisitQuote([NotNull] SchemeParser.QuoteContext context)
{
var expr = (ISExpression)Visit(context.datum());
return(AtomHelper.CreateCons(
AtomHelper.SymbolFromString("quote"),
AtomHelper.CreateCons(expr, AtomHelper.Nil)));
}
public void TestCeiling()
{
Assert.AreEqual(AtomHelper.NumberFromComplex(2), Eval("(ceiling 1.5)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(1), Eval("(ceiling 1)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(2001), Eval("(ceiling 2000.00001)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(0), Eval("(ceiling -0.9)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-99), Eval("(ceiling -99.5)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-100), Eval("(ceiling -100)"));
}
private object CreateList(SchemeParser.DatumContext[] elements)
{
if (elements.Length == 0)
{
return(AtomHelper.Nil);
}
return(AtomHelper.CreateCons((ISExpression)Visit(elements.First()), (ISExpression)CreateList(elements.Skip(1).ToArray())));
}
public void TestTruncate()
{
Assert.AreEqual(AtomHelper.NumberFromComplex(1), Eval("(truncate 1.5)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(1), Eval("(truncate 1)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(2000), Eval("(truncate 2000.00001)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(0), Eval("(truncate -0.9)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-99), Eval("(truncate -99.5)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-100), Eval("(truncate -100)"));
}
public void TestFloor()
{
Assert.AreEqual(AtomHelper.NumberFromComplex(1), Eval("(floor 1.5)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(1), Eval("(floor 1)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(2000), Eval("(floor 2000.00001)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-1), Eval("(floor -0.9)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-100), Eval("(floor -99.5)"));
Assert.AreEqual(AtomHelper.NumberFromComplex(-100), Eval("(floor -100)"));
}
public static ISExpression Modulo(IEnumerable <ISExpression> args)
{
var array = args.Cast <NumberAtom>().ToArray();
var a = array[0].Val;
var b = array[1].Val;
var c = (a.RealModulo(b) + b).RealModulo(b);
return(AtomHelper.NumberFromComplex(c));
}
public static ISExpression Remainder(IEnumerable <ISExpression> args)
{
var array = args.Cast <NumberAtom>().ToArray();
var a = array[0];
var b = array[1];
var c = a.Val.RealModulo(b.Val);
return(AtomHelper.NumberFromComplex(c));
}
private async void InitializeSDK()
{
if (String.IsNullOrEmpty(SecretKey))
{
Messages.ShowMessage(Messages.SecretKeyRquired);
return;
}
IsSDKInitializing = true;
var countries = new List <Country>();
var protocols = new List <Protocol>();
await Task.Factory.StartNew(() =>
{
//Can be initialized using this
atomManagerInstance = AtomManager.Initialize(SecretKey);
//Or this
//var atomConfig = new AtomConfiguration(SecretKey);
//atomManagerInstance = AtomManager.Initialize(atomConfig);
atomManagerInstance.Connected += AtomManagerInstance_Connected;
atomManagerInstance.DialError += AtomManagerInstance_DialError;
atomManagerInstance.Disconnected += AtomManagerInstance_Disconnected;
atomManagerInstance.StateChanged += AtomManagerInstance_StateChanged;
atomManagerInstance.Redialing += AtomManagerInstance_Redialing;
atomManagerInstance.OnUnableToAccessInternet += AtomManagerInstance_OnUnableToAccessInternet;
atomManagerInstance.SDKAlreadyInitialized += AtomManagerInstance_SDKAlreadyInitialized;
atomManagerInstance.AutoRedialOnConnectionDrop = true;
//To get countries
try
{
countries = atomManagerInstance.GetCountries();
}
catch { }
//To get protocols
try
{
protocols = atomManagerInstance.GetProtocols();
}
catch { }
//AtomHelper lets you use the functionality of above created instance in all usercontrols and pages
AtomHelper.SetAtomManagerInstance(atomManagerInstance);
});
ConnectionWithDedicatedIP.Initialize(protocols, countries);
ConnectionWithParams.Initialize(protocols, countries);
IsSDKInitializing = false;
ISSDKInitialized = true;
IsConnDisconnAllowed = true;
}
private bool StartConnection()
{
VPNProperties properties;
try
{
if (UseDedicatedIP)
{
if (!CanConnect)
{
Messages.ShowMessage(Messages.HostAndProtocolRequired);
return(false);
}
properties = new VPNProperties(Host, PrimaryProtocol);
}
else if (UseSmartConnect)
{
List <SmartConnectTag> smartConnectTagsList = new List <SmartConnectTag>();
if (SmartConnectTagsListBox?.SelectedItems?.Count > 0)
{
foreach (var item in SmartConnectTagsListBox.SelectedItems)
{
smartConnectTagsList.Add((SmartConnectTag)item);
}
}
bool isValidate = AtomHelper.AtomManagerInstance.IsSmartConnectAvailableOnProtocol(PrimaryProtocol, smartConnectTagsList);
if (isValidate)
{
properties = new VPNProperties(PrimaryProtocol, smartConnectTagsList?.Count > 0 ? smartConnectTagsList : null);
}
else
{
ParentWindow.ConnectionDialog += "No SmartConnect DNS available for dialing or you are not permitted to this resource";
return(false);
}
}
else
{
return(false);
}
properties.DoCheckInternetConnectivity = true;
AtomHelper.Connect(properties);
return(true);
}
catch (Exception ex)
{
ParentWindow.ConnectionDialog += ex.Message;
return(false);
}
}
public void TestLocs()
{
VM.E.DefineHere(AtomHelper.SymbolFromString("a"), Eval("(1 . 2)"));
VM.E.DefineHere(AtomHelper.SymbolFromString("b"), Eval("\"test\""));
VM.E.DefineHere(AtomHelper.SymbolFromString("c"), Eval("#(1 2)"));
Assert.AreEqual(AtomHelper.True, Eval("(eqv? a a)"));
Assert.AreEqual(AtomHelper.True, Eval("(eqv? b b)"));
Assert.AreEqual(AtomHelper.True, Eval("(eqv? c c)"));
Assert.AreEqual(AtomHelper.True, Eval("(eqv? + +)"));
Assert.AreEqual(AtomHelper.False, Eval("(eqv? (1 . 2) (1 . 2))"));
}
private static NumberAtom Multiply(this IEnumerable <NumberAtom> ee)
{
Complex m = Complex.CreateExactReal(1);
foreach (var e in ee)
{
m = m * e.Val;
}
return(AtomHelper.NumberFromComplex(m));
}
private static NumberAtom Sum(this IEnumerable <NumberAtom> ee)
{
Complex sum = Complex.CreateExactReal(0);
foreach (var e in ee)
{
sum = sum + e.Val;
}
return(AtomHelper.NumberFromComplex(sum));
}
public static ISExpression Lcm(IEnumerable <ISExpression> args)
{
if (args.Count() == 0)
{
return(AtomHelper.NumberFromComplex(1));
}
var nums = args.Cast <NumberAtom>().Select(a => a.Val).ToArray();
return(AtomHelper.NumberFromComplex(LCM(nums).RealAbs()));
}
public static ISExpression Gcd(IEnumerable <ISExpression> args)
{
if (!args.Any())
{
return(AtomHelper.NumberFromComplex(0));
}
var nums = args.Cast <NumberAtom>().Select(a => a.Val).ToArray();
return(AtomHelper.NumberFromComplex(GCD(nums).RealAbs()));
}
private void Cancel()
{
try
{
AtomHelper.Cancel();
}
catch (Exception ex)
{
ConnectionDialog += $"{ex.Message}";
}
}
public override ISExpression Compile(ISchemeVM vm, string i)
{
var exprs = ParserHelpers.Parse(i);
if (exprs.Length == 1)
{
return(exprs[0]);
}
return(AtomHelper.CreateCons(CompilerConstants.Begin, exprs.Unflatten()));
}
public override IInstruction Execute(ISchemeVM vm)
{
var e = AtomHelper.CreateEnvironment();
if (Populate)
{
AtomHelper.PopulateEnvironment(e, vm);
}
SetA(vm, e);
return(Next);
}
public void Reset(bool env = true)
{
A = AtomHelper.Nil;
R = new Stack <ISExpression>();
S = new Stack <IFrame>();
if (env)
{
E = AtomHelper.CreateEnvironment();
AtomHelper.PopulateEnvironment(E, this);
}
}
private bool StartConnection()
{
if (!CanConnect)
{
Messages.ShowMessage(Messages.PSKRequired);
return(false);
}
var properties = new VPNProperties(PSK);
properties.DoCheckInternetConnectivity = true;
AtomHelper.Connect(properties);
return(true);
}
