moma_simulation_engine 0.1.2

A Simulation engine powered by MOMA
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

# MOMA Simulation Engine


[](https://www.google.com/search?q=https://crates.io/crates/simulation-engine)
[](https://www.google.com/search?q=https://docs.rs/simulation-engine)
[](https://opensource.org/licenses/MIT)

A library for creating and running dynamic systems, such as cellular automata, using the [MOMA (Moving Origin Modular Arithmetic)](https://www.google.com/search?q=https://github.com/Neil-Crago/moma) framework as the core update rule.

This crate provides the tools to build simulations where the evolution of the system is governed by the complex, non-linear, and deterministic patterns generated by MOMA.

-----

## The Core Idea


Most simulations, like cellular automata, use simple, fixed rules to determine the next state of a cell (e.g., "if the left neighbor is black and the right is white, the new cell is black").

The **MOMA Simulation Engine** replaces these simple rules with a `MomaRing`. The state of a cell evolves based on the MOMA residue of its current state, where the "moving origin" is determined by the state of its neighbors.

This introduces a rich, complex, and deeply interconnected dynamic, allowing for the generation of intricate and emergent patterns that are unique to the chosen MOMA strategy.

-----

## Features


  * **`CellularAutomaton`**: A simple 1D cellular automaton that uses MOMA for its update logic.
  * **Strategy-Driven Rules**: The behavior of the simulation is determined by the `OriginStrategy` passed to it. This means you can create vastly different "universes" just by changing the strategy.
  * **Extensible**: Designed to be a foundation for more complex simulations, such as 2D automata or dynamic graph-based systems.

-----

## Getting Started


To use this engine in your own project, add it to your `Cargo.toml`.

```toml
[dependencies]
moma_simulation_engine = "0.1.1" # Or the most recent version
```

### Quick Start: Running a 1D Automaton


Here is a simple example of how to create, run, and display a MOMA-powered cellular automaton.

```rust
use moma::strategy;
use moma_simulation_engine::CellularAutomaton;
use std::{thread, time};

fn main() {
    println!("--- MOMA-Powered 1D Cellular Automaton ---");

    // --- Simulation Parameters ---
    let width = 100;         // Width of the automaton in cells.
    let steps = 200;         // Number of generations to simulate.
    let modulus = 10;        // The number of states for each cell (0-9).
    let delay_ms = 50;       // Delay between steps for visualization.

    // Choose a MOMA strategy to govern the rules.
    // Try changing this to `strategy::PrimeGap` to see a different universe!
    let strategy = strategy::CompositeMass;

    // --- Initialization ---
    let mut automaton = CellularAutomaton::new(width, modulus, strategy);
    println!("Initial State (Generation 0):\n{}\n", automaton.render());

    // --- Simulation Loop ---
    for i in 1..=steps {
        automaton.step();
        println!("Generation {}:", i);
        println!("{}", automaton.render());
        thread::sleep(time::Duration::from_millis(delay_ms));
    }

    println!("\n--- Simulation Complete ---");
}
```

-----

## Future Directions


This crate is the first step in exploring MOMA as a tool for modeling complex systems. Future plans include:

  * 2D Cellular Automata.
  * Dynamic Graph models where node states are updated via MOMA rules.
  * Tools for analyzing the patterns generated by different strategies.

## License


This project is licensed under either of:

  * Apache License, Version 2.0
  * MIT license

at your option.