update stuff

src/app/sort3.c

@@ -0,0 +1,138 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   sort3.c                                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/02/08 15:50:10 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/02/08 17:53:02 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "app/state.h"
+#include "me/types.h"
+#include "me/vec/vec_i64.h"
+
+void	push_a(void *s);
+void	push_b(void *s);
+void	swap_a(void *s);
+void	swap_b(void *s);
+void	swap_both(void *s);
+void	rotate_a(void *s);
+void	rotate_b(void *s);
+void	rotate_both(void *s);
+void	rev_rotate_a(void *s);
+void	rev_rotate_b(void *s);
+void	rev_rotate_both(void *s);
+
+/*
+fn	sort_three(state: &mut State, selector: StackSelector, min_first: bool) {
+	macro_rules! stack {
+		() => {
+			match selector {
+				StackSelector::B => &mut state.b,
+				StackSelector::A => &mut state.a,
+			}
+		};
+	}
+	let [swap, rotate, rev_rotate] = match selector {
+		StackSelector::A => [sa, ra, rra],
+		StackSelector::B => [sb, rb, rrb],
+	};
+	match stack!().len() {
+		2 => {
+			let func = match min_first {
+				true => PartialOrd::gt,
+				false => PartialOrd::lt,
+			};
+
+			if func(&stack!()[0].clone(), &stack!()[1]) {
+				swap(state);
+			}
+			return ;
+		}
+		3 => {}
+		0 | 1 | 4.. => return,
+	}
+	let mut c = stack!().clone();
+	macro_rules! comb {
+		($i1:literal, $i2:literal, $i3:literal) => {
+			&[c[$i1 - 1], c[$i2 - 1], c[$i3 - 1]]
+		};
+	}
+	c.make_contiguous().sort_unstable();
+	if min_first {
+		c.make_contiguous().reverse();
+	}
+	stack!().make_contiguous();
+
+		if (stack!() == 	comb![1, 2, 3]  / * abc * /)
+{
+	swap(state);
+	rev_rotate(state);
+}
+else if (stack!() == comb ![ 1, 3, 2 ]  / * acb * /)
+{
+	rotate(state);
+}
+else if (stack !() == comb ![ 2, 3, 1 ] / * bca  * /)
+{
+	swap(state);
+}
+else if (stack !() == comb ![ 2, 1, 3 ] / * bac  * /)
+{
+	rotate(state);
+}
+else if (stack !() == comb ![ 3, 2, 1 ] / * cba  * /)
+{
+}
+else if (stack !() == comb ![ 3, 1, 2 ] / * cab  * /)
+{
+	rotate(state);
+	swap(state);
+	rev_rotate(state);
+}
+}
+*/
+// 2 3 1
+bool	sort_i64(t_i64 *lhs, t_i64 *rhs)
+{
+	return (*lhs <= *rhs);
+}
+
+void	sort_3_inner(t_state *state, t_i64 data[3], t_i64 sorted[3])
+{
+	if ((data[0] == sorted[0]) && (data[1] == sorted[1])
+		&& (data[2] == sorted[2]))
+		(swap_a(state), rev_rotate_a(state));
+	else if ((data[0] == sorted[0]) && (data[1] == sorted[2])
+		&& (data[2] == sorted[1]))
+		rotate_a(state);
+	else if ((data[0] == sorted[1]) && (data[1] == sorted[2])
+		&& (data[2] == sorted[0]))
+		swap_a(state);
+	else if ((data[0] == sorted[1]) && (data[1] == sorted[0])
+		&& (data[2] == sorted[2]))
+		rev_rotate_a(state);
+	else if ((data[0] == sorted[2]) && (data[1] == sorted[0])
+		&& (data[2] == sorted[1]))
+		(rotate_a(state), swap_a(state), rev_rotate_a(state));
+}
+
+void	sort_3(t_state *state)
+{
+	t_i64		array[3];
+	t_vec_i64	why_do_i_do_this;
+
+	why_do_i_do_this.free_func = NULL;
+	why_do_i_do_this.len = 3;
+	why_do_i_do_this.capacity = 3;
+	why_do_i_do_this.buffer = array;
+	array[0] = state->stack_a.buffer[0];
+	array[1] = state->stack_a.buffer[1];
+	array[2] = state->stack_a.buffer[2];
+	vec_i64_sort(&why_do_i_do_this, sort_i64);
+	vec_i64_reverse(&why_do_i_do_this);
+	sort_3_inner(state, state->stack_a.buffer, array);
+}