Metadata-Version: 2.4
Name: gaskill
Version: 3.1.0
Summary: A comprehensive Python library for game development utilities
Home-page: https://github.com/limo1027/gaskill
Author: Limo
Author-email: 28009663@qq.com
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.6
Description-Content-Type: text/markdown
License-File: LICENSE
Dynamic: author
Dynamic: author-email
Dynamic: classifier
Dynamic: description
Dynamic: description-content-type
Dynamic: home-page
Dynamic: license-file
Dynamic: requires-python
Dynamic: summary

# Mlib
一个0依赖库

不依赖random，math等标准库

纯python制作，不使用C拓展

快速开始

```bash
git clone https://github.com/limo1027/mlib
cd mlib
python -c "from gaskill.test import run_test; run_test()"
```

[Learn More?](https://limo1027.github.io/mlib)

# 最新版本差异: 在plus中添加一个新的数据库，读极快，但是写偏慢MLIB HELP
A pure Python mathematics and utilities library


============================================================================
ABC - ABSTRACT BASE CLASSES (zero dependencies)
============================================================================

  ABC - Abstract base class metaclass
  ABC() - Base class with ABCMeta

  abstractmethod(func) - Mark method as abstract
  abstractclassmethod(func) - Mark class method as abstract
  abstractstaticmethod(func) - Mark static method as abstract
  abstractproperty(func) - Mark property as abstract

USAGE:
  class MyClass(ABC):
      @abstractmethod
      def my_method(self): pass


============================================================================
SMATH - MATHEMATICAL FUNCTIONS
============================================================================

CONSTANTS:
  pi = 3.141592653589793
  e = 2.718281828459045
  tau = 2*pi
  phi = 1.618033988749895
  EPSILON = 1e-18
  INF = float('inf')

ARITHMETIC:
  gcd(a,b) - Greatest common divisor
  lcm(a,b) - Least common multiple
  factorial(n) - n! (supports float via Gamma function)
  comb(n,k) - Combination C(n,k)
  perm(n,k) - Permutation P(n,k)
  is_prime(n) - Primality test (deterministic for n < 2^64)
  is_prime_fast(n) - Miller-Rabin primality test
  prime_factors(n) - Prime factorization, returns dict
  fibonacci(n) - nth Fibonacci number
  egcd(a,m) - Modular inverse of a mod m
  relative_error(self_val, real_val) - Relative error

POWER AND ROOTS:
  sqrt(x) - Square root (returns Complex for negative)
  cbrt(x) - Cube root
  root(x, n=2) - nth root
  pow(base, exp) - Built-in, works with Complex

EXPONENTIAL AND LOGARITHMS:
  exp(x) - e^x (supports Complex)
  ln(x) - Natural logarithm (supports Complex)
  log(x, base=None) - Logarithm with specified base
  log10(x) - Base-10 logarithm
  log2(x) - Base-2 logarithm

TRIGONOMETRY (angles in radians):
  sin(x) - Sine
  cos(x) - Cosine
  tan(x) - Tangent
  cot(x) - Cotangent
  sec(x) - Secant
  csc(x) - Cosecant
  asin(x) - Arc sine
  acos(x) - Arc cosine
  atan(x) - Arc tangent
  atan2(y,x) - Two-argument arc tangent
  sinc(x) - Sinc function sin(x)/x
  versin(x) - Versine 1-cos(x)
  coversin(x) - Coversine 1-sin(x)
  exsec(x) - Exsecant sec(x)-1
  excsc(x) - Excosecant csc(x)-1
  hav(x) - Haversine (1-cos(x))/2
  archav(x) - Inverse haversine

HYPERBOLIC:
  sinh(x) - Hyperbolic sine
  cosh(x) - Hyperbolic cosine
  tanh(x) - Hyperbolic tangent
  coth(x) - Hyperbolic cotangent
  sech(x) - Hyperbolic secant
  csch(x) - Hyperbolic cosecant
  asinh(x) - Inverse hyperbolic sine
  acosh(x) - Inverse hyperbolic cosine
  atanh(x) - Inverse hyperbolic tangent
  acoth(x) - Inverse hyperbolic cotangent
  asech(x) - Inverse hyperbolic secant
  acsch(x) - Inverse hyperbolic cosecant

GAMMA AND BETA:
  gamma(z) - Gamma function
  log_gamma(z) - Log Gamma function ln(|Gamma(z)|)
  digamma(z) - Digamma function (approximate)
  beta(a,b) - Beta function B(a,b) = Gamma(a)*Gamma(b)/Gamma(a+b)

GUDERMANNIAN:
  gudermannian(x) - Gudermannian function gd(x) = 2*atan(tanh(x/2))
  inv_gudermannian(x) - Inverse Gudermannian

ANGLE CONVERSION:
  rad(deg) - Degrees to radians
  deg(rad) - Radians to degrees
  normalize_angle(angle) - Normalize to [-pi, pi]
  wrap(x,a,b) - Wrap x into [a,b)
  clamp(x,min,max) - Clamp to range
  lerp(a,b,t) - Linear interpolation
  inv_lerp(a,b,v) - Inverse linear interpolation
  map(x,in_min,in_max,out_min,out_max,clamp_result=False) - Remap values

ROUNDING:
  floor(x) - Floor
  ceil(x) - Ceiling
  trunc(x) - Truncate
  fract(x) - Fractional part
  sign(x) - Sign: -1, 0, 1

VECTOR UTILITIES:
  hypot(*args) - Euclidean norm
  distance(p1,p2) - Distance between points
  angle_between(v1,v2) - Angle between vectors
  nearest(value, candidates) - Nearest value in list
  product(arr) - Product of array

EXCEPTIONS:
  MathError - Base math exception
  UndeFinedError - Undefined operation error


============================================================================
COMPLEX - COMPLEX NUMBERS
============================================================================

  Complex(real, imag=None) - Complex number class

PROPERTIES:
  real - Real part
  imag - Imaginary part
  r - Magnitude (modulus)
  theta - Phase (argument)

METHODS:
  conjugate() - Return conjugate
  copy() - Return copy

OPERATORS:
  +, -, *, /, **, -, +, ==, !=, %, abs, hash

CREATION:
  Complex(3,4) -> (3+4i)
  Complex("3+4i") -> (3+4i)
  Complex(1j) -> i


============================================================================
SFRAC - EXACT FRACTIONS
============================================================================

  Frac(numerator, denominator=None) - Exact rational number

PROPERTIES:
  n - Numerator
  d - Denominator

METHODS:
  as_percent(precision=0) - Percent string with precision digits

OPERATORS:
  +, -, *, /, **, -, +, ==, !=, <, <=, >, >=, %, abs, ~ (reciprocal)
  int(), float(), hash(), round()

FORMATTING:
  format(f, '%') - Percent: "25%"
  format(f, '.1%') - Percent with precision: "25.0%"
  format(f, 'l') - LaTeX: "\frac{1}{2}"
  format(f, 'm') - Mixed: "3 + 1/2"
  format(f, '/') - Fraction: "1/2"
  format(f, '.3f') - Float: "0.333"


============================================================================
SVECTOR - 2D, 3D, 4D VECTORS
============================================================================

  vec2(x=0, y=0) - 2D vector
  vec3(x=0, y=0, z=0) - 3D vector
  vec4(x=0, y=0, z=0, w=0) - 4D vector

VEC2 METHODS:
  dot(other) - Dot product
  cross(other) - 2D cross product (scalar)
  length() - Magnitude
  length_squared() - Squared magnitude
  normalize() - Unit vector (zero returns zero)
  distance(other) - Distance to other vector
  distance_squared(other) - Squared distance
  lerp(other, t) - Linear interpolation
  rotate(angle) - Rotate by angle (radians)
  rotate_around(center, angle) - Rotate around a point
  reflect(normal) - Reflect vector
  project(onto) - Project onto another vector
  reject(onto) - Reject (perpendicular component)
  angle() - Vector angle (radians)
  angle_to(other) - Angle to other vector
  perpendicular() - Perpendicular vector (CCW 90 deg)
  scale(sx, sy=None) - Scale vector
  copy() - Return copy

VEC2 STATIC:
  zero(), one(), up(), down(), left(), right()
  from_angle(angle) - Unit vector from angle
  lerp_batch(v1, v2, t_values) - Batch linear interpolation

VEC3 METHODS:
  dot(other) - Dot product
  cross(other) - Cross product
  length() - Magnitude
  length_squared() - Squared magnitude
  normalize() - Unit vector
  distance(other) - Distance
  distance_squared(other) - Squared distance
  lerp(other, t) - Linear interpolation
  reflect(normal) - Reflect vector
  project(onto) - Project onto vector
  reject(onto) - Reject (perpendicular component)
  rotate_x(angle) - Rotate around X axis
  rotate_y(angle) - Rotate around Y axis
  rotate_z(angle) - Rotate around Z axis
  rotate_around(center, axis, angle) - Rotate around point and axis
  scale(sx, sy=None, sz=None) - Scale vector
  to_tuple() - Convert to tuple
  to_list() - Convert to list
  copy() - Return copy

VEC3 STATIC:
  zero(), one(), up(), down(), left(), right(), forward(), back()
  from_tuple(t), from_list(lst)

VEC4 METHODS:
  dot(other) - Dot product
  cross(other) - 3D cross product (first 3 components)
  length() - Magnitude
  length_squared() - Squared magnitude
  normalize() - Unit vector
  distance(other) - Distance
  distance_squared(other) - Squared distance
  lerp(other, t) - Linear interpolation
  reflect(normal) - Reflect vector
  project(onto) - Project onto vector
  reject(onto) - Reject (perpendicular component)
  to_vec3(w_divide=True) - Convert to vec3 (homogeneous divide)
  to_tuple(), to_list() - Convert to tuple/list
  to_rgba() - Convert to RGBA tuple (0-255)
  to_rgb() - Convert to RGB tuple (0-255)
  copy() - Return copy

VEC4 STATIC:
  zero(), one(), unit_x(), unit_y(), unit_z(), unit_w()
  from_vec3(v, w=1.0), from_rgba(r,g,b,a=255), from_tuple(t), from_list(lst)

SHORTCUT FUNCTIONS:
  v2(x=0, y=0), v3(x=0, y=0, z=0), v4(x=0, y=0, z=0, w=0)
  vlerp(v1, v2, t), distance(v1, v2), dot(v1, v2), cross(v1, v2)
  normalize(v), angle_between(v1, v2)


============================================================================
SMATRIX - MATRIX OPERATIONS
============================================================================

  Matrix(data) - General matrix class

CREATION:
  Matrix([[a,b],[c,d]]) - From 2D list
  Matrix([1,2,3]) - Row vector
  matrix(data) - Shortcut for Matrix(data)

PROPERTIES:
  rows, cols, T (transpose)

METHODS:
  transpose() - Transpose matrix
  trace() - Trace (diagonal sum)
  det() - Determinant
  inverse() - Inverse matrix
  rank() - Matrix rank
  lu_decomposition() - Returns (L, U)
  copy() - Deep copy
  submatrix(row_start,row_end,col_start,col_end) - Extract submatrix
  minor(i,j) - Minor (determinant with row i, col j removed)
  cofactor(i,j) - Cofactor
  adjugate() - Adjugate matrix
  frobenius_norm() - Frobenius norm
  infinity_norm() - Infinity norm (row sum)
  one_norm() - 1-norm (column sum)
  is_symmetric() - Check symmetric
  is_identity() - Check identity matrix
  is_diagonal() - Check diagonal matrix
  diagonal() - Extract diagonal
  to_vector() - Convert to list if vector

OPERATORS:
  +, -, *, / (scalar), ==, -, []

SPECIAL MATRICES:
  rotation_matrix_2d(theta) - 2D rotation
  rotation_matrix_x(theta), rotation_matrix_y(theta), rotation_matrix_z(theta)
  scaling_matrix_2d(sx, sy=None) - 2D scaling
  scaling_matrix_3d(sx, sy=None, sz=None) - 3D scaling
  translation_matrix_2d(tx, ty) - 2D translation (3x3 homogeneous)
  translation_matrix_3d(tx, ty, tz) - 3D translation (4x4 homogeneous)

FUNCTIONS:
  solve_linear(A, b) - Solve Ax = b
  eigenvalues_2x2(matrix) - Eigenvalues of 2x2 matrix
  kronecker(A,B) - Kronecker product
  outer_product(v1,v2) - Outer product
  matrix_from_func(func, rows, cols=None, start=(0,0)) - Create from function


============================================================================
SQUATERNION - QUATERNIONS FOR 3D ROTATION
============================================================================

  Quaternion(w=1.0, x=0.0, y=0.0, z=0.0) - Quaternion class

IDENTITY AND ZERO:
  IDENTITY = Quaternion(1,0,0,0)
  ZERO = Quaternion(0,0,0,0)

METHODS:
  copy() - Return copy
  conjugate() - Conjugate quaternion
  norm() - Norm (magnitude)
  norm_squared() - Squared norm
  normalize() - Unit quaternion
  inverse() - Inverse quaternion
  dot(other) - Dot product
  to_axis_angle() - Returns (axis, angle) tuple
  to_matrix() - Convert to 3x3 rotation matrix
  rotate_vector(v) - Rotate a vector

STATIC METHODS:
  from_axis_angle(axis, angle) - Create from axis-angle
  from_euler(roll, pitch, yaw) - Create from Euler angles (Z-Y-X)
  from_two_vectors(v1, v2) - Create rotation from v1 to v2

OPERATORS:
  +, -, *, / (scalar), -, ==, !=, [] (index)

FUNCTIONS:
  slerp(q1, q2, t) - Spherical linear interpolation
  nlerp(q1, q2, t) - Normalized linear interpolation
  squad(q0, q1, q2, q3, t) - Spherical quadrangle interpolation
  angular_velocity(q1, q2, dt) - Angular velocity between quaternions
  integrate_angular_velocity(q, omega, dt) - Integrate angular velocity
  look_at(eye, target, up=None) - Create quaternion looking at target
  random_quaternion(rng=None) - Random unit quaternion


============================================================================
SRANDOM - RANDOM NUMBER GENERATOR
============================================================================

  Random(seed=None) - Deterministic PRNG

METHODS:
  seed(seed) - Reset seed
  next(a=0, b=9) - Next random integer in [a,b]
  randint(a,b) - Random integer in [a,b]
  random() - Random float in [0,1)
  random_float(start,end) - Random float in [start,end]
  choice(candidates) - Random element from list
  choices(arr, weight=None) - Weighted random selection
  shuffle(items) - Shuffle list in-place
  shuffle_copy(items) - Return shuffled copy
  sample(items, k) - Random k elements without replacement
  gauss(mu=0.0, sigma=1.0) - Gaussian (normal) distribution
  random_from_func(func, x_min, x_max, step=0.01, y_max=None) - Sample from function
  uuid() - Generate UUID v4
  random_ascii(length=16, charset='ascii') - Random ASCII string
  roll(expr) - Roll dice expression (e.g., "2d6+3")
  hash(seed) - Custom hash function
  hash_digit(n) - Digit hash

CHARSETS for random_ascii:
  'ascii' - Printable ASCII (33-126)
  'alnum' - Alphanumeric
  'alpha' - Letters only
  'digit' - Digits only
  'hex' - Hexadecimal digits
  'base64' - Base64 alphabet
  'all' - All 256 bytes

GLOBAL FUNCTIONS:
  random(rng=None) - Random float
  randint(a,b,rng=None) - Random integer
  choice(seq,rng=None) - Random choice
  shuffle(seq,rng=None) - Shuffle list
  sample(seq,k,rng=None) - Random sample
  random_ascii(length=16, charset='ascii', rng=None) - Random string


============================================================================
SCOLOR - COLOR MANIPULATION
============================================================================

FUNCTIONS:
  rgb(r,g,b) - RGB color tuple (0-255)
  rgba(r,g,b,a=255) - RGBA color tuple (0-255)
  hex_to_rgb(hex_str) - Hex string to RGB (e.g., "#FF0000" -> (255,0,0))
  rgb_to_hex(r,g,b) - RGB to hex string

CONVERSIONS:
  rgb_to_hsv(r,g,b) - RGB to HSV (h: 0-360, s: 0-1, v: 0-1)
  hsv_to_rgb(h,s,v) - HSV to RGB (0-255)
  rgb_to_cymb(r,g,b) - RGB to CYMB (CMYK variant)
  cymb_to_rgb(c,y,m,k) - CYMB to RGB

COLOR OPERATIONS:
  complementary(color, mode='rgb') - Complementary color
  color_lerp(c1,c2,t) - Color linear interpolation
  blend(c1,c2, mode='normal', alpha=0.5) - Color blending
  gradient_at(color_dict, t) - Sample gradient at t
  gradient_range(color_dict, steps=256) - Generate gradient list
  grayscale(color) - Convert to grayscale
  invert(color) - Invert color
  adjust_brightness(color, factor) - Adjust brightness
  adjust_saturation(color, factor) - Adjust saturation
  adjust_hue(color, degrees) - Adjust hue
  set_alpha(color, alpha) - Set alpha channel
  premultiply_alpha(color) - Premultiply alpha
  distance(c1,c2) - Euclidean color distance
  luminance(color) - Perceived luminance (0-1)
  contrast_ratio(c1,c2) - WCAG contrast ratio
  is_dark(color, threshold=0.5) - Check if dark
  is_light(color, threshold=0.5) - Check if light
  mix(c1,c2, amount=0.5) - Mix colors
  random_color(rng=None) - Random RGB color

BLEND MODES:
  'normal', 'multiply', 'screen', 'overlay', 'add', 'subtract', 'difference', 'average'

PREDEFINED COLORS:
  WHITE, BLACK, RED, GREEN, BLUE, YELLOW, PURPLE, ORANGE, CYAN, GRAY
  BROWN, PINK, GOLD, MAGENTA, BACKGROUND, LIGHT_BLUE, LIGHT_GRAY
  LIGHT_ORANGE, LIGHT_GREEN, LIGHT_BROWN, LIGHT_PINK, LIGHT_PURPLE
  LIGHT_CYAN, LIGHT_YELLOW, LIGHT_CORAL, DARK_GREEN, DARK_BLUE
  DARK_RED, DARK_GOLD, DARK_PURPLE, DARK_BROWN, DARK_CYAN, DARK_ORANGE
  DARK_GRAY, DARK_PINK, AQUA, LAVENDER, CORAL, TEAL, INDIGO, VIOLET
  MAROON, OLIVE, NAVY, LIME, FUCHSIA, SILVER
  PRIMARY, SECONDARY, SUCCESS, WARNING, ERROR, INFO, TRANSPARENT


============================================================================
SGEOMETRY - 2D GEOMETRY
============================================================================

  Rect(x=0, y=0, w=0, h=0, angle=0) - Rectangle (angle in radians)
  Circle(center, radius) - Circle
  Polygon(points) - Polygon (vec2 or tuples)
  Line2(p1, p2) - 2D line segment

RECT PROPERTIES:
  x, y, w, h, angle (degrees), left, right, top, bottom, center
  topleft, topright, bottomleft, bottomright, width, height, area

RECT METHODS:
  collide_point(x, y) - Point inside rect
  collide_rect(other) - Rect vs rect collision
  collide_circle(circle) - Rect vs circle collision
  inflate(dw, dh) - Expand rect
  expand(*args) - Expand to include point or rect
  move(dx, dy) - Move rect
  union(other) - Bounding box of two rects
  get_rects(step=10) - Convert to AABB rectangle list (for rendering)

CIRCLE PROPERTIES:
  center, radius, area

CIRCLE METHODS:
  collide_point(x, y) - Point inside circle
  collide_circle(other) - Circle vs circle
  collide_rect(rect) - Circle vs rect
  get_rects(step=10) - Convert to AABB rectangle list

POLYGON METHODS:
  vertices - List of vec2
  edges - List of edge vectors
  normals - List of outward normals
  contains_point(point) - Point in polygon test
  contains_point_accurate(point) - Point in or on polygon
  get_aabb() - Bounding box (min_x, min_y, w, h)
  convex_hull() - Compute convex hull (returns Polygon)
  triangulate() - Triangulate (ear clipping)
  collide_rect(rect) - Polygon vs rect
  collide_polygon(other) - Polygon vs polygon (SAT)
  move(dx, dy) - Translate polygon
  rotate(angle, center=None) - Rotate polygon
  scale(factor, center=None) - Scale polygon
  get_rects(step=10) - Convert to AABB rectangle list

LINE2 METHODS:
  length() - Line length
  closest_point(p) - Closest point on line
  collide_point(x,y,tolerance=0.1) - Point near line
  intersect_line(other) - Line-line intersection

RAY FUNCTIONS:
  raycast_rect(ray_origin, ray_dir, rect) - Ray vs rect collision
  reflect(vector, normal) - Reflect vector

SHORTCUTS:
  rect(x,y,w,h,angle=0), circle(center, radius), line(p1,p2)


============================================================================
SGEOMETRY3D - 3D GEOMETRY
============================================================================

  AABB(min_point, max_point) - Axis-Aligned Bounding Box
  Ray(origin, direction) - Ray
  Sphere(center, radius) - Sphere
  Plane(normal, point/d) - Plane

AABB METHODS:
  from_center_size(center, size) - Create from center and size
  from_points(points) - Create from point list
  center, size, extents - Properties
  expand(point) - Expand to include point
  inflate(amount) - Uniform expansion
  contains_point(point) - Point inside
  intersects_aabb(other) - AABB vs AABB
  intersects_sphere(center, radius) - AABB vs sphere
  surface_area() - Surface area
  volume() - Volume
  merge(other) - Merge AABBs

RAY METHODS:
  point_at(t) - Point on ray at distance t
  intersect_sphere(center, radius) - Ray vs sphere
  intersect_plane(point, normal) - Ray vs plane
  intersect_triangle(v0,v1,v2) - Ray vs triangle
  intersect_aabb(aabb) - Ray vs AABB
  closest_point_to(point) - Closest point on ray
  distance_to_point(point) - Distance from ray to point

SPHERE METHODS:
  contains_point(point) - Point inside
  intersects_sphere(other) - Sphere vs sphere
  intersects_aabb(aabb) - Sphere vs AABB
  surface_area(), volume()

PLANE METHODS:
  from_three_points(p1,p2,p3) - Create from 3 points
  distance_to_point(point) - Signed distance
  project_point(point) - Project point to plane
  is_on_plane(point, tolerance) - Check if on plane

FUNCTION:
  project_3d_to_2d(point, camera_pos, camera_angle, fov, width, height) - 3D to 2D projection


============================================================================
SCURVE - CURVES AND SPLINES
============================================================================

BEZIER CURVES:
  quadratic_bezier(p0, p1, p2, t) - Quadratic Bezier
  cubic_bezier(p0, p1, p2, p3, t) - Cubic Bezier
  bezier(points, t) - Arbitrary degree Bezier (de Casteljau)
  bezier_derivative(points, t, order=1) - Derivative (tangent)
  bezier_path(points, steps=100) - Generate curve points
  bezier_length(points, steps=100) - Approximate curve length
  de_casteljau_subdivide(points, t) - Subdivide curve

B-SPLINE:
  b_spline(control_points, knots, degree, t) - B-spline evaluation
  b_spline_curve(control_points, degree=3, steps=100) - Generate curve points
  uniform_knots(n, degree) - Uniform knot vector
  clamped_knots(n, degree) - Clamped knot vector

NURBS:
  nurbs(control_points, weights, knots, degree, t) - NURBS evaluation

GENERAL:
  curve_length(points_func, steps=100) - General curve length
  _lerp(p0,p1,t) - Linear interpolation helper


============================================================================
SEASING - EASING FUNCTIONS
============================================================================

BASIC:
  linear(t) - Constant speed

QUADRATIC:
  quad_in(t) - Accelerate (t^2)
  quad_out(t) - Decelerate (t*(2-t))
  quad_in_out(t) - Accelerate then decelerate

CUBIC:
  cubic_in(t) - t^3
  cubic_out(t) - (t-1)^3 + 1
  cubic_in_out(t) - Cubic accelerate/decelerate

SINE:
  sine_in(t) - Sine accelerate
  sine_out(t) - Sine decelerate
  sine_in_out(t) - Sine ease

EXPONENTIAL:
  expo_in(t) - Exponential accelerate
  expo_out(t) - Exponential decelerate
  expo_in_out(t) - Exponential ease

CIRCULAR:
  circ_in(t) - Circular accelerate
  circ_out(t) - Circular decelerate
  circ_in_out(t) - Circular ease

BACK:
  back_in(t) - Pull back then forward
  back_out(t) - Overshoot then return

BOUNCE:
  bounce_out(t) - Bounce at end
  bounce_in(t) - Bounce at start
  bounce_in_out(t) - Bounce both ends

ELASTIC:
  elastic_out(t, amplitude=1, period=0.3) - Elastic out
  elastic_in(t, amplitude=1, period=0.3) - Elastic in

TWEEN:
  tween(start, end, duration, elapsed, easing=linear) - Compute tween value
  Tween(start, end, duration, easing=linear) - Tween animation class

  Tween METHODS:
    update(dt) - Update and return value
    reset() - Reset animation

DICTIONARY:
  EASING - Dict of all easing functions (string -> function)
  ease(t, type='linear') - Get easing by name


============================================================================
SINTERP - INTERPOLATION FUNCTIONS
============================================================================

  lerp(a,b,t) - Linear interpolation (clamped 0-1)
  lerp_unclamped(a,b,t) - Linear interpolation (no clamp)
  bilerp(v00,v10,v01,v11,x,y) - Bilinear interpolation
  trilerp(v000,v100,v010,v110,v001,v101,v011,v111,x,y,z) - Trilinear interpolation
  slerp(v1,v2,t) - Spherical linear interpolation (for vectors)
  smoothstep(edge0, edge1, x) - Smooth step function
  smootherstep(edge0, edge1, x) - Smoother step function
  coserp(a,b,t) - Cosine interpolation
  cubic_bezier(p0,p1,p2,p3,t) - Cubic Bezier value
  cubic_bezier_derivative(p0,p1,p2,p3,t) - Cubic Bezier derivative
  catmull_rom(p0,p1,p2,p3,t) - Catmull-Rom spline
  hermite(p0,t0,p1,t1,s) - Hermite curve
  inverse_lerp(a,b,value) - Inverse linear interpolation
  remap(value,in_min,in_max,out_min,out_max) - Remap value
  pingpong(value,length) - Ping-pong value
  damp(current,target,lambda_val,dt) - Damped interpolation
  spring(current,target,velocity,frequency,damping,dt) - Spring interpolation


============================================================================
SCACHE - CACHING
============================================================================

  LFUCache(max_size=100) - Least Frequently Used cache
  LRUCache(max_size=100) - Least Recently Used cache
  TTLCache(max_size=100, default_ttl=None) - Time-to-live cache
  CacheEntry(key, value, ttl=None) - Cache entry with TTL
  RingBuffer(capacity) - Fixed-size FIFO buffer
  CacheStats() - Cache statistics

  memoize(max_size=128, method=False) - Memoization decorator

LFUCache METHODS:
  get(key, default=None), set(key, value), __setitem__, __getitem__
  __contains__, pop(key, default=None), clear(), keys(), values(), items()
  size, max_size (properties), __len__, __repr__

LRUCache METHODS:
  get(key, default=None), set(key, value), __setitem__, __getitem__
  __contains__, pop(key, default=None), clear(), keys(), values(), items()
  size, max_size (properties), __len__, __repr__

TTLCache METHODS:
  get(key, default=None, current_time=0), set(key, value, ttl=None, current_time=0)
  clear(), remove_expired(current_time), size (property), __len__, __repr__

RingBuffer METHODS:
  push(item), pop(), peek(), clear(), capacity (property), is_empty(), is_full()

CacheStats METHODS:
  record_hit(), record_miss(), record_eviction()
  hits, misses, evictions, total_requests, hit_rate (properties)
  reset(), __repr__

memoize USAGE:
  @memoize(max_size=128)
  def expensive_func(x): return x*x

  @memoize(max_size=128, method=True)
  def expensive_method(self, x): return x*x


============================================================================
SEVENT - EVENT SYSTEM
============================================================================

  EventSystem(dt=0.016) - Event system class
  event = EventSystem() - Global event instance

EVENT SYSTEM METHODS:
  on(event_name, handler) - Register permanent listener (returns ID)
  once(event_name, handler) - Run once then auto-remove
  times(count, event_name, handler) - Run fixed times then auto-remove
  when(event_name, condition, handler) - Condition-triggered listener
  wheel_once(event_name, condition, handler) - Condition-triggered, runs once
  delay(delay_time, event_name, handler) - Delayed event
  emit(event_name, *args, **kwargs) - Trigger event
  update(dt=None) - Update delayed events
  remove(event_name, listener_id) - Remove listener
  redo(event_name, listener_id) - Reactivate listener
  clear(event_name=None) - Clear listeners


============================================================================
SFSM - FINITE STATE MACHINE
============================================================================

  State(name) - State base class
  StateMachine(initial_state=None) - Finite state machine
  FunctionState(name, on_enter, on_exit, on_update, on_event) - Functional state
  StateTransition() - State transition table

State METHODS:
  enter(old_state) - Called on enter
  exit(new_state) - Called on exit
  update(dt) - Called each frame
  handle_event(event) - Process event, return next state

StateMachine METHODS:
  add_state(state) - Add state
  remove_state(state_name) - Remove state
  set_state(state_name) - Switch state
  update(dt) - Update current state
  handle_event(event) - Process event
  transition_to(state_name) - Switch state
  revert_to_previous() - Go back to previous state
  lock() - Lock state changes
  unlock() - Unlock state changes
  current_state, current_state_name, previous_state, states (properties)
  has_state(state_name), clear()

FunctionState USAGE:
  on_enter = lambda old: print("Entering")
  state = FunctionState("my_state", on_enter=on_enter)

StateTransition METHODS:
  add_transition(from_state, to_state, condition=None) - Add transition
  get_transition(from_state, context=None) - Get target state
  clear()


============================================================================
SPOOL - OBJECT POOL
============================================================================

  ObjectPool(factory=None, reset_func=None, max_size=100) - Object pool
  PooledObject() - Poolable object base class
  AutoReleasePool() - Auto-release context manager
  StackAllocator(initial_capacity=100) - LIFO allocator

ObjectPool METHODS:
  acquire(*args, **kwargs) - Get object from pool
  release(obj) - Return object to pool
  clear() - Clear pool
  available_count, in_use_count, total_count (properties)
  __len__, __repr__

PooledObject METHODS:
  recycle() - Return to pool
  on_acquire() - Called when acquired
  on_release() - Called when released
  is_active (property)

AutoReleasePool METHODS:
  __enter__, __exit__ - Context manager support
  add(obj, release_method='recycle') - Add object to pool
  release_all() - Release all objects
  count (property)

StackAllocator METHODS:
  push(obj) - Push object
  pop() - Pop object
  pop_multiple(count) - Pop multiple objects
  clear() - Clear stack
  size, capacity (properties)
  __len__, __repr__


============================================================================
SPATHFINDER - PATHFINDING ALGORITHMS
============================================================================

  astar(grid, start, end, heuristic='manhattan', allow_diagonal=False) - A* search
  astar_weighted(grid, start, end, weight=1.0, ...) - Weighted A*
  dijkstra(grid, start, end, weights=None, allow_diagonal=False) - Dijkstra
  bfs(grid, start, end) - Breadth-first search
  bidirectional_bfs(grid, start, end) - Bidirectional BFS
  dfs_maker(width, height, start=(1,1), seed=None) - Generate maze

  astar_cost(cost_grid, start, end, heuristic='manhattan', allow_diagonal=False) - A* with cost grid
  dijkstra_cost(cost_grid, start, end, allow_diagonal=False) - Dijkstra with cost grid
  get_path_cost(cost_grid, path, allow_diagonal=False) - Calculate path cost
  create_cost_grid(grid, default_cost=1.0, wall_cost=-1.0, custom_costs=None) - Create cost grid

HEURISTICS:
  'manhattan' - |dx| + |dy|
  'euclidean' - sqrt(dx^2 + dy^2)
  'chebyshev' - max(|dx|, |dy|)
  'octile' - max(|dx|,|dy|) + (sqrt(2)-1) * min(|dx|,|dy|)

RETURN VALUE:
  All pathfinders return list of vec2 points or None if no path

GRID FORMAT:
  0 = passable, 1 = wall (or any non-zero value)

COST GRID FORMAT:
  Positive values = movement cost
  -1 = wall (impassable)


============================================================================
SSAVER - SAVE/Load SYSTEM (SGT format)
============================================================================

  SGTsaver() - Save/load state with checksum

METHODS:
  set_value(**kwargs) - Set multiple values
  add(key, value) - Set single value (chainable)
  save(filename, use_hash=True) - Save to file
  load(filename, require_hash=True) - Load from file
  get(key, default=None) - Get value
  __getitem__(key), __setitem__(key, value) - Dict-style access

SUPPORTED TYPES:
  str, int, float, bool, list, tuple, dict
  vec2, vec3 (and similar objects with x,y,z attributes)

FILE FORMAT:
  #key=value
  #key2=value2
  hash=checksum

USAGE:
  s = SGTsaver()
  s.set_value(name="player", score=100)
  s.save("save.sgt")
  s2 = SGTsaver()
  s2.load("save.sgt")
  print(s2["name"])  # "player"


============================================================================
SFORMAT - FORMATTING UTILITIES
============================================================================

  uuid4(obj) - Convert any object to UUID
  superscript(n) - Convert number to superscript string
  visual_len(t) - Visual length (Chinese = 2, ASCII = 1)
  center(s, width) - Center align by visual width
  table(data, border_style="unicode", shows={...}) - Pretty table

TABLE BORDER STYLES:
  'unicode', 'ascii', 'double', 'rounded'

TABLE SHOWS FORMAT:
  shows = {"left": 5, "right": 5, "top": 5, "bottom": 5}
  Controls how many rows/columns to show (ellipsis for hidden)

  ordinal(number) - Convert to ordinal string (1st, 2nd, 3rd)
  to_poly(expr, use_star=False) - Convert expression to polynomial string
  number_to_english(n) - Convert integer to English words
  english_to_number(s) - Convert English words to integer
  insert(base_str, place, insert_str) - Insert substring at position
  encode(string) - Encode string to numeric representation
  decode(encoded) - Decode numeric representation
  time_format(seconds, mode='auto') - Format time duration

TIME FORMAT MODES:
  'auto' - Adaptive (1s, 1m, 1h, 1d)
  'full' - HH:MM:SS
  'short' - Xh Ym Zs
  'words' - X hours Y minutes Z seconds

  file_size(size_bytes, mode='auto', decimal=False) - Format file size

FILE SIZE MODES:
  'auto' - Adaptive (SI)
  'bits' - Bits (Kb, Mb, etc.)
  'si' - SI units (KB, MB, GB)
  'binary' - Binary units (KiB, MiB, GiB)
  'short' - Short (B, K, M, G)
  'full' - Full words (bytes, kilobytes)


============================================================================
SNOISE - NOISE GENERATION
============================================================================

  PerlinNoise(seed=None, octaves=4, persistence=0.5, lacunarity=2.0)
  SimplexNoise(seed=None, octaves=4, persistence=0.5, lacunarity=2.0)
  Snoise(falloff=1.0) - Simple noise field from control points

PerlinNoise METHODS:
  noise2d(x, y) - 2D Perlin noise [-1, 1]
  fbm2d(x, y) - Fractal Brownian motion
  terrain_height(x, y) - Terrain height (ridges)

SimplexNoise METHODS:
  noise2d(x, y) - 2D Simplex noise [-1, 1] (no grid artifacts)
  fbm2d(x, y) - Fractal Brownian motion

Snoise METHODS:
  add_point(x, y, value) - Add control point
  add_points(*points) - Add multiple points
  clear() - Clear all points
  set_falloff(falloff) - Set falloff factor
  __call__(x, y, use_cache=True) - Get noise value
  sample_rect(x1,y1,x2,y2,step=1.0) - Sample region
  heatmap(x1,y1,x2,y2,step=1.0) - Generate heatmap (0-255)

SHORTCUT:
  snoise_from_points(points, falloff=1.0) - Create Snoise from points


============================================================================
SCRYPT - CRYPTOGRAPHY
============================================================================

  rsa_generate_keys(bits=512) - Generate RSA key pair
  rsa_encrypt(message, public_key) - RSA encryption
  rsa_decrypt(cipher, private_key) - RSA decryption

  simple_encrypt(value, key=None, second=None) - Simple encryption
  simple_decrypt(cipher, key, IV, second=None) - Simple decryption

  share_secret(plaintext, keys, threshold) - Secret sharing (encrypt)
  recover_secret(shares_dict, threshold) - Secret sharing (decrypt)

RSA KEY FORMAT:
  {'e': e, 'd': d, 'n': n, 'p': p, 'q': q, 'phi': phi}

simple_encrypt RETURN:
  If key is None: (cipher, key, IV)
  If key is provided: (cipher, IV)

Secret sharing USAGE:
  shares = share_secret("secret", ["key1", "key2", "key3"], threshold=2)
  recovered = recover_secret(shares, 2)  # Any 2 shares enough


============================================================================
SOLVER - EQUATION SOLVING
============================================================================

  solve_linear(a,b) - Solve ax + b = 0
  solve_quadratic(a,b,c) - Solve ax^2 + bx + c = 0 (supports complex)
  solve_cubic(a,b,c,d) - Solve ax^3 + bx^2 + cx + d = 0 (supports complex)
  solve_polynomial(coefficients) - Auto-select solver (degree <= 3)
  solve_polynomial_numerical(coefficients, max_iter=1000, tol=1e-10) - Numerical solver (any degree)
  roots(coefficients) - Alias for solve_polynomial_numerical
  poly(val, coefficients) - Evaluate polynomial

COEFFICIENTS FORMAT:
  [a, b, c, d] for ax^3 + bx^2 + cx + d

EXCEPTION:
  NoSolutionError - No solution found


============================================================================
SSTAT - STATISTICS
============================================================================

CENTRAL TENDENCY:
  mean(data) - Arithmetic mean
  geometric_mean(data) - Geometric mean
  harmonic_mean(data) - Harmonic mean
  median(data) - Median
  mode(data) - Mode (all values)
  quantile(data, p) - Quantile (p in [0,1])
  quartiles(data) - (Q1, Q2, Q3)
  iqr(data) - Interquartile range

DISPERSION:
  variance(data, ddof=0) - Variance
  stdev(data, ddof=0) - Standard deviation
  mad(data) - Mean absolute deviation
  range_stat(data) - Range (max - min)
  cv(data, ddof=0) - Coefficient of variation

SHAPE:
  skewness(data, ddof=0) - Skewness
  kurtosis(data, ddof=0) - Kurtosis (excess)

RELATIONSHIP:
  covariance(x,y) - Covariance
  correlation(x,y) - Pearson correlation
  spearman(x,y) - Spearman rank correlation
  linear_regression(x,y) - Linear regression (returns slope, intercept, R^2)

PROBABILITY DISTRIBUTIONS:
  normal_pdf(x, mu=0, sigma=1) - Normal PDF
  normal_cdf(x, mu=0, sigma=1) - Normal CDF (approx)
  binomial_pmf(k, n, p) - Binomial PMF
  poisson_pmf(k, lam) - Poisson PMF

HYPOTHESIS TESTING:
  z_score(x, mu, sigma) - Z-score
  t_test(data, mu0) - One-sample t-test (returns t, p)
  chi_square(observed, expected) - Chi-square test
  f_test(a,b) - F-test (variance ratio)

TRANSFORMATIONS:
  normalize(data, new_min=0, new_max=1) - Normalize to range
  standardize(data) - Standardize (mean=0, stdev=1)

TIME SERIES:
  rolling_mean(data, window) - Moving average
  ewma(data, alpha) - Exponential weighted moving average

SUMMARY:
  summary(data) - Complete statistical summary (dict)
  probability_distribution(data) - Probability distribution (dict)


============================================================================
SBASE64 - BASE ENCODINGS
============================================================================

  b16encode(data), b16decode(data) - Base16 (hex)
  b32encode(data), b32decode(data) - Base32
  b64encode(data), b64decode(data) - Base64
  b64urlencode(data), b64urldecode(data) - Base64 URL-safe
  b58encode(data), b58decode(data) - Base58 (Bitcoin)
  b256encode(data), b256decode(data) - Base256 (Chinese characters)

DATA TYPE:
  All functions accept and return bytes

Base64 URL-safe:
  Uses '-' and '_' instead of '+' and '/'

Base58:
  Uses Bitcoin alphabet: 123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz
  (Note: 0, O, I, l are excluded)

Base256:
  Uses Chinese characters from 0x4E00
  Encodes each byte as a 3-byte UTF-8 character


============================================================================
PICKLE - CUSTOM BINARY SERIALIZATION
============================================================================

  pack(obj) - Pack any object to bytes
  unpack(data, pos=0) - Unpack bytes to object
  dump(obj, filename) - Save object to file
  load(filename) - Load object from file

  pack_float(num) - Pack float to binary string
  unpack_float(byte_data) - Unpack float from bytes
  pack_int(n, bits=None) - Pack integer
  pack_str(n) - Pack string
  bits_to_bytes(bits) - Binary string to bytes
  bytes_to_bits(data) - Bytes to binary string
  pack_to_file(obj, filename) - Pack and write to file

SUPPORTED TYPES:
  str, int, float, bool, list, tuple, dict, None

FILE FORMAT:
  Type marker + data + terminator
  'S' - String (varint length + UTF-8)
  'I' - Non-negative integer (varint)
  'i' - Negative integer (varint)
  'F' - Float (8 bytes IEEE 754)
  'B' - Boolean (1 byte)
  'L' - List (items + 'E')
  'D' - Dictionary (key+value pairs + 'E')
  'N' - None


============================================================================
HASHLIB - SHA-256 AND HASHING
============================================================================

  sha256(message) - SHA-256 hash (returns hex string)
  DJB2(s, capacity=0xffffffff) - DJB2 hash

MESSAGE TYPES:
  str - UTF-8 encoded
  bytes - Raw bytes
  list of ints - Bytes as integers

SHA-256 INTERNALS (exported):
  rotr(x,n) - Rotate right
  shr(x,n) - Shift right
  xor3(a,b,c) - XOR of three
  add_mod32(a,b) - 32-bit add
  ch(x,y,z), maj(x,y,z) - SHA functions
  sigma0(x), sigma1(x), gamma0(x), gamma1(x) - SHA functions
  pad_message(msg_bytes) - Padding
  bytes_to_words(block) - Block to words
  compress_block(block_bytes, h_vals) - Compression


============================================================================
BMP - BMP IMAGE READER/WRITER
============================================================================

  BMPImage(width, height) - BMP image class

METHODS:
  set_pixel(x, y, color) - Set pixel (R,G,B) or (R,G,B,A)
  get_pixel(x, y) - Get pixel color
  save(filename) - Save as BMP
  to_rgb() - Remove alpha channel
  load(filename) - Load from file (class method)
  load_from_bytes(data) - Load from bytes (class method)

COLOR FORMAT:
  RGB: (r, g, b) each 0-255
  RGBA: (r, g, b, a) each 0-255

SUPPORTED BIT DEPTHS (loading):
  1, 4, 8, 16, 24, 32

SAVING:
  24-bit (RGB) or 32-bit (RGBA)

FACTORY METHODS:
  create_checkerboard(width, height, size=10) - Checkerboard pattern
  create_gradient(width, height) - Gradient pattern

EXCEPTION:
  BMPError - BMP operation error


============================================================================
ECC - ELLIPTIC CURVE CRYPTOGRAPHY (ECDSA)
============================================================================

  ecdsa_sign_with_k(private_key, message, k) - ECDSA signature with custom k
  ecdsa_verify(public_key, message, signature) - ECDSA verification
  is_valid_private_key(k) - Check private key
  is_valid_k(k) - Check ephemeral key

CURVE: secp256k1 (Bitcoin curve)
  p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
  a = 0, b = 7
  n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
  G = Base point (x, y)

SIGNATURE FORMAT:
  (r, s) where r and s are integers

USAGE:
  priv = 123456789
  msg = "Hello, world!"
  k = 987654321  # Must be random and unique
  r, s = ecdsa_sign_with_k(priv, msg, k)
  pub = G * priv  # Public key
  valid = ecdsa_verify(pub, msg, (r, s))


============================================================================
DECIMAL - HIGH-PRECISION DECIMAL
============================================================================

  Decimal(value, fr_len=None) - High-precision decimal

SETTINGS:
  decimal.prec = 50  - Global precision (default 50)

FUNCTIONS:
  dec_pi() - Pi to decimal.prec digits
  dec_e() - e to decimal.prec digits
  dec_ln2() - ln(2) to decimal.prec digits
  dec_exp(value) - Exponential
  dec_ln(value) - Natural logarithm
  dec_sin(x) - Sine
  dec_cos(x) - Cosine
  dec_atan(x) - Arc tangent
  asin(x) - Arc sine (using dec_atan)

OPERATORS:
  +, -, *, /, //, %, **, -, +, ==, !=, <, <=, >, >=, abs
  int(), float(), round()

FORMATTING:
  repr() - 'Decimal("3.14")'
  str() - 'Decimal("3.14")'

USAGE:
  d1 = Decimal("3.141592653589793")
  d2 = Decimal(2)
  result = d1 * d2  # Decimal("6.283185307179586")


============================================================================
POLY - POLYNOMIALS
============================================================================

  Poly(terms=None) - Polynomial class
  Poly.from_string(poly_str) - Parse polynomial string

TERMS FORMAT:
  [(coeff, {var: exp, ...}), ...]
  Example: [(3, {'x': 2}), (2, {'x': 1}), (1, {})] = 3x^2 + 2x + 1

METHODS:
  degree(var=None) - Degree of polynomial
  evaluate(values) - Evaluate with variable values
  derivative(var='x') - Differentiate
  factor() - Factor polynomial
  extract_gcf() - Extract greatest common factor

OPERATORS:
  +, -, *, -, ==

FUNCTIONS:
  factors_to_str(factors) - Convert factor list to string

USAGE:
  p = Poly.from_string("x^2 + 2x + 1")
  p.evaluate({'x': 3})  # 16
  p.derivative()  # 2x + 2
  p.factor()  # [(x+1), (x+1)]


============================================================================
RADICAL - EXACT RADICALS
============================================================================

  Radical(index, radicand, coeff=1) - Exact radical representation

  real_sqrt(n) - Square root (index=2)
  real_root(n, x) - nth root

PROPERTIES:
  index - Root index
  radicand - Value under root (int, float, Frac, tuple, or Radical)
  coeff - Coefficient

METHODS:
  approx() - Float approximation
  conjugate() - Conjugate for rationalization

OPERATORS:
  +, -, *, /, **, -, +, ==, hash, float()

USAGE:
  r = Radical(2, 12)  # sqrt(12) = 2*sqrt(3)
  print(r)  # 2*√(3)
  r.approx()  # 3.464101615...
  r = Radical(2, 2) * Radical(2, 3)  # sqrt(6)
  r + Radical(2, 3)  # sqrt(2) + sqrt(3) (kept as sum)


============================================================================
ZIP - COMPRESSION (LZ77 + HUFFMAN)
============================================================================

  compress(data) - Compress bytes
  decompress(data, codes, count) - Decompress

COMPRESS FORMAT:
  Returns (compressed_bytes, codes_dict, symbol_count)

USAGE:
  data = b"Hello, world!"
  compressed, codes, count = compress(data)
  original = decompress(compressed, codes, count)

ALGORITHM:
  1. LZ77 sliding window compression
  2. Huffman coding on symbols


============================================================================
RE - REGULAR EXPRESSIONS
============================================================================

  Regex(pattern) - Regular expression engine

METHODS:
  match(text) - Return True if pattern matches

SUPPORTED SYNTAX:
  . - Any character
  * - Zero or more
  + - One or more
  ? - Zero or one
  | - Alternation
  ^ - Start anchor
  $ - End anchor
  [abc] - Character class
  [a-z] - Character range
  [^abc] - Negated character class
  {n} - Exactly n times
  {n,m} - Between n and m times
  {n,} - n or more times
  () - Grouping

ESCAPE SEQUENCES:
  \d - Digit
  \D - Non-digit
  \w - Word character (A-Z, a-z, 0-9, _)
  \W - Non-word character
  \s - Whitespace
  \S - Non-whitespace

USAGE:
  re = Regex(r"\d+")
  re.match("123")  # True
  re.match("abc")  # False

  re = Regex(r"^[A-Z]+\d+$")
  re.match("ABC123")  # True


============================================================================
DATABASE - DISK-BASED KEY-VALUE STORE
============================================================================

  DiskKV(filepath, initial_capacity=131072) - Key-value store on disk

METHODS:
  set(key, value) - Set key-value (string keys and values)
  get(key, default=None) - Get value
  flush() - Force write to disk
  close() - Close database

PROPERTIES:
  capacity - Current capacity
  count - Number of keys

USAGE:
  db = DiskKV("data.db")
  db.set("name", "John")
  db.set("age", "30")
  print(db.get("name"))  # "John"
  db.close()


============================================================================
TESTER - UNIT TESTING FRAMEWORK
============================================================================

  TestCase - Test case base class
  TestRunner - Test runner
  test - Decorator: mark test method
  skip(reason="") - Decorator: skip test

DECORATORS:
  @test - Mark method as test
  @skip("reason") - Skip test

ASSERTIONS:
  assert_equal(a,b) - a == b
  assert_not_equal(a,b) - a != b
  assert_almost_equal(a,b,places=7) - round(a-b, places) == 0
  assert_not_almost_equal(a,b,places=7) - round(a-b, places) != 0
  assert_greater(a,b) - a > b
  assert_greater_equal(a,b) - a >= b
  assert_less(a,b) - a < b
  assert_less_equal(a,b) - a <= b
  assert_true(x) - bool(x) is True
  assert_false(x) - bool(x) is False
  assert_is(a,b) - a is b
  assert_is_not(a,b) - a is not b
  assert_is_none(x) - x is None
  assert_is_not_none(x) - x is not None
  assert_in(a,b) - a in b
  assert_not_in(a,b) - a not in b
  assert_isinstance(a,b) - isinstance(a,b)
  assert_not_isinstance(a,b) - not isinstance(a,b)
  assert_issubclass(a,b) - issubclass(a,b)
  assert_not_issubclass(a,b) - not issubclass(a,b)
  assert_count_equal(a,b) - Same elements (order ignored)
  assert_starts_with(a,b) - a.startswith(b)
  assert_not_starts_with(a,b) - not a.startswith(b)
  assert_ends_with(a,b) - a.endswith(b)
  assert_not_ends_with(a,b) - not a.endswith(b)
  assert_has_attr(a,b) - hasattr(a,b)
  assert_not_has_attr(a,b) - not hasattr(a,b)

  assert_raises(exc_class) - Context manager for exceptions

HOOKS:
  setup() - Before each test
  teardown() - After each test
  setup_class() - Before all tests in class
  teardown_class() - After all tests in class

USAGE:
  class MyTest(TestCase):
      @test
      def test_add(self):
          self.assert_equal(1+1, 2)
      
      @test
      @skip("not implemented")
      def test_mul(self):
          pass

  runner = TestRunner()
  runner.run_all()


============================================================================
SUI - SIMPLE UI COMPONENTS
============================================================================

  Label(x,y,width,height,text="", **kwargs) - Text label
  Button(x,y,width,height,text="", **kwargs) - Clickable button
  Bar(x,y,width,height,value=1.0, **kwargs) - Progress/health bar
  Entry(x,y,width,height,text="", **kwargs) - Text input

  render_all(components) - Render all components
  draw(cmd_type) - Decorator to register render handler

LABEL PARAMETERS:
  color - Background color (default (240,240,240))
  text_color - Text color (default (0,0,0))
  align - 'left', 'center', 'right'

BUTTON PARAMETERS:
  color - Normal color
  hover_color - Hover color
  press_color - Pressed color
  text_color - Text color
  border - True/False
  radius - Corner radius

BUTTON METHODS:
  handle_event(mouse_pos, keys) - Update hover state
  press() - Press button
  release() - Release button (returns True if clicked)

BAR PARAMETERS:
  bg_color - Background color
  fill_color - Fill color
  text_color - Text color
  show_text - Show percentage
  orientation - 'horizontal' or 'vertical'

BAR METHODS:
  set_hp(current, max_hp) - Set health value

ENTRY PARAMETERS:
  placeholder - Placeholder text
  placeholder_color - Placeholder color
  color - Background color
  text_color - Text color
  border - True/False
  radius - Corner radius
  cursor_blink_tim - Blink interval (ms)

ENTRY METHODS:
  handle_event(mouse_pos, keys, dt) - Process input (returns True on submit)
  config(**kwargs) - Configure component

COMPONENT METHODS:
  config(**kwargs) - Set parameters
  render() - Return render commands
  destroy() - Hide component
  enter(x,y) - Check if mouse inside


============================================================================
VECTOR AND QUATERNION QUICK REFERENCE
============================================================================

VECTOR OPERATORS:
  v + v, v - v, v * scalar, v / scalar, v == v, -v, v[i]

QUATERNION OPERATORS:
  q + q, q - q, q * q, q * scalar, q / scalar, -q, q == q, q[i]


FFT - FAST FOURIER TRANSFORM
============================================================================

fft(x) - Fast Fourier Transform (supports any length, auto-pads to power of 2)
ifft(X, original_length=None) - Inverse FFT

fftfreq(N, d=1.0) - Generate frequency coordinates for FFT
fftshift(x) - Shift zero frequency to center
ifftshift(x) - Inverse of fftshift

magnitude_spectrum(x, shift=False) - Compute magnitude spectrum |X|
power_spectrum(x, shift=False) - Compute power spectrum |X|^2
phase_spectrum(x, shift=False) - Compute phase spectrum angle(X)

INPUT/OUTPUT:
x - List of numbers (int, float, or Complex)
X - List of Complex numbers (FFT output)

RETURN VALUES:
fft(x) - Returns (X, N) where N is original length (for ifft)
ifft(X, original_length) - Returns list of Complex (or numbers)
fftfreq(N, d) - Returns list of frequencies (d = sampling interval)

USAGE:
from mlib.plus.fft import fft, ifft, fftfreq, fftshift, magnitude_spectrum

Basic FFT
x = [1.0, 2.0, 3.0, 4.0]
X, N = fft(x)
x_recovered = ifft(X, N)

Frequency analysis
freqs = fftfreq(len(x), d=0.01)
mag = magnitude_spectrum(x, shift=True)

Shift zero frequency to center
X_shifted = fftshift(X)

NOTES:

Input length does NOT need to be a power of 2 (auto-padding applied)

fft() returns (spectrum, original_length) for proper reconstruction

fftshift() and ifftshift() work for both even and odd lengths

EXAMPLES:

Sine wave analysis
from mlib import pi, sin
t = [i * 0.01 for i in range(100)]
x = [sin(2pi50*t[i]) for i in range(len(t))]
X, N = fft(x)
freqs = fftfreq(N, d=0.01)
mag = magnitude_spectrum(x, shift=True)

Peak at 50 Hz
Filtering
X, N = fft(x)
for i in range(len(X)):
if abs(fftfreq(N, 0.01)[i]) > 100:
X[i] = 0
filtered = ifft(X, N)


============================================================================
IMPORT PATHS
============================================================================

  from mlib import *
  from mlib.gaskill import *
  from mlib.plus import *

Main package imports everything from gaskill and plus subpackages.
