Struct MultiPhaseSearch

Source

pub struct MultiPhaseSearch<TPuzzle: SemiGroupActionPuzzle> {
    pub phases: Vec<Box<dyn SearchPhase<TPuzzle>>>,
    pub phantom_data: PhantomData<TPuzzle>,
    /* private fields */
}

Fields§

§phases: Vec<Box<dyn SearchPhase<TPuzzle>>>§phantom_data: PhantomData<TPuzzle>

Implementations§

Source §

impl<TPuzzle: SemiGroupActionPuzzle> MultiPhaseSearch<TPuzzle>

Source

pub fn try_new( tpuzzle: TPuzzle, phases: Vec<Box<dyn SearchPhase<TPuzzle>>>, options: MultiPhaseSearchOptions, ) -> Result<Self, SearchError>

Examples found in repository ?

examples/kociemba_multiphase.rs (lines 24-66)

21    pub fn new() -> Self {
22        let kpuzzle = cube3x3x3_centerless_kpuzzle();
23        Self(
24            MultiPhaseSearch::try_new(
25                kpuzzle.clone(),
26                vec![
27                    Box::new(
28                        KPuzzleSimpleMaskPhase::try_new(
29                            "G1 reduction".to_owned(),
30                            cube3x3x3_centerless_g1_target_kpattern().clone(),
31                            vec![
32                                parse_move!("U").to_owned(),
33                                parse_move!("L").to_owned(),
34                                parse_move!("F").to_owned(),
35                                parse_move!("R").to_owned(),
36                                parse_move!("B").to_owned(),
37                                parse_move!("D").to_owned(),
38                            ],
39                            Default::default(),
40                        )
41                        .unwrap(),
42                    ),
43                    Box::new(
44                        KPuzzleSimpleMaskPhase::try_new(
45                            "Domino".to_owned(),
46                            kpuzzle.default_pattern().clone(),
47                            vec![
48                                parse_move!("U").to_owned(),
49                                parse_move!("L2").to_owned(),
50                                parse_move!("F2").to_owned(),
51                                parse_move!("R2").to_owned(),
52                                parse_move!("B2").to_owned(),
53                                parse_move!("D").to_owned(),
54                            ],
55                            Default::default(),
56                        )
57                        .unwrap(),
58                    ),
59                ],
60                MultiPhaseSearchOptions {
61                    search_logger: SearchLogger {
62                        verbosity: VerbosityLevel::Info,
63                    },
64                    ..Default::default()
65                },
66            )
67            .unwrap(),
68        )
69    }

More examples

Hide additional examples

examples/2x2x2_three_phase.rs (lines 29-83)

24pub fn main() {
25    let kpuzzle = cube2x2x2_kpuzzle();
26
27    // Note: this solver isn't really a "good idea". It's just a convenient test
28    // of three phases, on a puzzle with few-ish states.
29    let mut search = MultiPhaseSearch::try_new(
30        kpuzzle.clone(),
31        vec![
32            Box::new(
33                KPuzzleSimpleMaskPhase::try_new(
34                    "D orientation".to_owned(),
35                    phase1_kpattern().clone(),
36                    vec![
37                        parse_move!("U").to_owned(),
38                        parse_move!("L").to_owned(),
39                        parse_move!("F").to_owned(),
40                        parse_move!("R").to_owned(),
41                        parse_move!("B").to_owned(),
42                        parse_move!("D").to_owned(),
43                    ],
44                    Default::default(),
45                )
46                .unwrap(),
47            ),
48            Box::new(
49                KPuzzleSimpleMaskPhase::try_new(
50                    "U orientation".to_owned(),
51                    phase2_kpattern().clone(),
52                    vec![
53                        parse_move!("U").to_owned(),
54                        parse_move!("F").to_owned(),
55                        parse_move!("R").to_owned(),
56                    ],
57                    Default::default(),
58                )
59                .unwrap(),
60            ),
61            Box::new(
62                KPuzzleSimpleMaskPhase::try_new(
63                    "PBL".to_owned(),
64                    kpuzzle.default_pattern().clone(),
65                    vec![
66                        parse_move!("U").to_owned(),
67                        parse_move!("R2").to_owned(),
68                        parse_move!("F2").to_owned(),
69                        parse_move!("L2").to_owned(),
70                        parse_move!("D").to_owned(),
71                    ],
72                    Default::default(),
73                )
74                .unwrap(),
75            ),
76        ],
77        MultiPhaseSearchOptions {
78            search_logger: SearchLogger {
79                verbosity: VerbosityLevel::Info,
80            },
81            ..Default::default()
82        },
83    )
84    .unwrap();
85
86    let scramble_alg = random_scramble_for_event(Event::Cube2x2x2Speedsolving).unwrap();
87    let scramble = kpuzzle.default_pattern().apply_alg(&scramble_alg).unwrap();
88    println!(
89        "{} // scramble alg
90{} // solution",
91        scramble_alg,
92        search
93            .chain_first_solution_for_each_phase(&scramble)
94            .unwrap()
95    );
96}

Source

pub fn chain_first_solution_for_each_phase( &mut self, search_pattern: &TPuzzle::Pattern, ) -> Result<Alg, SearchError>

Examples found in repository ?

examples/kociemba_multiphase.rs (line 86)

72pub fn main() {
73    let kpuzzle = cube3x3x3_centerless_kpuzzle();
74
75    let mut kociemba_two_phase = KociembaTwoPhase::new();
76
77    let scramble = kpuzzle
78        .default_pattern()
79        .apply_alg(parse_alg!(
80            "F B2 L' U2 D' B2 D B' U2 B2 U2 L2 B2 L2 D B2 U' F2 R2 F2 L"
81        ))
82        .unwrap();
83    assert_ne!(scramble, cube3x3x3_centerless_kpuzzle().default_pattern());
84    let solution = kociemba_two_phase
85        .0
86        .chain_first_solution_for_each_phase(&scramble)
87        .unwrap();
88    println!("{}", solution);
89    assert_eq!(
90        scramble.apply_alg(&solution).unwrap(),
91        cube3x3x3_centerless_kpuzzle().default_pattern()
92    );
93}

More examples

Hide additional examples

examples/2x2x2_three_phase.rs (line 93)

24pub fn main() {
25    let kpuzzle = cube2x2x2_kpuzzle();
26
27    // Note: this solver isn't really a "good idea". It's just a convenient test
28    // of three phases, on a puzzle with few-ish states.
29    let mut search = MultiPhaseSearch::try_new(
30        kpuzzle.clone(),
31        vec![
32            Box::new(
33                KPuzzleSimpleMaskPhase::try_new(
34                    "D orientation".to_owned(),
35                    phase1_kpattern().clone(),
36                    vec![
37                        parse_move!("U").to_owned(),
38                        parse_move!("L").to_owned(),
39                        parse_move!("F").to_owned(),
40                        parse_move!("R").to_owned(),
41                        parse_move!("B").to_owned(),
42                        parse_move!("D").to_owned(),
43                    ],
44                    Default::default(),
45                )
46                .unwrap(),
47            ),
48            Box::new(
49                KPuzzleSimpleMaskPhase::try_new(
50                    "U orientation".to_owned(),
51                    phase2_kpattern().clone(),
52                    vec![
53                        parse_move!("U").to_owned(),
54                        parse_move!("F").to_owned(),
55                        parse_move!("R").to_owned(),
56                    ],
57                    Default::default(),
58                )
59                .unwrap(),
60            ),
61            Box::new(
62                KPuzzleSimpleMaskPhase::try_new(
63                    "PBL".to_owned(),
64                    kpuzzle.default_pattern().clone(),
65                    vec![
66                        parse_move!("U").to_owned(),
67                        parse_move!("R2").to_owned(),
68                        parse_move!("F2").to_owned(),
69                        parse_move!("L2").to_owned(),
70                        parse_move!("D").to_owned(),
71                    ],
72                    Default::default(),
73                )
74                .unwrap(),
75            ),
76        ],
77        MultiPhaseSearchOptions {
78            search_logger: SearchLogger {
79                verbosity: VerbosityLevel::Info,
80            },
81            ..Default::default()
82        },
83    )
84    .unwrap();
85
86    let scramble_alg = random_scramble_for_event(Event::Cube2x2x2Speedsolving).unwrap();
87    let scramble = kpuzzle.default_pattern().apply_alg(&scramble_alg).unwrap();
88    println!(
89        "{} // scramble alg
90{} // solution",
91        scramble_alg,
92        search
93            .chain_first_solution_for_each_phase(&scramble)
94            .unwrap()
95    );
96}