User:Inthar/Code - Revision history

Inthar: Blanked the page

2023-12-31T01:49:11Z

Blanked the page

Inthar at 04:37, 24 December 2023

2023-12-24T04:37:32Z

@@ Line 843: / Line 843: @@
+	    }
 	    (mv_result, balance_result)
+     }
+}

Inthar: /* Ternary billiard scales of length ≤ 31 */

2023-12-12T19:20:58Z

Ternary billiard scales of length ≤ 31

← Older revision		Revision as of 19:20, 12 December 2023
Line 1:		Line 1:
	== Ternary billiard scales ~~of length ≤ 31~~ ==		== Ternary billiard scales ==
	To run this, you need Rust installed.		To run this, you need Rust installed.
	# In any folder you want, create a directory <code>billiard-scales</code>.		# In any folder you want, create a directory <code>billiard-scales</code>.

Inthar at 01:21, 10 December 2023

2023-12-10T01:21:47Z

Show changes

Inthar at 01:16, 10 December 2023

2023-12-10T01:16:45Z

Show changes

Inthar: /* main.rs */

2023-12-08T05:52:20Z

main.rs

← Older revision		Revision as of 05:52, 8 December 2023
Line 904:		Line 904:
	let mut f = File::create("billiard_scales_mediawiki")?;		let mut f = File::create("billiard_scales_mediawiki")?;
	let start_time = Instant::now();		let start_time = Instant::now();
	for a in 1..=29 {		for n in 3..=31 {
	for b in 1..=a {		writeln!(&f, "== {} notes ==", n);
	for c in 1..=b {		for a in 1..=(n - 2) {
	if a + b + c ~~<= 31~~ && ~~scale_theory~~::gcd(~~scale_theory~~::gcd(a as i64, b as i64), c as i64) == 1 {		for b in 1..=(n - a - 1) {
	writeln!(&f, "== {}x{}y{}z ==", a, b, c);		let c = n - a - b;
	let billiard_scales = ~~scale_theory~~::billiard_scales(a, b, c);		if a >= b && b >= c && billiard_scales::gcd(billiard_scales::gcd(a as i64, b as i64), c as i64) == 1 {
			writeln!(&f, "=== {}x{}y{}z ===", a, b, c);
			let billiard_scales = billiard_scales::billiard_scales(a, b, c);
	for scale in &billiard_scales{		for scale in &billiard_scales{
	writeln!(&f, "# {}\n#* maximum variety {}, balance {}", scale, ~~scale_theory~~::maximum_variety(scale), ~~scale_theory~~::balance(scale));		writeln!(&f, "# {}\n#* maximum variety {}, balance {}", scale, billiard_scales::maximum_variety(scale), billiard_scales::balance(scale));
	}		}
	}		}

Inthar: /* planegeometry.rs */

2023-12-08T05:12:28Z

planegeometry.rs

← Older revision		Revision as of 05:12, 8 December 2023
Line 6:		Line 6:
	# Run <code>cargo run --release</code>. The script should notify you when it has finished running.		# Run <code>cargo run --release</code>. The script should notify you when it has finished running.
	# Open the output file <code>billiard_scales_mediawiki</code> for the result.		# Open the output file <code>billiard_scales_mediawiki</code> for the result.
	=== ~~planegeometry~~.rs ===		=== plane_geometry.rs ===
	<syntaxhighlight lang="rs">		<syntaxhighlight lang="rs">
	// Geometry of points and lines in the plane, implemented with rational numbers. The implementation is janky, though.		// Geometry of points and lines in the plane, implemented with rational numbers. The implementation is janky, though.

Inthar: /* lib.rs */

2023-12-08T05:07:11Z

lib.rs

← Older revision		Revision as of 05:07, 8 December 2023
Line 648:		Line 648:
	<syntaxhighlight lang="rs">		<syntaxhighlight lang="rs">
	use std::collections::BTreeSet;		use std::collections::BTreeSet;
	~~use std::collections::HashSet;~~
	use num_rational::Rational64 as r64;		use num_rational::Rational64 as r64;
	mod plane_geometry;		mod plane_geometry;
Line 848:		Line 847:
	}		}

	// Return a Christoffel word with `a` x's and `b` y's.		/// Return a Christoffel word with `a` x's and `b` y's.
	// Algorithm from Bulgakova et al, 2023, "On balanced and abelian properties of circular words over a ternary alphabet".		/// Algorithm from Bulgakova et al, 2023, "On balanced and abelian properties of circular words over a ternary alphabet".
	pub fn christoffel_word(a: u32, b: u32) -> String {		pub fn christoffel_word(a: u32, b: u32) -> String {
	let d = (gcd(a as i64, b as i64) as u32);		let d = gcd(a as i64, b as i64) as u32;
	if d == 1 {		if d == 1 {
	let mut result : String = String::from("");		let mut result : String = String::from("");

Inthar: /* lib.rs */

2023-12-08T05:03:59Z

lib.rs

← Older revision		Revision as of 05:03, 8 December 2023
Line 656:		Line 656:
	type EquivalenceRelation<T> = fn(&T, &T) -> bool;		type EquivalenceRelation<T> = fn(&T, &T) -> bool;

	// Treating `scale` as a cyclic string (that is, "scale[i] == scale[i % scale.len()]"),		/// Treating `scale` as a cyclic string (that is, "scale[i] == scale[i % scale.len()]"),
	// take a slice of length `slice_length` from `basepoint`; assumes `slice_length` <= `scale`.len()		/// take a slice of length `slice_length` from `basepoint`; assumes `slice_length` <= `scale`.len()
	fn slice_cyclic_string(scale: &str, basepoint: usize, slice_length: usize) -> String {		fn slice_cyclic_string(scale: &str, basepoint: usize, slice_length: usize) -> String {
	let arr = scale;		let arr = scale;
Line 684:		Line 684:
	}		}

	// ~~Assumes~~ that equiv : T x T -> bool is an equivalence relation.		/// Assuming that "`equiv` : T x T -> bool" is an equivalence relation,
			/// return the equivalence class representatives `set` under `equiv`.
	pub fn equivalence_class_representatives<T>(set: Vec<T>, equiv: EquivalenceRelation<T>) -> Vec<T>		pub fn equivalence_class_representatives<T>(set: Vec<T>, equiv: EquivalenceRelation<T>) -> Vec<T>
	where T : Clone + PartialEq {		where T : Clone + PartialEq {
Line 744:		Line 745:
	}		}

	// Is the scale word ~~s = s(x, y, z) abstractly mv3?~~		/// Computes the maximum variety of a ternary scale word.
	pub fn maximum_variety(s: &str) -> usize {		pub fn maximum_variety(scale: &str) -> usize {
	let mut result = 0;		let mut result = 0;
	let floor_half: usize = s.len()/2;		let floor_half: usize = scale.len()/2;
	for l in 1..(floor_half+1) {		for slice_length in 1..(floor_half+1) {
	let mut sizes: BTreeSet<(usize, usize, usize)> = BTreeSet::new();		let mut sizes: BTreeSet<(usize, usize, usize)> = BTreeSet::new();
	for b in 0..(s.len()) {		for basepoint in 0..(scale.len()) {
	let mut size: (usize, usize, usize) = (0, 0, 0);		let mut size: (usize, usize, usize) = (0, 0, 0);
	let sl = &slice_cyclic_string(s, b, l);		let sl = &slice_cyclic_string(scale, basepoint, slice_length);
	let chars_in_sl = sl.chars();		let chars_in_sl = sl.chars();
	for ch in chars_in_sl {		for ch in chars_in_sl {
Line 769:		Line 770:
	}		}

	// Return the balance of `s` = `s`(x, y, z), defined as max { \| \|w\|_{x_i} - \|w'\|_{x_i} \| : x_i is a letter of `s` and k = len(w) = len(w') }.		/// Return the balance of `s` = `s`(x, y, z), defined as max { \| \|w\|_{x_i} - \|w'\|_{x_i} \| : x_i is a letter of `s` and k = len(w) = len(w') }.
	pub fn balance(scale: &str) -> usize {		pub fn balance(scale: &str) -> usize {
	if scale.len() <= 1 {		if scale.len() <= 1 {
Line 807:		Line 808:
	}		}

	// Function for computing two properties, maximum variety and balance, while executing the subroutine to extract words only once at a time for both properties.		/// Function for computing two properties, maximum variety and balance, while executing the subroutine to extract words only once at a time for both properties.
	pub fn max_variety_and_balance(s: &str) -> (usize, usize) {		pub fn max_variety_and_balance(scale: &str) -> (usize, usize) {
	if s.len() <= 1 {		if scale.len() <= 1 {
	(s.len(), 0)		(scale.len(), 0)
	} else {		} else {
	let mut mv_result = 0;		let mut mv_result = 0;
	let mut balance_result = 0;		let mut balance_result = 0;
	let (mut min_x, mut max_x, mut min_y, mut max_y, mut min_z, mut max_z) = (usize::MAX, 0, usize::MAX, 0, usize::MAX, 0);		let (mut min_x, mut max_x, mut min_y, mut max_y, mut min_z, mut max_z) = (usize::MAX, 0, usize::MAX, 0, usize::MAX, 0);
	let floor_half: usize = s.len()/2;		let floor_half: usize = scale.len()/2;
	for l in 1..(floor_half+1) {		for slice_length in 1..(floor_half+1) {
	let mut sizes: BTreeSet<(usize, usize, usize)> = BTreeSet::new();		let mut sizes: BTreeSet<(usize, usize, usize)> = BTreeSet::new();
	for b in 0..s.len() {		for basepoint in 0..scale.len() {
	let mut size: (usize, usize, usize) = (0, 0, 0);		let mut size: (usize, usize, usize) = (0, 0, 0);
	let sl = &slice_cyclic_string(s, b, l);		let sl = &slice_cyclic_string(scale, basepoint, slice_length);
	let chars_in_sl = sl.chars();		let chars_in_sl = sl.chars();
	for ch in chars_in_sl {		for ch in chars_in_sl {
Line 846:		Line 847:
	}		}
	}		}


	// Return a Christoffel word with `a` x's and `b` y's.		// Return a Christoffel word with `a` x's and `b` y's.

Inthar: /* lib.rs */

2023-12-08T05:00:00Z

lib.rs

← Older revision		Revision as of 05:00, 8 December 2023
Line 807:		Line 807:
	}		}

	// Function for computing two properties, maximum variety and balance, while executing the subroutine to extract words only once.		// Function for computing two properties, maximum variety and balance, while executing the subroutine to extract words only once at a time for both properties.
	pub fn max_variety_and_balance(s: &str) -> (usize, usize) {		pub fn max_variety_and_balance(s: &str) -> (usize, usize) {
	if s.len() <= 1 {		if s.len() <= 1 {