Struct SolveSettings 

pub struct SolveSettings { /* private fields */ }

Stores settings for solver.

Default settings:

• solve_simple: true
• debug: false
• difference: false
• sleep_ms: None

Implementations

impl SolveSettings

pub fn new() -> SolveSettings

Creates new solve settings.

Examples found in repository

examples/adinkra1.rs (line 21)

fn main() {
    let mut g = Graph::new();
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![Constraint {edge: RED, node: 1}]
    };
    let b = Node {
        color: 1,
        self_connected: false,
        edges: vec![Constraint {edge: RED, node: 0}]
    };
    g.push(a);
    g.push(b);

    let solve_settings = SolveSettings::new();
    if let Some(solution) = g.solve(solve_settings) {
        solution.puzzle.print();
    }
}

examples/triangle.rs (line 18)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![Constraint {edge: EDGE, node: 0}; 2]
    };

    for _ in 0..3 {g.push(a.clone())}

    let solve_settings = SolveSettings::new();
    if let Some(solution) = g.solve(solve_settings) {
        // solution.puzzle.print();
        println!("{}", solution.puzzle.graphviz(
            "sfdp",
            &["black"],
            &["black"]
        ));
    }
}

examples/pentagon.rs (line 21)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![
            Constraint {edge: EDGE, node: 0},
            Constraint {edge: EDGE, node: 0},
        ]
    };

    for _ in 0..5 {g.push(a.clone())}

    let solve_settings = SolveSettings::new();
    if let Some(solution) = g.solve(solve_settings) {
        // solution.puzzle.print();
        println!("{}", solution.puzzle.graphviz(
            "sfdp",
            &["black"],
            &["black"]
        ));
    }
}

examples/cube.rs (line 30)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern with 3 edges.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![Constraint {edge: EDGE, node: 0}; 3]
    };

    // Add 8 vertices.
    for _ in 0..8 {g.push(a.clone())}
    g.no_triangles = true;

    let solve_settings = SolveSettings::new();
    if let Some(solution) = g.solve(solve_settings) {
        println!("{}", solution.puzzle.graphviz(
            "sfdp",
            &["black"],
            &["black"]
        ));
    } else {
        eprintln!("<no solution>");
    }
}

examples/square2.rs (line 19)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![Constraint {edge: SOLID, node: 0}; 2]
    };

    // Add 4 nodes.
    for _ in 0..4 {g.push(a.clone())}

    let solve_settings = SolveSettings::new()
        .debug(true).sleep_ms(2000);
    if let Some(solution) = g.solve(solve_settings) {
        // Prints:
        // 0 0 0 0
        // ========================================
        // 0 2 1 0
        // 2 0 0 1
        // 1 0 0 2
        // 0 1 2 0
        solution.puzzle.print();
    }
}

examples/hexagon.rs (line 22)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![
            Constraint {edge: EDGE, node: 0},
            Constraint {edge: EDGE, node: 0},
        ]
    };

    for _ in 0..6 {g.push(a.clone())}
    g.push_pair((2, 3));

    let solve_settings = SolveSettings::new();
    if let Some(solution) = g.solve(solve_settings) {
        // solution.puzzle.print();
        println!("{}", solution.puzzle.graphviz(
            "sfdp",
            &["black,fontcolor=white"],
            &["black"]
        ));
    }
}

Additional examples can be found in:

• examples/4cube.rs
• examples/square.rs
• examples/grid.rs
• examples/seven-bridges.rs
• examples/adinkra2.rs
• examples/adinkra3.rs
• examples/adinkra4.rs

pub fn set_solve_simple(&mut self, val: bool)

Sets wheter to solve simple moves between each step.

pub fn solve_simple(self, val: bool) -> SolveSettings

Whether to solve simple moves between each step.

pub fn set_debug(&mut self, val: bool)

Sets whether to debug by printing out to standard output.

pub fn debug(self, val: bool) -> SolveSettings

Whether to debug by printing out to standard output.

Examples found in repository

examples/square2.rs (line 20)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![Constraint {edge: SOLID, node: 0}; 2]
    };

    // Add 4 nodes.
    for _ in 0..4 {g.push(a.clone())}

    let solve_settings = SolveSettings::new()
        .debug(true).sleep_ms(2000);
    if let Some(solution) = g.solve(solve_settings) {
        // Prints:
        // 0 0 0 0
        // ========================================
        // 0 2 1 0
        // 2 0 0 1
        // 1 0 0 2
        // 0 1 2 0
        solution.puzzle.print();
    }
}

examples/square.rs (line 24)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![
            Constraint {edge: HORIZONTAL, node: 0},
            Constraint {edge: VERTICAL, node: 0},
        ]
    };

    // Add 4 nodes.
    for _ in 0..4 {g.push(a.clone())}

    let solve_settings = SolveSettings::new()
        .debug(true).sleep_ms(2000);
    if let Some(solution) = g.solve(solve_settings) {
        // Prints:
        // 0 0 0 0
        // ========================================
        // 0 2 1 0
        // 2 0 0 1
        // 1 0 0 2
        // 0 1 2 0
        solution.puzzle.print();
    }
}

examples/seven-bridges.rs (line 46)

fn main() {
    let mut g = Graph::new();

    let black_edge = Constraint {node: 0, edge: 2};
    let red_edge = Constraint {node: 0, edge: 3};
    let f = |black, red| Node {
        color: 0,
        self_connected: false,
        edges: {
            let mut res = vec![];
            for _ in 0..black {res.push(black_edge)}
            for _ in 0..red {res.push(red_edge)}
            res
        }
    };
    g.push(f(1, 1));
    g.push(f(2, 1));
    g.push(f(1, 1));
    g.push(f(1, 2));
    g.push(f(1, 3));
    g.push(f(0, 3));
    g.push(f(1, 1));
    g.push(f(2, 1));
    g.push(f(1, 1));

    g.set((0, 1), 2);
    g.set((1, 2), 2);
    g.set((0, 2), 1);
    g.set((1, 4), 3);
    g.set((2, 3), 1);
    g.set((2, 4), 1);
    g.set((3, 5), 1);
    g.set((3, 7), 1);
    g.set((3, 4), 2);

    g.connected = true;

    let solve_settings = SolveSettings::new()
        .debug(false)
        .sleep_ms(1000);
    if let Some(solution) = g.solve(solve_settings) {
        // solution.puzzle.print();
        println!("{}", solution.puzzle.graphviz(
            "sfdp",
            &["white"],
            &["black", "red"]
        ));
    } else {
        eprintln!("<no solution>");
    }
}

pub fn set_difference(&mut self, val: bool)

Sets whether to return the difference from initial puzzle.

pub fn difference(self, val: bool) -> SolveSettings

Whether to return the difference from initial puzzle.

pub fn set_maybe_sleep_ms(&mut self, val: Option<u64>)

Sets how many milliseconds to sleep between each step, if any.

pub fn maybe_sleep_ms(self, val: Option<u64>) -> SolveSettings

Sets how many milliseconds to sleep between each step, if any.

pub fn set_sleep_ms(&mut self, val: u64)

Sets how many milliseconds to sleep between each step.

pub fn sleep_ms(self, val: u64) -> SolveSettings

How many milliseconds to sleep between each step.

Examples found in repository

examples/square2.rs (line 20)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![Constraint {edge: SOLID, node: 0}; 2]
    };

    // Add 4 nodes.
    for _ in 0..4 {g.push(a.clone())}

    let solve_settings = SolveSettings::new()
        .debug(true).sleep_ms(2000);
    if let Some(solution) = g.solve(solve_settings) {
        // Prints:
        // 0 0 0 0
        // ========================================
        // 0 2 1 0
        // 2 0 0 1
        // 1 0 0 2
        // 0 1 2 0
        solution.puzzle.print();
    }
}

examples/square.rs (line 24)

fn main() {
    let mut g = Graph::new();

    // Create a node pattern.
    let a = Node {
        color: 0,
        self_connected: false,
        edges: vec![
            Constraint {edge: HORIZONTAL, node: 0},
            Constraint {edge: VERTICAL, node: 0},
        ]
    };

    // Add 4 nodes.
    for _ in 0..4 {g.push(a.clone())}

    let solve_settings = SolveSettings::new()
        .debug(true).sleep_ms(2000);
    if let Some(solution) = g.solve(solve_settings) {
        // Prints:
        // 0 0 0 0
        // ========================================
        // 0 2 1 0
        // 2 0 0 1
        // 1 0 0 2
        // 0 1 2 0
        solution.puzzle.print();
    }
}

examples/seven-bridges.rs (line 47)

fn main() {
    let mut g = Graph::new();

    let black_edge = Constraint {node: 0, edge: 2};
    let red_edge = Constraint {node: 0, edge: 3};
    let f = |black, red| Node {
        color: 0,
        self_connected: false,
        edges: {
            let mut res = vec![];
            for _ in 0..black {res.push(black_edge)}
            for _ in 0..red {res.push(red_edge)}
            res
        }
    };
    g.push(f(1, 1));
    g.push(f(2, 1));
    g.push(f(1, 1));
    g.push(f(1, 2));
    g.push(f(1, 3));
    g.push(f(0, 3));
    g.push(f(1, 1));
    g.push(f(2, 1));
    g.push(f(1, 1));

    g.set((0, 1), 2);
    g.set((1, 2), 2);
    g.set((0, 2), 1);
    g.set((1, 4), 3);
    g.set((2, 3), 1);
    g.set((2, 4), 1);
    g.set((3, 5), 1);
    g.set((3, 7), 1);
    g.set((3, 4), 2);

    g.connected = true;

    let solve_settings = SolveSettings::new()
        .debug(false)
        .sleep_ms(1000);
    if let Some(solution) = g.solve(solve_settings) {
        // solution.puzzle.print();
        println!("{}", solution.puzzle.graphviz(
            "sfdp",
            &["white"],
            &["black", "red"]
        ));
    } else {
        eprintln!("<no solution>");
    }
}

pub fn set_maybe_max_iterations(&mut self, val: Option<u64>)

Sets the maximum number of iterations before giving up.

pub fn maybe_max_iterations(self, val: Option<u64>) -> SolveSettings

The maximum number of iterations before giving up.

pub fn set_max_iterations(&mut self, val: u64)

Sets the maximum number of iterations before giving up.

pub fn max_iterations(self, val: u64) -> SolveSettings

The maximum number of iterations before giving up.