Struct Tp

pub struct Tp<T>(/* private fields */);

The Triangle of Power

This struct formalizes the six fundamental transformations that interrelate exponentiation, roots, and logarithms. These operations are not independent but form a structured system of shifts and rotations, governed by underlying symmetries. Each function belongs to one of two interwoven three-function cycles, with structured transformations that preserve relationships between base, exponent, and power.

The system follows a modular shift structure, where functions transition through well-defined rotations (shr and shl) or switch between cycles through selective shifts. This framework does not introduce new computations but instead exposes the inherent structure of scaling operations, making explicit the relationships that underlie exponentiation.

Structure and Transformations

The six operations are arranged into two distinct three-function cycles, each forming a closed loop under cyclic shifts. Functions transition within their cycle using forward (shr) or backward (shl) shifts, while selective shifts allow movement between cycles. These relationships define the full space of exponentiation-like transformations.

Rotation Groups

Each function belongs to one of two interwoven three-function cycles:

• Exponentiation-Logarithm Cycle: pow → apow → log → pow
• Root-Antilogarithm Cycle: root → aroot → alog → root

Within each cycle, functions are related by modular shift transformations:

Function	Static Operand Order	Forward Shift (shr)	Backward Shift (shl)	Selective Shift
pow	(bep)	apow (epb)	log (pbe)	root (peb)
apow	(epb)	log (pbe)	pow (bep)	aroot (bpe)
log	(pbe)	alog (ebp)	pow (bep)	apow (epb)
root	(bpe)	aroot (peb)	alog (ebp)	apow (epb)
aroot	(peb)	alog (ebp)	root (bpe)	pow (bep)
alog	(ebp)	pow (bep)	root (bpe)	aroot (bpe)

Shift Transformations

Each function is connected to others by structured shifts:

• Cycle shifts (shr, shl) maintain movement within the same rotation group.
• Selective shifts (X << Y == Z >>) enable transitions between cycles.

These shifts behave modularly, ensuring all transformations preserve valid operand relationships.

By formalizing these relationships, this struct provides a systematic way to express, explore, and manipulate exponentiation-based transformations, making explicit the structure that underlies their behavior.

Implementations

impl Tp<f64>

pub fn pow(&self, exponent: Self) -> Self

Available on crate feature _float_f64 only.

Computes power by raising (self as base) to exponent.

• math: $b^e = p$
• func: pow(base, exponent) = base^exponent = power
• meta: base ⊕ exponent = power
• symb: ^ → b^e=p

Pairs by

self	param	result	shr	shl
= base	= exponent	= power	>>	<<
aroot	root	alog	apow	log

pub fn apow(&self, power: Self) -> Self

Available on crate feature _float_f64 only.

Computes base, such that raising it to (self as exponent) produces power.

• math: $e \sqrt[p]{p} = b$ ⟺ $p^{1/e} = b$
• func: apow(exponent, power) = power^(1/exponent) = base
• meta: exponent ⊕ power = base
• symb: ^ → e^p=b

Pairs by

self	param	result	shr	shl
= exponent	= power	= base	>>	<<
alog	aroot	root	log	pow

pub fn root(&self, exponent: Self) -> Self

Available on crate feature _float_f64 only.

Computes base, such that raising it to exponent produces (self as power).

• math: $p^{(1/e)} = b$ ⟺ $e \sqrt[p]{p} = b$
• func: root(power, exponent) = power^(1/exponent) = base
• meta: power ⊕ exponent = base
• symb: √ → p√e=b

Pairs by

self	param	result	shr	shl
= power	= exponent	= base	>>	<<
log	pow	apow	alog	aroot

pub fn aroot(&self, power: Self) -> Self

Available on crate feature _float_f64 only.

Computes exponent, such that raising (self as base) to it produces power.

• math: $b^{(1/p)} = e$
• func: aroot(base, power) = exponent
• meta: base ⊕ power = exponent
• symb: √ → b√p=e

Pairs by

self	param	result	shr	shl
= base	= power	= exponent	(b>> p>> e>>)	(b<< p<< e<<
pow	apow	log	root	root

pub fn log(&self, base: Self) -> Self

Available on crate feature _float_f64 only.

Computes exponent as the logarithm of (self as power) with respect to base.

• math: $\log_b(p) = e$
• func: log(power, base) = log_base(power) = exponent
• meta: power ⊕ base = exponent
• symb: @ → p@b=e

Pairs by

self	param	result	reverse	shl
= power	= base	= exponent	(??)	(b<< e<< p<<)
root	alog	aroot	alog ??	log

pub fn alog(&self, base: Self) -> Self

Available on crate feature _float_f64 only.

Computes power, using (self as exponent) and base.

• math: $b^e = p$
• func: alog(exponent, base) = base^exponent = power
• meta: exponent ⊕ base = power
• symb: @ → e@b=p

Pairs by

self	param	result	reverse	shl
= exponent	= base	= power	(??)	(b<< e<< p<<)
apow	log	pow	log ??	log