public void LSystemSelectsRuleToApplyBasedOnConditional() { var globalParameters = new string[] { "global" }; LSystemState <float> state = new DefaultLSystemState("A(0)"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A(x) : x < global -> A(x + 1)", "A(x) : x >= global -> A(x - 1)", }, globalParameters); var defaultGlobalParams = new float[] { 3 }; Assert.AreEqual("A(0)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(1)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(2)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(3)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(2)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(3)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(2)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(3)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemAppliesReplacementBasedOnGlobalParameters() { var globalParameters = new string[] { "global" }; LSystemState <float> state = new DefaultLSystemState("A(1, 1)"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A(x, y) -> A((x + y) - global, x * y + global)", }, globalParameters); var defaultGlobalParams = new float[] { 5 }; Assert.AreEqual("A(1, 1)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(-3, 6)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(-2, -13)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(-20, 31)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(6, -615)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(-614, -3685)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemChecksContidionalBasedOnGlobalParameters() { var globalParameters = new string[] { "global" }; LSystemState <float> state = new DefaultLSystemState("A(0)"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A(x) : x < global -> A(x + 1)", }, globalParameters); var defaultGlobalParams = new float[] { 3 }; Assert.AreEqual("A(0)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(1)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(2)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(3)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(3)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(3)", state.currentSymbols.Data.ToString()); var nextGlobalParams = new float[] { 4 }; state = basicLSystem.StepSystem(state, nextGlobalParams); Assert.AreEqual("A(4)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemAppliesFlatContextualRules() { LSystemState <float> state = new DefaultLSystemState("B"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { " A -> AB", " B -> A", " A > A ->", "A < A -> B" }); Assert.AreEqual("B", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("AB", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABA", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABAAB", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABABA", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABAABAAB", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABABABA", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LinksSimpleDependencyAndExecutes() { var fileSystem = new InMemoryFileProvider(); fileSystem.RegisterFileWithIdentifier("root.lsystem", @" #axiom Y #iterations 10 #symbols XY #include lib.lsyslib (Exported->X) Y -> YX "); fileSystem.RegisterFileWithIdentifier("lib.lsyslib", @" #symbols AB #export Exported B B -> AB "); var linker = new FileLinker(fileSystem); var linkedFiles = linker.LinkFiles("root.lsystem"); using var system = linkedFiles.CompileSystem(); LSystemState <float> currentState = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); var X = linkedFiles.GetSymbol("root.lsystem", 'X'); var Y = linkedFiles.GetSymbol("root.lsystem", 'Y'); var A = linkedFiles.GetSymbol("lib.lsyslib", 'A'); var B = linkedFiles.GetSymbol("lib.lsyslib", 'B'); Assert.AreEqual(B, X); var symbolStringMapping = new Dictionary <int, char>() { { X, 'X' }, { Y, 'Y' }, { A, 'A' } }; /** * system equivalent with remapped symbol names: * Y -> YX * X -> AX */ Assert.AreEqual("Y", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("YX", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("YXAX", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("YXAXAAX", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("YXAXAAXAAAX", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState.currentSymbols.DisposeImmediate(); }
public void LinksBuiltinLibraryAndExecutes() { var builtins = new BuiltinLibraries(); builtins.Add(new DiffusionLibrary()); var fileSystem = new InMemoryFileProvider(builtins); fileSystem.RegisterFileWithIdentifier("root.lsystem", @" #axiom n(0.5, 0, 10)ST(3) #iterations 10 #symbols naFTS #include diffusion (Node->n) (Amount->a) T(x) : x > 0 -> n(.5, 0, 10)FT(x - 1) S -> a(3)S "); var linker = new FileLinker(fileSystem); var linkedFiles = linker.LinkFiles("root.lsystem"); using var system = linkedFiles.CompileSystem(); LSystemState <float> currentState = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); var n = linkedFiles.GetSymbol("root.lsystem", 'n'); var a = linkedFiles.GetSymbol("root.lsystem", 'a'); var F = linkedFiles.GetSymbol("root.lsystem", 'F'); var T = linkedFiles.GetSymbol("root.lsystem", 'T'); var S = linkedFiles.GetSymbol("root.lsystem", 'S'); var symbolStringMapping = new Dictionary <int, char>() { { n, 'n' }, { a, 'a' }, { F, 'F' }, { T, 'T' }, { S, 'S' }, }; Assert.AreEqual("n(0.5, 0, 10)ST(3)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.5, 0, 10)a(3)Sn(0.5, 0, 10)FT(2)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.5, 1.5, 10)aa(3)Sn(0.5, 1.5, 10)Fn(0.5, 0, 10)FT(1)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.5, 3, 10)aa(3)Sn(0.5, 2.25, 10)Fn(0.5, 0.75, 10)Fn(0.5, 0, 10)FT(0)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.5, 4.125, 10)aa(3)Sn(0.5, 3.375, 10)Fn(0.5, 1.125, 10)Fn(0.5, 0.375, 10)FT(0)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.5, 5.25, 10)aa(3)Sn(0.5, 4.125, 10)Fn(0.5, 1.875, 10)Fn(0.5, 0.75, 10)FT(0)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.5, 6.1875, 10)aa(3)Sn(0.5, 5.0625, 10)Fn(0.5, 2.4375, 10)Fn(0.5, 1.3125, 10)FT(0)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState.currentSymbols.DisposeImmediate(); }
public void LinksBuiltinLibraryWithCustomParameterAndExecutes() { var builtins = new BuiltinLibraries(); builtins.Add(new DiffusionLibrary()); var fileSystem = new InMemoryFileProvider(builtins); fileSystem.RegisterFileWithIdentifier("root.lsystem", @" #axiom n(0.25, 18, 20)Fn(0.25, 0, 20)Fn(0.25, 0, 20) #iterations 10 #symbols naF #define diffusionStepsPerStep 2 #include diffusion (Node->n) (Amount->a) "); var linker = new FileLinker(fileSystem); var linkedFiles = linker.LinkFiles("root.lsystem"); using var system = linkedFiles.CompileSystem(); LSystemState <float> currentState = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); var n = linkedFiles.GetSymbol("root.lsystem", 'n'); var a = linkedFiles.GetSymbol("root.lsystem", 'a'); var F = linkedFiles.GetSymbol("root.lsystem", 'F'); var symbolStringMapping = new Dictionary <int, char>() { { n, 'n' }, { a, 'a' }, { F, 'F' }, }; Assert.AreEqual("n(0.25, 18, 20)Fn(0.25, 0, 20)Fn(0.25, 0, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.25, 11.25, 20)Fn(0.25, 5.625, 20)Fn(0.25, 1.125, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.25, 8.859375, 20)Fn(0.25, 5.976563, 20)Fn(0.25, 3.164063, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.25, 7.602539, 20)Fn(0.25, 5.998535, 20)Fn(0.25, 4.398926, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.25, 6.901062, 20)Fn(0.25, 5.999908, 20)Fn(0.25, 5.09903, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.25, 6.506824, 20)Fn(0.25, 5.999994, 20)Fn(0.25, 5.493181, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.25, 6.285088, 20)Fn(0.25, 6, 20)Fn(0.25, 5.714913, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.25, 6.160362, 20)Fn(0.25, 6, 20)Fn(0.25, 5.839638, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("n(0.25, 6.090203, 20)Fn(0.25, 6, 20)Fn(0.25, 5.909797, 20)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState.currentSymbols.DisposeImmediate(); }
public void CompilesWithImmaturityMarkers() { var fileSystem = new InMemoryFileProvider(); fileSystem.RegisterFileWithIdentifier("root.lsystem", @" #axiom Y(2) #iterations 20 #symbols XY #immature Y Y(x) : x > 0 -> Y(x - 1) Y(x) : x <= 0 -> X "); var linker = new FileLinker(fileSystem); var linkedFiles = linker.LinkFiles("root.lsystem"); using var system = linkedFiles.CompileSystem(); LSystemState <float> currentState = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); var X = linkedFiles.GetSymbol("root.lsystem", 'X'); var Y = linkedFiles.GetSymbol("root.lsystem", 'Y'); var symbolStringMapping = new Dictionary <int, char>() { { X, 'X' }, { Y, 'Y' } }; /** * system equivalent with remapped symbol names: * Y -> YX * X -> AX */ Assert.AreEqual("Y(2)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(1)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); Assert.IsTrue(currentState.hasImmatureSymbols); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(0)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); Assert.IsTrue(currentState.hasImmatureSymbols); currentState = system.StepSystem(currentState); Assert.AreEqual("X", currentState.currentSymbols.Data.ToString(symbolStringMapping)); Assert.IsFalse(currentState.hasImmatureSymbols); currentState = system.StepSystem(currentState); Assert.AreEqual("X", currentState.currentSymbols.Data.ToString(symbolStringMapping)); Assert.IsFalse(currentState.hasImmatureSymbols); currentState.currentSymbols.DisposeImmediate(); }
public void SymbolStringParsesStringAxiom() { var systemState = new DefaultLSystemState("B"); Assert.AreEqual("B", systemState.currentSymbols.Data.ToString()); Assert.AreEqual(new JaggedIndexing { index = 0, length = 0 }, systemState.currentSymbols.Data.parameters.indexing[0]); Assert.AreEqual(0, systemState.currentSymbols.Data.parameters.data.Length); systemState.currentSymbols.Dispose(); }
public void LSystemMatchesParametricWithVariedConditionals() { var globalParameters = new string[] { "global" }; using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A(x, y) > B(z, a) : x < global && y <= z -> A(x, y)", "A(x, y) > B(z, a) : x < global && y > z -> B(x, y)", "A(x, y) > B(z, a) : x >= global && y <= z -> A(z, a)", "A(x, y) > B(z, a) : x >= global && y > z -> B(z, a)", "A(x) > B(y, z) : x >= global && y <= z -> A(z, x)", "A(x) > B(y, z) : x >= global && y > z -> B(z, x)", }, globalParameters); var defaultGlobalParams = new float[] { 3 }; LSystemState <float> state = new DefaultLSystemState("A(0, 5)B(10, 15)"); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(0, 5)B(10, 15)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); state = new DefaultLSystemState("A(0, 5)B(3, 15)"); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("B(0, 5)B(3, 15)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); state = new DefaultLSystemState("A(4, 5)B(10, 15)"); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(10, 15)B(10, 15)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); state = new DefaultLSystemState("A(4, 5)B(3, 15)"); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("B(3, 15)B(3, 15)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); state = new DefaultLSystemState("A(4)B(5, 10)"); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(10, 4)B(5, 10)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); state = new DefaultLSystemState("A(4)B(10, 5)"); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("B(5, 4)B(10, 5)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); state = new DefaultLSystemState("A(1)B(10, 5)"); state = basicLSystem.StepSystem(state, defaultGlobalParams); Assert.AreEqual("A(1)B(10, 5)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void TestLSystemFile( string fileText, IEnumerable <string> expectedSteps) { var fileSystem = new InMemoryFileProvider(); fileSystem.RegisterFileWithIdentifier("root.lsystem", fileText); var linker = new FileLinker(fileSystem); var linkedFiles = linker.LinkFiles("root.lsystem"); using var system = linkedFiles.CompileSystem(); LSystemState <float> state = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); var symbolStringMapping = linkedFiles.allSymbolDefinitionsLeafFirst .Where(x => x.sourceFileDefinition == "root.lsystem") .ToDictionary(x => x.actualSymbol, x => x.characterInSourceFile); using var axiom = linkedFiles.GetAxiom(); Assert.AreEqual(axiom.ToString(symbolStringMapping), state.currentSymbols.Data.ToString(symbolStringMapping)); try { foreach (var expectedStep in expectedSteps) { state = system.StepSystem(state); Assert.AreEqual(expectedStep, state.currentSymbols.Data.ToString(symbolStringMapping)); } } catch (System.Exception e) { UnityEngine.Debug.LogException(e); UnityEngine.Debug.Log("actual result:"); state.currentSymbols.DisposeImmediate(); state = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); for (int i = 0; i < expectedSteps.Count(); i++) { state = system.StepSystem(state); UnityEngine.Debug.Log(state.currentSymbols.Data.ToString(symbolStringMapping)); } throw; } finally { state.currentSymbols.DisposeImmediate(); } }
public void LinkCompilesBranchingSymbolWithContextMatches() { var fileSystem = new InMemoryFileProvider(); fileSystem.RegisterFileWithIdentifier("root.lsystem", @" #axiom AF[FB] #iterations 10 #symbols FAB #matches AB #symbols CD #matches CD A > [B] -> C A < B -> D "); var linker = new FileLinker(fileSystem); var linkedFiles = linker.LinkFiles("root.lsystem"); using var system = linkedFiles.CompileSystem(); LSystemState <float> currentState = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); var lBracket = linkedFiles.GetSymbol("root.lsystem", '['); var rBracket = linkedFiles.GetSymbol("root.lsystem", ']'); var FRoot = linkedFiles.GetSymbol("root.lsystem", 'F'); var ARoot = linkedFiles.GetSymbol("root.lsystem", 'A'); var BRoot = linkedFiles.GetSymbol("root.lsystem", 'B'); var CRoot = linkedFiles.GetSymbol("root.lsystem", 'C'); var DRoot = linkedFiles.GetSymbol("root.lsystem", 'D'); var symbolStringMapping = new Dictionary <int, char>() { { lBracket, '[' }, { rBracket, ']' }, { FRoot, 'F' }, { ARoot, 'A' }, { BRoot, 'B' }, { CRoot, 'C' }, { DRoot, 'D' } }; Assert.AreEqual("AF[FB]", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("CF[FD]", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState.currentSymbols.DisposeImmediate(); }
public void DiffusionRateCanChangeAtRuntime() { var testFile = @" #axiom n(0.5, 0, 10)Fn(0.5, 0, 10)Fn(0.5, 8, 10) #iterations 10 #symbols Fna #define diffusionStepsPerStep 1 #include diffusion (Node->n) (Amount->a) "; var fileSystem = new InMemoryFileProvider(); fileSystem.RegisterFileWithIdentifier("root.lsystem", testFile); var linker = new FileLinker(fileSystem); var linkedFiles = linker.LinkFiles("root.lsystem"); using var system = linkedFiles.CompileSystem(); LSystemState <float> state = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); var symbolStringMapping = linkedFiles.allSymbolDefinitionsLeafFirst .Where(x => x.sourceFileDefinition == "root.lsystem") .ToDictionary(x => x.actualSymbol, x => x.characterInSourceFile); using var axiom = linkedFiles.GetAxiom(); Assert.AreEqual(axiom.ToString(symbolStringMapping), state.currentSymbols.Data.ToString(symbolStringMapping)); try { state = system.StepSystem(state); Assert.AreEqual("n(0.5, 0, 10)Fn(0.5, 4, 10)Fn(0.5, 4, 10)", state.currentSymbols.Data.ToString(symbolStringMapping)); system.customSymbols.diffusionConstantRuntimeGlobalMultiplier = 0.5f; state = system.StepSystem(state); Assert.AreEqual("n(0.5, 1, 10)Fn(0.5, 3, 10)Fn(0.5, 4, 10)", state.currentSymbols.Data.ToString(symbolStringMapping)); state = system.StepSystem(state); Assert.AreEqual("n(0.5, 1.5, 10)Fn(0.5, 2.75, 10)Fn(0.5, 3.75, 10)", state.currentSymbols.Data.ToString(symbolStringMapping)); system.customSymbols.diffusionConstantRuntimeGlobalMultiplier = 1f; state = system.StepSystem(state); Assert.AreEqual("n(0.5, 2.125, 10)Fn(0.5, 2.625, 10)Fn(0.5, 3.25, 10)", state.currentSymbols.Data.ToString(symbolStringMapping)); } finally { state.currentSymbols.DisposeImmediate(); } }
public void LSystemAppliesContextualRulesWithInitialBranching() { LSystemState <float> state = new DefaultLSystemState("AF[FB]"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { " A > [B] -> C", }, includedCharacters: "AB"); Assert.AreEqual("AF[FB]", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("CF[FB]", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemPrioritizesContextualRulesBySize() { LSystemState <float> state = new DefaultLSystemState("AABCD"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A -> B", "A > A -> C", "A > ABCD -> F", "A > ABC -> E", "A > AB -> D", }); Assert.AreEqual("AABCD", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("FBBCD", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemReproducesStochasticResultFromReplicatedState() { var globalParameters = new string[] { "global" }; LSystemState <float> state = new DefaultLSystemState("A(0)"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "P(0.5) | A(x) : x < global -> A(x + 1)", "P(0.5) | A(x) : x < global -> A(x + 0.5)", "P(0.5) | A(x) : x >= global -> A(x - 1)", "P(0.5) | A(x) : x >= global -> A(x - 0.5)", }, globalParameters); var defaultGlobalParams = new float[] { 3 }; var resultSequence = new List <string>(); var resultSampleSize = 12; resultSequence.Add(state.currentSymbols.Data.ToString()); LSystemState <float> systemCopyAt5 = null; for (int i = 1; i < resultSampleSize; i++) { if (i == 5) { systemCopyAt5 = state; state = basicLSystem.StepSystem(state, defaultGlobalParams, false); } else { state = basicLSystem.StepSystem(state, defaultGlobalParams); } resultSequence.Add(state.currentSymbols.Data.ToString()); } state.currentSymbols.Dispose(); for (int i = 5; i < resultSampleSize; i++) { systemCopyAt5 = basicLSystem.StepSystem(systemCopyAt5, defaultGlobalParams); Assert.AreEqual(resultSequence[i], systemCopyAt5.currentSymbols.Data.ToString(), $"Index {i}"); } systemCopyAt5.currentSymbols.Dispose(); }
public void LSystemAppliesParameterMatches() { LSystemState <float> state = new DefaultLSystemState("A(1)"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A(x) -> A(x + 1)", }); Assert.AreEqual("A(1)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(2)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(3)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(4)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(5)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemAppliesComplexParameterEquations() { LSystemState <float> state = new DefaultLSystemState("A(1, 1)"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A(x, y) -> A(x + y, x * y)", }); Assert.AreEqual("A(1, 1)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(2, 1)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(3, 2)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(5, 6)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(11, 30)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemAssumesIdentityRule() { LSystemState <float> state = new DefaultLSystemState("B"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A -> ACB", "B -> A" }); Assert.AreEqual("B", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ACB", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ACBCA", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ACBCACACB", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
private void AssertStochasticResults(LSystemStepper system, string axiom, string[] expectedResults, float[] globalParams = null) { var resultSet = new HashSet <string>(); var attemptSeeder = new Unity.Mathematics.Random((uint)axiom.GetHashCode()); var attempts = expectedResults.Length * 10; for (int attempt = 1; attempt < attempts; attempt++) { LSystemState <float> state = new DefaultLSystemState(axiom, attemptSeeder.NextUInt()); state = system.StepSystem(state, globalParams); resultSet.Add(state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); } Assert.AreEqual(expectedResults.Length, resultSet.Count); for (int i = 0; i < expectedResults.Length; i++) { var expected = expectedResults[i]; Assert.IsTrue(resultSet.Contains(expected), $"Generated states should contain stochastic result {expected}"); } }
public void LSystemAssumesIdentityReplacementWithContextRules() { LSystemState <float> state = new DefaultLSystemState("B"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "B -> ABA", "A > A ->", "A < A -> B" }); Assert.AreEqual("B", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABA", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("AABAA", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("BABAB", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABAAABAAABA", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemDoesAFibbonachi() { LSystemState <float> state = new DefaultLSystemState("A(1)B(1)"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { " A(x) > B(y) -> A(x + y)", "A(x) < B(y) -> B(x)", }); Assert.AreEqual("A(1)B(1)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(2)B(1)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(3)B(2)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(5)B(3)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(8)B(5)", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A(13)B(8)", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemAppliesContextualRulesOfEqualComplexityInDefinitionOrder() { LSystemState <float> state = new DefaultLSystemState("AAA"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { " A > A -> B", "A < A -> C" }); Assert.AreEqual("AAA", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("BBC", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); state = new DefaultLSystemState("AAA"); using var basicLSystem2 = LSystemBuilder.FloatSystem(new string[] { "A < A -> C", " A > A -> B" }); Assert.AreEqual("AAA", state.currentSymbols.Data.ToString()); state = basicLSystem2.StepSystem(state); Assert.AreEqual("BCC", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemAppliesStochasticRuleDifferently() { LSystemState <float> state = new DefaultLSystemState("C"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { "A -> AC", "P(0.9) | C -> A", "P(0.1) | C -> AB" }); Assert.AreEqual("C", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("A", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("AC", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ACA", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ACAAC", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ACAACACA", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemIgnoresIgnoredCharatchers() { LSystemState <float> state = new DefaultLSystemState("B"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { " A -> A1B2", " B -> 3A4", " A > A -> 5", "A < A -> 6B7" }, includedCharacters: "AB"); Assert.AreEqual("B", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("3A4", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("3A1B24", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("3A1B213A424", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("3A1B213A4213A1B2424", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("3A1B213A4213542136B713A42424", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LSystemAppliesContextualRulesWithUniqueOrigins() { LSystemState <float> state = new DefaultLSystemState("A"); using var basicLSystem = LSystemBuilder.FloatSystem(new string[] { " A -> AB", " B -> CDC", " D > C -> A", "D < C > D -> B" }); Assert.AreEqual("A", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("AB", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABCDC", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABCDCCAC", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABCDCCACCABC", state.currentSymbols.Data.ToString()); state = basicLSystem.StepSystem(state); Assert.AreEqual("ABCDCCACCABCCABCDCC", state.currentSymbols.Data.ToString()); state.currentSymbols.Dispose(); }
public void LinksDependencyWithContextualMatchesAndIgnoresNonImportedSymbols() { var fileSystem = new InMemoryFileProvider(); fileSystem.RegisterFileWithIdentifier("root.lsystem", @" #axiom Y(0)A(3) #iterations 10 #symbols XYA #matches XYA #include nodes.lsyslib (Node->X) (Root->Y) A(x) : x > 0 -> I(2)[X(x)]A(x - 1) A(x) : x <= 0 -> J #symbols IFJ #matches IJ I(x) : x > 0 -> I(x - 1)F J -> I(x) > J -> JI(x) "); fileSystem.RegisterFileWithIdentifier("nodes.lsyslib", @" #symbols AB #matches AB #export Node B #export Root A A(y) < B(x) : x > 0 -> B(x - 1) A(x) > [B(y)] : y > 0 -> A(x + 1) A(x) > [B(y)][B(z)] : y > 0 && z > 0 -> A(x + 2) A(x) > [B(y)][B(z)][B(a)] : y > 0 && z > 0 && a > 0 -> A(x + 3) A(x) > [B(y)][B(z)][B(a)][B(b)] : y > 0 && z > 0 && a > 0 && b > 0 -> A(x + 4) "); var linker = new FileLinker(fileSystem); var linkedFiles = linker.LinkFiles("root.lsystem"); using var system = linkedFiles.CompileSystem(); LSystemState <float> currentState = new DefaultLSystemState( linkedFiles.GetAxiom(), (uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue)); var lBracket = linkedFiles.GetSymbol("root.lsystem", '['); var rBracket = linkedFiles.GetSymbol("root.lsystem", ']'); var XRoot = linkedFiles.GetSymbol("root.lsystem", 'X'); var YRoot = linkedFiles.GetSymbol("root.lsystem", 'Y'); var ARoot = linkedFiles.GetSymbol("root.lsystem", 'A'); var IRoot = linkedFiles.GetSymbol("root.lsystem", 'I'); var FRoot = linkedFiles.GetSymbol("root.lsystem", 'F'); var JRoot = linkedFiles.GetSymbol("root.lsystem", 'J'); var Alib = linkedFiles.GetSymbol("nodes.lsyslib", 'A'); var Blib = linkedFiles.GetSymbol("nodes.lsyslib", 'B'); Assert.AreEqual(Alib, YRoot); Assert.AreEqual(Blib, XRoot); var symbolStringMapping = new Dictionary <int, char>() { { lBracket, '[' }, { rBracket, ']' }, { XRoot, 'X' }, { YRoot, 'Y' }, { ARoot, 'A' }, { IRoot, 'I' }, { FRoot, 'F' }, { JRoot, 'J' } }; Assert.AreEqual("Y(0)A(3)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(0)I(2)[X(3)]A(2)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(1)I(1)F[X(2)]I(2)[X(2)]A(1)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(3)I(0)FF[X(1)]I(1)F[X(1)]I(2)[X(1)]A(0)", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(6)I(0)FF[X(0)]I(0)FF[X(0)]I(1)F[X(0)]J", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(6)I(0)FF[X(0)]I(0)FF[X(0)]JI(1)F[X(0)]", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(6)I(0)FF[X(0)]JI(0)FF[X(0)]I(0)FF[X(0)]", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(6)JI(0)FF[X(0)]I(0)FF[X(0)]I(0)FF[X(0)]", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState = system.StepSystem(currentState); Assert.AreEqual("Y(6)I(0)FF[X(0)]I(0)FF[X(0)]I(0)FF[X(0)]", currentState.currentSymbols.Data.ToString(symbolStringMapping)); currentState.currentSymbols.DisposeImmediate(); }