refactor: ✨ (#418)

* refactor: ✨ move in one commit

Eveything in modules should probably be changed to `exported` defs.
The idea is to move everything first to keep proper history.

* refactor: 📝 add modules readme (wip)

* refactor: ✨ small move

* refactor: 📝 changed nestring, updated modules readme

* refactor: 📝 to document or not to document

* fix: 🐛 themes

replaced the template to use `main` and regenerated them
from lemnos themes.

* Revert "fix: 🐛 themes"

This reverts commit 4918d3633c8d2d81950a0ed0cfd9eb84241bc886.

* refactor: ✨ introduce sourced

- Created a source `root` in which sourcable demos are stored.
  Some might get converted to modules later on.
- Moved some files to bin too.

* fix: 🐛 fehbg.nu

* fix: 🐛 modules/after.nu

* moved some other stuff around

---------

Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com>

modules/maths/math_functions.nu

@@ -0,0 +1,159 @@
+#Root with a custom denominator
+export def root [ denominator, num ] {
+	$num ** ( 1 / $denominator ) | math round  -p 10
+}
+
+#Cube root
+export def croot [num] {
+	$num ** ( 1 / 3 ) | math round -p 10
+}
+
+#Root with a custom scaler and denominator
+export def aroot [ scaler, denominator, num] {
+	$num ** ($scaler / $denominator) | math round -p 10
+}
+
+#calculate delta of the quadratic function
+export def delta [ a,#x^2 factor
+b, #x factor
+c #the rest
+] {
+	( $b ** 2 ) - ( 4 * $a * $c)
+}
+
+#Factorial of the given number
+export def fact [num: int] {
+	if $num >= 0 {
+		if $num < 2 {
+			$num
+		} else {
+			seq 2 $num | math product
+		}
+	} else {
+		error make -u {msg: "can only calculate non-negative integers"}
+	}
+}
+
+#Calculate roots of the quadratic function: ax^2+bx+x
+export def q_roots [
+	a 	# x^2
+	b	# x
+	c 	# independent term
+] {
+	let d = $b ** 2 - 4 * $a * $c
+	if $d > 0 {
+		let s = ($d | math sqrt)
+		let r1 = (($s - $b) / (2 * $a))
+		let r2 = (0 - (($s + $b) / (2 * $a)))
+
+		echo $"root #1: ($r1)"
+		echo $"root #2: ($r2)"
+	} else if $d == 0 {
+		let s = ($d | math sqrt)
+		let r = (($s - $b) / (2 * $a))
+
+		echo $"root:   ($r)"
+	} else {
+		let s = ((0 - $d) | math sqrt)
+		let r = ((0 - $b) / (2 * $a))
+		let i = ($s / (2 * $a))
+
+		echo $"root #1: ($r) + ($i)*i"
+		echo $"root #2: ($r) - ($i)*i"
+	}
+}
+
+#Check if integer is prime
+export def isprime [n: int] {
+	let max = ($n | math sqrt | math ceil)
+
+	let flag = ([[isPrime];[true]] | update isPrime {if ($n mod 2) == 0 { false } else { seq 3 1 $max | each { |it| if ($n mod $it) == 0 { false }}}})
+
+	if ($flag.isPrime.0 | is-empty) { echo 'prime' } else { echo 'not prime' }
+}
+
+#Prime list <= n
+export def primelist [n: int] {
+	let primes = [2 3]
+
+	let primes2 = (seq 5 2 $n | each {|it| if (isprime $it) == 'prime' {$it}})
+
+	$primes | append $primes2
+}
+
+#Multiplication table of n till max
+export def mtable [n: int, max: int] {
+	seq 1 $max | each {|it| echo $"($it)*($n) = ($n * $it)"}
+}
+
+#Check if year is leap
+export def isleap [year: int] {
+	if ( (($year mod 4) == 0 and ($year mod 100) != 0) or ($year mod 400) == 0 ) { echo "It is a leap year." } else { echo "It is not a leap year."}
+}
+
+#Greatest common divisior (gcd) between 2 integers
+export def gcd [a: int, b:int] {
+	if $a < $b {
+		gcd $b $a
+	} else if $b == 0 {
+		$a
+	} else {
+		gcd $b ($a mod $b)
+	}
+}
+
+#Least common multiple (lcm) between 2 integers
+export def lcm [a: int, b:int] {
+	if $a == $b and $b == 0 {
+		0
+	} else {
+		$a * ($b / (gcd $a $b))
+	}
+}
+
+#Decimal number to custom base representation
+export def dec2base [
+	n: string	#decimal number
+	b: string	#base in [2,16]
+] {
+	let base = if ( ($b | into int) < 2 or ($b | into int) > 16 ) {
+		echo "Wrong base, it must be an integer between 2 and 16"
+		10
+	} else {
+		$b | into int
+	}
+
+	let number = ($n | into int)
+
+	let chars = ['0' '1' '2' '3' '4' '5' '6' '7' '8' '9' 'A' 'B' 'C' 'D' 'E' 'F']
+
+	if $number == 0 {
+		''
+	} else {
+		let newNumber = (($number - ($number mod $base)) / $base)
+
+		[(dec2base $newNumber $base) ($chars | get ($number mod $base))] | str join
+	}
+}
+
+# Scale list to [a,b] interval
+export def scale-minmax [a, b,input?] {
+	let x = if ($input | is-empty) {$in} else {$input}
+
+	let min = ($x | math min)
+	let max = ($x | math max)
+
+	$x | each {|it| ((($it - $min) / ($max - $min)) * ($b - $a) + $a) }
+}
+
+# Scale every column of a table (separately) to [a,b] interval
+export def scale-minmax-table [a, b,input?] {
+	let x = if ($input | is-empty) {$in} else {$input}
+	let n_cols = ($x | transpose | length)
+	let name_cols = ($x | transpose | column2 0)
+
+	0..($n_cols - 1)
+	| each {|i|
+		($x | column2 $i) | scale-minmax $a $b | wrap ($name_cols | get $i)
+	} | reduce {|it, acc| $acc | merge {$it}}
+}