lumix.linearization.functions.LXNonLinearFunctions

class lumix.linearization.functions.LXNonLinearFunctions[source]

Pre-built approximations for common nonlinear functions.

All functions use piecewise-linear approximation with adaptive breakpoint generation for improved accuracy.

Example

# Create linearizer linearizer = LXPiecewiseLinearizer(config)

# Approximate exponential growth growth = LXNonLinearFunctions.exp(time, linearizer)

# Logarithmic decay decay = LXNonLinearFunctions.log(age, linearizer, base=10)

__init__()

Methods

__init__()

cos(var, linearizer[, segments])

Cosine function: cos(x)

custom(var, func, linearizer[, segments, ...])

Custom user-defined function.

exp(var, linearizer[, segments])

Exponential function: e^x

log(var, linearizer[, base, segments])

Logarithm: log_base(x)

power(var, exponent, linearizer[, segments])

Power function: x^n

sigmoid(var, linearizer[, segments])

Sigmoid function: 1 / (1 + e^(-x))

sin(var, linearizer[, segments])

Sine function: sin(x)

sqrt(var, linearizer[, segments])

Square root: √x

tan(var, linearizer[, segments])

Tangent function: tan(x)
static exp(var, linearizer, segments=30)[source]

Exponential function: e^x

Parameters:

  • var (LXVariable) – Input variable

  • linearizer (LXPiecewiseLinearizer) – Piecewise linearizer instance

  • segments (int) – Number of segments (default: 30 for good accuracy)

Return type:

LXVariable

Returns:

Output variable representing exp(var)

Example

# Population growth model population = LXNonLinearFunctions.exp(time, linearizer)

# Compound interest future_value = principal * LXNonLinearFunctions.exp(rate * time, linearizer)

static log(var, linearizer, base=2.718281828459045, segments=30)[source]

Logarithm: log_base(x)

Parameters:

  • var (LXVariable) – Input variable (must be positive)

  • linearizer (LXPiecewiseLinearizer) – Piecewise linearizer instance

  • base (float) – Logarithm base (default: e for natural log)

  • segments (int) – Number of segments

Return type:

LXVariable

Returns:

Output variable representing log(var)

Example

# Natural logarithm ln_demand = LXNonLinearFunctions.log(demand, linearizer)

# Base-10 logarithm log10_quantity = LXNonLinearFunctions.log(quantity, linearizer, base=10)

# Information entropy entropy = -probability * LXNonLinearFunctions.log(probability, linearizer, base=2)

static sqrt(var, linearizer, segments=20)[source]

Square root: √x

Parameters:
Return type:

LXVariable

Returns:

Output variable representing sqrt(var)

Example

# Standard deviation std_dev = LXNonLinearFunctions.sqrt(variance, linearizer)

# Euclidean distance (after squaring) distance = LXNonLinearFunctions.sqrt(x_squared + y_squared, linearizer)

# Flow velocity in pipes velocity = LXNonLinearFunctions.sqrt(pressure_drop, linearizer)

static power(var, exponent, linearizer, segments=25)[source]

Power function: x^n

Parameters:
Return type:

LXVariable

Returns:

Output variable representing var^exponent

Example

# Cubic cost function cubic_cost = LXNonLinearFunctions.power(production, 3, linearizer)

# Quadratic relationship area = LXNonLinearFunctions.power(radius, 2, linearizer)

# Fractional power (e.g., Cobb-Douglas) output = LXNonLinearFunctions.power(capital, 0.3, linearizer)

static sigmoid(var, linearizer, segments=40)[source]

Sigmoid function: 1 / (1 + e^(-x))

Useful for modeling probabilities, S-curves, saturation effects.

Parameters:

  • var (LXVariable) – Input variable

  • linearizer (LXPiecewiseLinearizer) – Piecewise linearizer instance

  • segments (int) – Number of segments (higher for sharper transition)

Return type:

LXVariable

Returns:

Output variable representing sigmoid(var) ∈ [0, 1]

Example

# Probability of success probability = LXNonLinearFunctions.sigmoid(score, linearizer)

# Market saturation market_share = capacity * LXNonLinearFunctions.sigmoid(time, linearizer)

# Learning curve efficiency = LXNonLinearFunctions.sigmoid(experience, linearizer)

static sin(var, linearizer, segments=50)[source]

Sine function: sin(x)

Useful for seasonal patterns, cyclical behavior.

Parameters:
Return type:

LXVariable

Returns:

Output variable representing sin(var) ∈ [-1, 1]

Example

# Seasonal demand pattern (annual cycle) import math day_angle = day_of_year * 2 * math.pi / 365 seasonal_factor = LXNonLinearFunctions.sin(day_angle, linearizer)

# Daily temperature variation hour_angle = hour * 2 * math.pi / 24 temp_variation = LXNonLinearFunctions.sin(hour_angle, linearizer)

static cos(var, linearizer, segments=50)[source]

Cosine function: cos(x)

Similar to sine but phase-shifted by π/2.

Parameters:
Return type:

LXVariable

Returns:

Output variable representing cos(var) ∈ [-1, 1]

Example

# Phase-shifted seasonal pattern import math day_angle = day_of_year * 2 * math.pi / 365 seasonal_factor = LXNonLinearFunctions.cos(day_angle, linearizer)

# Circular motion x-coordinate x_pos = radius * LXNonLinearFunctions.cos(angle, linearizer)

static tan(var, linearizer, segments=40)[source]

Tangent function: tan(x)

Warning: Has discontinuities at x = π/2 + nπ. Ensure domain avoids these.

Parameters:

  • var (LXVariable) – Input variable (in radians, avoid discontinuities)

  • linearizer (LXPiecewiseLinearizer) – Piecewise linearizer instance

  • segments (int) – Number of segments

Return type:

LXVariable

Returns:

Output variable representing tan(var)

Example

# Slope calculation slope = LXNonLinearFunctions.tan(angle, linearizer)

static custom(var, func, linearizer, segments=30, adaptive=True)[source]

Custom user-defined function.

Allows approximation of any arbitrary function.

Parameters:
Return type:

LXVariable

Returns:

Output variable representing func(var)

Example:

# Custom discount curve
def discount_curve(q):
    if q < 100:
        return 1.0  # No discount
    elif q < 1000:
        return 0.9  # 10% discount
    else:
        return 0.8  # 20% discount

discount = LXNonLinearFunctions.custom(
    quantity, discount_curve, linearizer, segments=50
)

# Piecewise quadratic
def piecewise_quad(x):
    return x**2 if x < 10 else 100 + 20*(x-10)

cost = LXNonLinearFunctions.custom(
    production, piecewise_quad, linearizer
)