#tcl
# title, formula, topic/math domain, profession
proc name {short var names} { expr { ... } }
# usage: name args... multiple examples, -> result, units, notes
# Boundary conditions, real numbers, or numerical limitations, zingers
----
# Note: textbook and journal formulas may use
# implied multiplication by adjacency.
# Tcl expr requires explicit * operators,
# so adjacent symbols are written as A*B.
----

# Still checking V9 exposure and drafts.
# Some parts
# of the language Tcl V9 were actually changed,
# but not particularly the expr function.
So most of 21 procs should run unmodified on Tcl 9.

# One Liners for Beginners: Engineering & Math V4
# 7/14/2026
# Style follows the  Compendium "house" conventions,
# dead space near  expr ,
# usage comment & worked answer.
# All formulas below have different topics 
# Formulas  should complement student efforts.
# Conventional formulas are largely 
# from engr. math textbooks.
# Almost have to use single letter variables
# in some denser formulas for compactness. 
#  Draft on Compatibility Check with V9 
console show
# All 21 procs above were run under Tcl 8.6.14.
#  Some parts
# of the language Tcl 9  actually changed,
# but not particularly the expr function, 
# so 21 should run unmodified on Tcl 9.

# Tcl 8.6 or greater required
# Naming convention: all proc and variable names are 12-15
# characters, descriptive, and domain-neutral so the engine
# can serve any subject area without modification.
# 
# ----
# Compatible with Tcl/Tk (Tool Command Language / Toolkit) 8.6+
# Written for Windows 11 on ActiveState Tcl.
# Use Pure 7-bit ASCII code, no Unicode characters used anywhere.
# ----
# Program deck may contain multiple estimation procs.
# Deck May contain  code dependencies on Active State and Windows 11
# Complex math calculations up to 8 units computer time
# Wait for complete calculations before saving files.
# Proc names and variables names need to be very human readable
# and very explanatory. 
# Avoid variables with single letter names. 
# Whereas single letter names are known to lead
# to many historic errors. 
# Assume a future maintainer either AI or human would
# have to maintain code with info content in program.
# This is Experimenting Draft,
# and not a replacement for TCL Core. 
# This is a hacker's patch, not rigorously derived.
# appears correct solutions for autotests.
# TCL Club 7/14/2026 
# 
#
## Mechanical / Structural

# tcl
#   power dissipated in a resistor, P = I^2 * R
proc power_dissipated {current resistance} { expr { $current**2 * $resistance } }
#   Usage power_dissipated 2 10  returns 40   (watts)

#   spring constant from Hooke's law, k = F / x
proc spring_constant {force displacement} { expr { $force / $displacement } }
#   Usage spring_constant 50 0.25  returns 200   (N/m)

#   simply supported beam, center point load, max deflection
#   delta = F * L^3 / (48 * E * I)
proc beam_deflection {force length modulus_e moment_i} { expr { $force*$length**3 / (48.*$modulus_e*$moment_i) } }
#   Usage beam_deflection 1000. 2. 200.e9 8.e-6  returns 0.0001042   (meters, ~0.1 mm)

#   axial stress, sigma = F / A
proc axial_stress {force area} { expr { $force / $area } }
#   Usage axial_stress 5000. 0.0002  returns 25000000.0   (Pa, 25 MPa)

#   gear ratio, driven teeth over driver teeth
proc gear_ratio {driven_teeth driver_teeth} { expr { (1.*$driven_teeth) / $driver_teeth } }
#   Usage gear_ratio 40 20  returns 2.0
#

## Fluids / Thermal
# Listing alternatives here.

# Reynolds number, Re=rho*v*D/mu,
# abbrev: rho=density(kg/m³), v=vel(m/s), D=diam(m), mu=visc(Pa·s), units: dimensionless
proc reynolds {rho v D mu} { expr {$rho*$v*$D/$mu} }
# Usage: reynolds 1000 2 0.05 0.001 -> 100000

# conductive heat flow, Q=k*A*ΔT/thick, 
# abbrev: k=conductivity(W/m·K), A=area(m²), ΔT=temp diff(K), thick=thickness(m), units: W (watts)
proc conductive_heat_flow {k A t1 t2 thick} { expr {$k*$A*($t1-$t2)/$thick} }
# Usage: conductive_heat_flow 0.5 2 300 290 0.1 -> 100 W

# tcl
#   Reynolds number, Re = rho * v * D / mu
proc reynolds_number_2 {density velocity diameter viscosity} { expr { $density*$velocity*$diameter/$viscosity } }
#   Usage reynolds_number 1000. 2. 0.05 0.001  returns 100000.0   (turbulent flow)

#   Fourier conduction, Q = k * A * (T1-T2) / thickness
proc conductive_heat_flow_2 {k_conductivity area t1 t2 thickness} { expr { $k_conductivity*$area*($t1-$t2)/$thickness } }
#   Usage conductive_heat_flow 0.5 2. 300. 290. 0.1  returns 100.0   (watts)
#

# Electrical



# capacitor charge, Q=C*V,
# abbrev: C=capacitance(F), V=voltage(V), units: C (coulombs)
proc capacitor_charge {C V} { expr {$C*$V} }
# Usage: capacitor_charge 0.001 12 -> 0.012 C

# RC time constant, tau=R*C, 
# abbrev: R=resistance(ohm), C=capacitance(F), units: s (seconds)
proc rc_time_constant {R C} { expr {$R*$C} }
# Usage: rc_time_constant 1000 0.000001 -> 0.001 s
 


## Dynamics

#  tcl
#   pendulum period (small angle), T = 2*pi*sqrt(L/g)
proc pendulum_period {length} { expr { 2.*acos(-1)*sqrt($length/9.81) } }
#   Usage pendulum_period 1.  returns 2.0064   (seconds, 1 meter pendulum)

#   projectile range on level ground, R = v^2 * sin(2*theta) / g,  theta in radians
proc projectile_range {velocity angle_rad} { expr { $velocity**2 * sin(2.*$angle_rad) / 9.81 } }
#   Usage projectile_range 20. [expr {45.*acos(-1)/180.}]  returns 40.7747   (meters, 45 degree launch)


## Math
# tcl
#   quadratic formula, positive root, x = (-b + sqrt(b^2-4ac)) / 2a
proc quad_root_pos {aa bb cc} { expr { (-$bb+sqrt($bb**2-4.*$aa*$cc))/(2.*$aa) } }
#   Usage quad_root_pos 1. -3. 2.  returns 2.0

#   distance between two points in 3D space
proc distance_3d {x1 y1 z1 x2 y2 z2} { expr { sqrt(($x2-$x1)**2+($y2-$y1)**2+($z2-$z1)**2) } }
#   Usage distance_3d 0. 0. 0. 3. 4. 12.  returns 13.0

#   geometric mean of two numbers
proc geometric_mean2 {aa bb} { expr { sqrt($aa*$bb) } }
#   Usage geometric_mean2 4. 16.  returns 8.0

#   harmonic mean of two numbers
proc harmonic_mean2 {aa bb} { expr { 2.*$aa*$bb/($aa+$bb) } }
#   Usage harmonic_mean2 4. 16.  returns 6.4

#   factorial, needed for combinations below
proc fact {n} { expr { $n<2 ? 1 : $n*[fact [expr {$n-1}]] } }
#   Usage fact 5  returns 120
#   recursion limited, tricky to install

#   combinations, n choose r
proc n_choose_r {n r} { expr { [fact $n] / ([fact $r]*[fact [expr {$n-$r}]]) } }
#   Usage n_choose_r 5 2  returns 10

#   sum of an arithmetic series, S = n/2 * (2a + (n-1)d)
proc arithmetic_series_sum {first_term common_diff n_terms} { expr { $n_terms/2.*(2.*$first_term+($n_terms-1)*$common_diff) } }
#   Usage arithmetic_series_sum 2. 3. 5  returns 40.0   (2+5+8+11+14)

#   3D vector dot product
proc dot_product3 {x1 y1 z1 x2 y2 z2} { expr { $x1*$x2+$y1*$y2+$z1*$z2 } }
#   Usage dot_product3 1. 2. 3. 4. 5. 6.  returns 32.0

#   3D vector magnitude
proc vector_magnitude3 {x y z} { expr { sqrt($x**2+$y**2+$z**2) } }
#   Usage vector_magnitude3 3. 4. 12.  returns 13.0

#   logistic growth, N = K / (1 + ((K-N0)/N0)*exp(-r*t))
proc logistic_growth {carrying_capacity initial_pop rate time} { expr { $carrying_capacity/(1.+(($carrying_capacity-$initial_pop)/$initial_pop)*exp(-$rate*$time)) } }
#   Usage logistic_growth 1000. 10. 0.3 10.  returns 168.6   (population after 10 time units)

Draft, testing under V9 migration???

# tcl
# clamp x to [lo, hi], arithmetic domain, control systems
proc clamp {x lo hi} { expr {$x < $lo ? $lo : ($x > $hi ? $hi : $x)} }
# usage: clamp 17 0 10  -> 10

# tcl
# even test, number theory domain, programming interviews
proc is_even {n} { expr {($n % 2) == 0} }
# usage: is_even 42  -> 1

# tcl
# not the best style, but alternatives???

# Quantum computer

# Quantum
proc qubit_norm2 {a b} { expr {$a*$a + $b*$b} }     ; # qubit purity proxy, p = a^2 + b^2
proc bloch_theta {a} { expr {2*acos($a)} }          ; # Bloch angle proxy, theta = 2*acos(a)
proc qphase {re im} { expr {atan2($im,$re)} }       ; # phase difference, phi = atan2(im, re)
proc fringe {phi} { expr {cos($phi)} }              ; # interference fringe, cos(phi)
proc mixing {p} { expr {$p*(1-$p)} }                ; # two-state mixing, p*(1-p)

# Quantum / Math
# qubit norm squared, p=a²+b², abbrev: a b=amplitudes, units: dimensionless
proc qubit_norm2 {a b} { expr {$a*$a + $b*$b} }
# Usage: qubit_norm2 0.6 0.8 -> 1.0

# Bloch sphere angle, theta=2*acos(a), abbrev: a=|0> amplitude, units: rad (radians)
proc bloch_theta {a} { expr {2*acos($a)} }
# Usage: bloch_theta 0.7071 -> 1.5708 rad

# Note. This code is using validation checks, lengthy.

# tcl
# qubit purity proxy, p = a^2 + b^2, quantum computer domain, researchers
# variables: a b = real amplitudes
proc qubit_norm2 {a b} { if {![string is double -strict $a] || ![string is double -strict $b]} { return -code error "qubit_norm2: numeric arguments required" }; expr {$a*$a + $b*$b} }
# usage: qubit_norm2 0.6 0.8 -> 1
# abbrev: the short names fit amplitude algebra.

# tcl
# Bloch angle proxy, theta = 2 acos(a), quantum computer domain, researchers
# variables: a = amplitude on |0>
proc bloch_theta {a} { if {![string is double -strict $a]} { return -code error "bloch_theta: numeric argument required" }; if {$a < -1 || $a > 1} { return -code error "bloch_theta: amplitude must be in [-1, 1]" }; expr {2*acos($a)} }
# usage: bloch_theta 0.70710678 -> about 1.5708
# abbrev: a is a compact amplitude symbol.

# tcl
# phase difference, phi = atan2(im, re), quantum computer domain, researchers
# variables: re = real part, im = imaginary part
proc qphase {re im} { if {![string is double -strict $re] || ![string is double -strict $im]} { return -code error "qphase: numeric arguments required" }; expr {atan2($im,$re)} }
# usage: qphase 1 1 -> 0.7853981633974483
# abbrev: re and im are standard complex-number shorthand.

# tcl
# interference fringe score, s = cos(phi), quantum computer domain, researchers
# variables: phi = phase
proc fringe {phi} { if {![string is double -strict $phi]} { return -code error "fringe: numeric argument required" }; expr {cos($phi)} }
# usage: fringe 0 -> 1
# abbrev: phi is the conventional phase symbol.

# tcl
# two-state mixing, m = p(1-p), quantum computer domain, researchers
# variables: p = probability
proc mixing {p} { if {![string is double -strict $p]} { return -code error "mixing: numeric argument required" }; if {$p < 0 || $p > 1} { return -code error "mixing: probability must be in [0,1]" }; expr {$p*(1-$p)} }
# usage: mixing 0.5 -> 0.25
# abbrev: p is the usual probability symbol.