Fixed point

concrete_fhe_toolkit.math.fixed_point

Helpers for scaled-integer fixed-point values.

make_floor

make_floor(min_input: int, max_input: int, *, scale: int = 10) -> UnaryFunction

Create floor(value / scale) for encrypted scaled integers.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10

Returns:

Type	Description
UnaryFunction	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_floor

floor_fn = make_floor(min_input=0, max_input=50, scale=10)
# Use `floor_fn(value)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_floor(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
) -> UnaryFunction:
    """Create floor(value / scale) for encrypted scaled integers.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_floor

        floor_fn = make_floor(min_input=0, max_input=50, scale=10)
        # Use `floor_fn(value)` inside an FHE program compilation
        ```
"""
    values = _scaled_values(min_input, max_input, scale, "floor")
    return make_unary_lookup(values, min_input)

compile_floor

compile_floor(min_input: int, max_input: int, *, scale: int = 10, allow_large_lookup: bool = False, configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile floor(value / scale) for encrypted scaled integers.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10
allow_large_lookup	bool	Whether to allow large table lookups (may be slow).	False
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_floor

circuit = compile_floor(min_input=0, max_input=50, scale=10)
print(circuit.encrypt_run_decrypt(25))  # 2

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_floor(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
    allow_large_lookup: bool = False,
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile floor(value / scale) for encrypted scaled integers.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.
        allow_large_lookup: Whether to allow large table lookups (may be slow).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_floor

        circuit = compile_floor(min_input=0, max_input=50, scale=10)
        print(circuit.encrypt_run_decrypt(25))  # 2
        ```
"""
    check_lookup_domain(
        "compile_floor",
        (min_input, max_input),
        allow_large_lookup=allow_large_lookup,
    )
    values = _scaled_values(min_input, max_input, scale, "floor")
    return compile_unary_lookup(
        "compile_floor",
        values,
        min_input,
        max_input,
        allow_large_lookup=allow_large_lookup,
        configuration=configuration,
    )

make_ceil

make_ceil(min_input: int, max_input: int, *, scale: int = 10) -> UnaryFunction

Create ceil(value / scale) for encrypted scaled integers.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10

Returns:

Type	Description
UnaryFunction	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_ceil

ceil_fn = make_ceil(min_input=0, max_input=50, scale=10)
# Use `ceil_fn(value)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_ceil(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
) -> UnaryFunction:
    """Create ceil(value / scale) for encrypted scaled integers.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_ceil

        ceil_fn = make_ceil(min_input=0, max_input=50, scale=10)
        # Use `ceil_fn(value)` inside an FHE program compilation
        ```
"""
    values = _scaled_values(min_input, max_input, scale, "ceil")
    return make_unary_lookup(values, min_input)

compile_ceil

compile_ceil(min_input: int, max_input: int, *, scale: int = 10, allow_large_lookup: bool = False, configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile ceil(value / scale) for encrypted scaled integers.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10
allow_large_lookup	bool	Whether to allow large table lookups (may be slow).	False
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_ceil

circuit = compile_ceil(min_input=0, max_input=50, scale=10)
print(circuit.encrypt_run_decrypt(25))  # 3

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_ceil(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
    allow_large_lookup: bool = False,
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile ceil(value / scale) for encrypted scaled integers.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.
        allow_large_lookup: Whether to allow large table lookups (may be slow).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_ceil

        circuit = compile_ceil(min_input=0, max_input=50, scale=10)
        print(circuit.encrypt_run_decrypt(25))  # 3
        ```
"""
    check_lookup_domain(
        "compile_ceil",
        (min_input, max_input),
        allow_large_lookup=allow_large_lookup,
    )
    values = _scaled_values(min_input, max_input, scale, "ceil")
    return compile_unary_lookup(
        "compile_ceil",
        values,
        min_input,
        max_input,
        allow_large_lookup=allow_large_lookup,
        configuration=configuration,
    )

make_trunc

make_trunc(min_input: int, max_input: int, *, scale: int = 10) -> UnaryFunction

Create trunc(value / scale) toward zero for encrypted scaled integers.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10

Returns:

Type	Description
UnaryFunction	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_trunc

trunc_fn = make_trunc(min_input=-50, max_input=50, scale=10)
# Use `trunc_fn(value)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_trunc(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
) -> UnaryFunction:
    """Create trunc(value / scale) toward zero for encrypted scaled integers.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_trunc

        trunc_fn = make_trunc(min_input=-50, max_input=50, scale=10)
        # Use `trunc_fn(value)` inside an FHE program compilation
        ```
"""
    values = _scaled_values(min_input, max_input, scale, "trunc")
    return make_unary_lookup(values, min_input)

compile_trunc

compile_trunc(min_input: int, max_input: int, *, scale: int = 10, allow_large_lookup: bool = False, configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile trunc(value / scale) toward zero for encrypted scaled integers.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10
allow_large_lookup	bool	Whether to allow large table lookups (may be slow).	False
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_trunc

circuit = compile_trunc(min_input=-50, max_input=50, scale=10)
print(circuit.encrypt_run_decrypt(-25))  # -2

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_trunc(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
    allow_large_lookup: bool = False,
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile trunc(value / scale) toward zero for encrypted scaled integers.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.
        allow_large_lookup: Whether to allow large table lookups (may be slow).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_trunc

        circuit = compile_trunc(min_input=-50, max_input=50, scale=10)
        print(circuit.encrypt_run_decrypt(-25))  # -2
        ```
"""
    check_lookup_domain(
        "compile_trunc",
        (min_input, max_input),
        allow_large_lookup=allow_large_lookup,
    )
    values = _scaled_values(min_input, max_input, scale, "trunc")
    return compile_unary_lookup(
        "compile_trunc",
        values,
        min_input,
        max_input,
        allow_large_lookup=allow_large_lookup,
        configuration=configuration,
    )

make_round

make_round(min_input: int, max_input: int, *, scale: int = 10) -> UnaryFunction

Create round(value / scale) using Python's ties-to-even rule.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10

Returns:

Type	Description
UnaryFunction	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_round

round_fn = make_round(min_input=0, max_input=50, scale=10)
# Use `round_fn(value)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_round(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
) -> UnaryFunction:
    """Create round(value / scale) using Python's ties-to-even rule.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_round

        round_fn = make_round(min_input=0, max_input=50, scale=10)
        # Use `round_fn(value)` inside an FHE program compilation
        ```
"""
    values = _scaled_values(min_input, max_input, scale, "nearest")
    return make_unary_lookup(values, min_input)

compile_round

compile_round(min_input: int, max_input: int, *, scale: int = 10, allow_large_lookup: bool = False, configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile round(value / scale) using Python's ties-to-even rule.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10
allow_large_lookup	bool	Whether to allow large table lookups (may be slow).	False
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_round

circuit = compile_round(min_input=0, max_input=50, scale=10)
print(circuit.encrypt_run_decrypt(25))  # 2 (ties-to-even)

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_round(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
    allow_large_lookup: bool = False,
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile round(value / scale) using Python's ties-to-even rule.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.
        allow_large_lookup: Whether to allow large table lookups (may be slow).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_round

        circuit = compile_round(min_input=0, max_input=50, scale=10)
        print(circuit.encrypt_run_decrypt(25))  # 2 (ties-to-even)
        ```
"""
    check_lookup_domain(
        "compile_round",
        (min_input, max_input),
        allow_large_lookup=allow_large_lookup,
    )
    values = _scaled_values(min_input, max_input, scale, "nearest")
    return compile_unary_lookup(
        "compile_round",
        values,
        min_input,
        max_input,
        allow_large_lookup=allow_large_lookup,
        configuration=configuration,
    )

make_floor_ceil

make_floor_ceil(min_input: int, max_input: int, *, scale: int = 10) -> UnaryFunction

Create a function returning both floor and ceil for a scaled integer.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10

Returns:

Type	Description
UnaryFunction	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_floor_ceil

floor_ceil_fn = make_floor_ceil(min_input=0, max_input=50, scale=10)
# Use `floor_ceil_fn(value)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_floor_ceil(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
) -> UnaryFunction:
    """Create a function returning both floor and ceil for a scaled integer.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_floor_ceil

        floor_ceil_fn = make_floor_ceil(min_input=0, max_input=50, scale=10)
        # Use `floor_ceil_fn(value)` inside an FHE program compilation
        ```
"""
    floor_values = _scaled_values(min_input, max_input, scale, "floor")
    ceil_values = _scaled_values(min_input, max_input, scale, "ceil")
    floor_lookup = make_unary_lookup(floor_values, min_input)
    ceil_lookup = make_unary_lookup(ceil_values, min_input)

    def floor_and_ceil(value: Any) -> Any:
        """Compute both floor and ceil."""
        return floor_lookup(value), ceil_lookup(value)

    return floor_and_ceil

compile_floor_ceil

compile_floor_ceil(min_input: int, max_input: int, *, scale: int = 10, allow_large_lookup: bool = False, configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile a circuit returning both floor and ceil for a scaled integer.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10
allow_large_lookup	bool	Whether to allow large table lookups (may be slow).	False
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_floor_ceil

circuit = compile_floor_ceil(min_input=0, max_input=50, scale=10)
print(circuit.encrypt_run_decrypt(25))  # (2, 3)

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_floor_ceil(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
    allow_large_lookup: bool = False,
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile a circuit returning both floor and ceil for a scaled integer.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.
        allow_large_lookup: Whether to allow large table lookups (may be slow).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_floor_ceil

        circuit = compile_floor_ceil(min_input=0, max_input=50, scale=10)
        print(circuit.encrypt_run_decrypt(25))  # (2, 3)
        ```
"""
    check_lookup_domain(
        "compile_floor_ceil",
        (min_input, max_input),
        allow_large_lookup=allow_large_lookup,
    )
    floor_values = _scaled_values(min_input, max_input, scale, "floor")
    ceil_values = _scaled_values(min_input, max_input, scale, "ceil")
    check_lookup_cost(
        "compile_floor_ceil floor",
        floor_values,
        allow_large_lookup=allow_large_lookup,
    )
    check_lookup_cost(
        "compile_floor_ceil ceil",
        ceil_values,
        allow_large_lookup=allow_large_lookup,
    )
    function = make_floor_ceil(min_input, max_input, scale=scale)
    minimum, maximum = validate_bounds(min_input, max_input)
    return compile_function(
        function,
        {"value": "encrypted"},
        [minimum, maximum],
        configuration,
    )

make_rescale

make_rescale(min_input: int, max_input: int, *, input_scale: int, output_scale: int, rounding: RoundingMode = 'nearest') -> UnaryFunction

Create rescaling from one fixed-point scale to another.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
input_scale	int	The fixed-point scaling factor of the input.	required
output_scale	int	The desired fixed-point scaling factor for the output.	required
rounding	RoundingMode	The rounding mode to use (e.g., floor, ceil, trunc, nearest).	'nearest'

Returns:

Type	Description
UnaryFunction	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_rescale

rescale_fn = make_rescale(0, 100, input_scale=10, output_scale=100)
# Use `rescale_fn(value)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_rescale(
    min_input: int,
    max_input: int,
    *,
    input_scale: int,
    output_scale: int,
    rounding: RoundingMode = "nearest",
) -> UnaryFunction:
    """Create rescaling from one fixed-point scale to another.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        input_scale: The fixed-point scaling factor of the input.
        output_scale: The desired fixed-point scaling factor for the output.
        rounding: The rounding mode to use (e.g., floor, ceil, trunc, nearest).

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_rescale

        rescale_fn = make_rescale(0, 100, input_scale=10, output_scale=100)
        # Use `rescale_fn(value)` inside an FHE program compilation
        ```
"""
    input_minimum, input_maximum = validate_bounds(min_input, max_input)
    source = _validate_scale("input_scale", input_scale)
    target = _validate_scale("output_scale", output_scale)
    values = unary_values(
        lambda value: _round_fraction(Fraction(value * target, source), rounding),
        input_minimum,
        input_maximum,
    )
    return make_unary_lookup(values, input_minimum)

compile_rescale

compile_rescale(min_input: int, max_input: int, *, input_scale: int, output_scale: int, rounding: RoundingMode = 'nearest', allow_large_lookup: bool = False, configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile rescaling from one fixed-point scale to another.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
input_scale	int	The fixed-point scaling factor of the input.	required
output_scale	int	The desired fixed-point scaling factor for the output.	required
rounding	RoundingMode	The rounding mode to use (e.g., floor, ceil, trunc, nearest).	'nearest'
allow_large_lookup	bool	Whether to allow large table lookups (may be slow).	False
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_rescale

circuit = compile_rescale(0, 100, input_scale=10, output_scale=100)
print(circuit.encrypt_run_decrypt(50))  # 500

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_rescale(
    min_input: int,
    max_input: int,
    *,
    input_scale: int,
    output_scale: int,
    rounding: RoundingMode = "nearest",
    allow_large_lookup: bool = False,
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile rescaling from one fixed-point scale to another.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        input_scale: The fixed-point scaling factor of the input.
        output_scale: The desired fixed-point scaling factor for the output.
        rounding: The rounding mode to use (e.g., floor, ceil, trunc, nearest).
        allow_large_lookup: Whether to allow large table lookups (may be slow).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_rescale

        circuit = compile_rescale(0, 100, input_scale=10, output_scale=100)
        print(circuit.encrypt_run_decrypt(50))  # 500
        ```
"""
    check_lookup_domain(
        "compile_rescale",
        (min_input, max_input),
        allow_large_lookup=allow_large_lookup,
    )
    input_minimum, input_maximum = validate_bounds(min_input, max_input)
    source = _validate_scale("input_scale", input_scale)
    target = _validate_scale("output_scale", output_scale)
    values = unary_values(
        lambda value: _round_fraction(Fraction(value * target, source), rounding),
        input_minimum,
        input_maximum,
    )
    return compile_unary_lookup(
        "compile_rescale",
        values,
        input_minimum,
        input_maximum,
        allow_large_lookup=allow_large_lookup,
        configuration=configuration,
    )

make_round_to_multiple

make_round_to_multiple(min_input: int, max_input: int, step: int, *, rounding: RoundingMode = 'nearest') -> UnaryFunction

Create quantization of an encrypted integer to the nearest multiple of step.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
step	int	The integer step size to which the input will be quantized.	required
rounding	RoundingMode	The rounding mode to use (e.g., floor, ceil, trunc, nearest).	'nearest'

Returns:

Type	Description
UnaryFunction	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_round_to_multiple

quantize_fn = make_round_to_multiple(0, 100, step=5)
# Use `quantize_fn(value)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_round_to_multiple(
    min_input: int,
    max_input: int,
    step: int,
    *,
    rounding: RoundingMode = "nearest",
) -> UnaryFunction:
    """Create quantization of an encrypted integer to the nearest multiple of step.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        step: The integer step size to which the input will be quantized.
        rounding: The rounding mode to use (e.g., floor, ceil, trunc, nearest).

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_round_to_multiple

        quantize_fn = make_round_to_multiple(0, 100, step=5)
        # Use `quantize_fn(value)` inside an FHE program compilation
        ```
"""
    minimum, maximum = validate_bounds(min_input, max_input)
    normalized_step = validate_integer("step", step)
    if normalized_step < 1:
        raise ValueError("step must be at least 1")
    values = unary_values(
        lambda value: _round_fraction(Fraction(value, normalized_step), rounding)
        * normalized_step,
        minimum,
        maximum,
    )
    return make_unary_lookup(values, minimum)

compile_round_to_multiple

compile_round_to_multiple(min_input: int, max_input: int, step: int, *, rounding: RoundingMode = 'nearest', allow_large_lookup: bool = False, configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile quantization of an encrypted integer to the nearest multiple of step.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
step	int	The integer step size to which the input will be quantized.	required
rounding	RoundingMode	The rounding mode to use (e.g., floor, ceil, trunc, nearest).	'nearest'
allow_large_lookup	bool	Whether to allow large table lookups (may be slow).	False
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_round_to_multiple

circuit = compile_round_to_multiple(0, 100, step=5)
print(circuit.encrypt_run_decrypt(12))  # 10

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_round_to_multiple(
    min_input: int,
    max_input: int,
    step: int,
    *,
    rounding: RoundingMode = "nearest",
    allow_large_lookup: bool = False,
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile quantization of an encrypted integer to the nearest multiple of step.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        step: The integer step size to which the input will be quantized.
        rounding: The rounding mode to use (e.g., floor, ceil, trunc, nearest).
        allow_large_lookup: Whether to allow large table lookups (may be slow).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_round_to_multiple

        circuit = compile_round_to_multiple(0, 100, step=5)
        print(circuit.encrypt_run_decrypt(12))  # 10
        ```
"""
    check_lookup_domain(
        "compile_round_to_multiple",
        (min_input, max_input),
        allow_large_lookup=allow_large_lookup,
    )
    minimum, maximum = validate_bounds(min_input, max_input)
    normalized_step = validate_integer("step", step)
    if normalized_step < 1:
        raise ValueError("step must be at least 1")
    values = unary_values(
        lambda value: _round_fraction(Fraction(value, normalized_step), rounding)
        * normalized_step,
        minimum,
        maximum,
    )
    return compile_unary_lookup(
        "compile_round_to_multiple",
        values,
        minimum,
        maximum,
        allow_large_lookup=allow_large_lookup,
        configuration=configuration,
    )

make_modf

make_modf(min_input: int, max_input: int, *, scale: int = 10) -> UnaryFunction

Create a function returning (fractional_part, integer_part) like math.modf.

The integer part truncates toward zero; the fractional part keeps the input's sign and stays at the input scale (e.g. -37 with scale=10 yields (-7, -3)).

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10

Returns:

Type	Description
UnaryFunction	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_modf

modf_fn = make_modf(-50, 50, scale=10)
# Use `modf_fn(value)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_modf(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
) -> UnaryFunction:
    """Create a function returning (fractional_part, integer_part) like math.modf.

    The integer part truncates toward zero; the fractional part keeps the
    input's sign and stays at the input scale (e.g. -37 with scale=10
    yields (-7, -3)).

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_modf

        modf_fn = make_modf(-50, 50, scale=10)
        # Use `modf_fn(value)` inside an FHE program compilation
        ```
"""
    minimum, maximum = validate_bounds(min_input, max_input)
    normalized_scale = _validate_scale("scale", scale)
    integer_values = _scaled_values(minimum, maximum, normalized_scale, "trunc")
    fractional_values = [
        value - integer * normalized_scale
        for value, integer in zip(range(minimum, maximum + 1), integer_values)
    ]
    integer_lookup = make_unary_lookup(integer_values, minimum)
    fractional_lookup = make_unary_lookup(fractional_values, minimum)

    def modf(value: Any) -> Any:
        """Return the fractional and integer parts."""
        return fractional_lookup(value), integer_lookup(value)

    return modf

compile_modf

compile_modf(min_input: int, max_input: int, *, scale: int = 10, allow_large_lookup: bool = False, configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile a circuit returning (fractional_part, integer_part) like math.modf.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10
allow_large_lookup	bool	Whether to allow large table lookups (may be slow).	False
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_modf

circuit = compile_modf(-50, 50, scale=10)
print(circuit.encrypt_run_decrypt(-37))  # (-7, -3)

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_modf(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
    allow_large_lookup: bool = False,
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile a circuit returning (fractional_part, integer_part) like math.modf.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.
        allow_large_lookup: Whether to allow large table lookups (may be slow).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_modf

        circuit = compile_modf(-50, 50, scale=10)
        print(circuit.encrypt_run_decrypt(-37))  # (-7, -3)
        ```
"""
    check_lookup_domain(
        "compile_modf",
        (min_input, max_input),
        allow_large_lookup=allow_large_lookup,
    )
    minimum, maximum = validate_bounds(min_input, max_input)
    normalized_scale = _validate_scale("scale", scale)
    integer_values = _scaled_values(minimum, maximum, normalized_scale, "trunc")
    fractional_values = [
        value - integer * normalized_scale
        for value, integer in zip(range(minimum, maximum + 1), integer_values)
    ]
    check_lookup_cost(
        "compile_modf integer",
        integer_values,
        allow_large_lookup=allow_large_lookup,
    )
    check_lookup_cost(
        "compile_modf fractional",
        fractional_values,
        allow_large_lookup=allow_large_lookup,
    )
    function = make_modf(minimum, maximum, scale=normalized_scale)
    # The fractional output is not monotonic, so the inputset must cover the
    # full domain for Concrete to infer the correct output range.
    return compile_function(
        function,
        {"value": "encrypted"},
        list(range(minimum, maximum + 1)),
        configuration,
    )

make_fixed_point_multiply

make_fixed_point_multiply(*, scale: int = 10, rounding: RoundingMode = 'floor') -> Any

Create multiplication of two scaled values with the product rescaled back.

Computes (left * right) / scale so that two inputs at the same fixed-point scale produce an output at that scale. This is the missing primitive for chaining fixed-point math without scale growth.

Parameters:

Name	Type	Description	Default
scale	int	The scaling factor applied to the fixed-point representation.	10
rounding	RoundingMode	The rounding mode to use (e.g., floor, ceil, trunc, nearest).	'floor'

Returns:

Type	Description
Any	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_fixed_point_multiply

mul_fn = make_fixed_point_multiply(scale=10)
# Use `mul_fn(left, right)` inside an FHE program compilation

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def make_fixed_point_multiply(
    *,
    scale: int = 10,
    rounding: RoundingMode = "floor",
) -> Any:
    """Create multiplication of two scaled values with the product rescaled back.

    Computes ``(left * right) / scale`` so that two inputs at the same
    fixed-point scale produce an output at that scale. This is the missing
    primitive for chaining fixed-point math without scale growth.

    Args:
        scale: The scaling factor applied to the fixed-point representation.
        rounding: The rounding mode to use (e.g., floor, ceil, trunc, nearest).

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_fixed_point_multiply

        mul_fn = make_fixed_point_multiply(scale=10)
        # Use `mul_fn(left, right)` inside an FHE program compilation
        ```
"""
    normalized_scale = _validate_scale("scale", scale)
    if rounding == "floor":
        def multiply_floor(left: Any, right: Any) -> Any:
            """Multiply and return the floor."""
            return (left * right) // normalized_scale

        return multiply_floor
    if rounding == "nearest":
        offset = normalized_scale // 2

        def multiply_nearest(left: Any, right: Any) -> Any:
            """Multiply and return the nearest integer."""
            return (left * right + offset) // normalized_scale

        return multiply_nearest
    raise ValueError("rounding must be 'floor' or 'nearest'")

compile_fixed_point_multiply

compile_fixed_point_multiply(min_input: int, max_input: int, *, scale: int = 10, rounding: RoundingMode = 'floor', configuration: Optional[Configuration] = None) -> fhe.Circuit

Compile rescaled multiplication of two scaled encrypted values.

Parameters:

Name	Type	Description	Default
min_input	int	The minimum expected value in the input domain.	required
max_input	int	The maximum expected value in the input domain.	required
scale	int	The scaling factor applied to the fixed-point representation.	10
rounding	RoundingMode	The rounding mode to use (e.g., floor, ceil, trunc, nearest).	'floor'
configuration	Optional[Configuration]	Optional FHE compiler configuration object.	None

Returns:

Type	Description
Circuit	A compiled Concrete FHE circuit that performs the operation.

Example

from concrete_fhe_toolkit.math.fixed_point import compile_fixed_point_multiply

circuit = compile_fixed_point_multiply(0, 50, scale=10)
print(circuit.encrypt_run_decrypt(20, 15))  # (2.0 * 1.5) = 30

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

def compile_fixed_point_multiply(
    min_input: int,
    max_input: int,
    *,
    scale: int = 10,
    rounding: RoundingMode = "floor",
    configuration: Optional[fhe.Configuration] = None,
) -> fhe.Circuit:
    """Compile rescaled multiplication of two scaled encrypted values.

    Args:
        min_input: The minimum expected value in the input domain.
        max_input: The maximum expected value in the input domain.
        scale: The scaling factor applied to the fixed-point representation.
        rounding: The rounding mode to use (e.g., floor, ceil, trunc, nearest).
        configuration: Optional FHE compiler configuration object.

    Returns:
        A compiled Concrete FHE circuit that performs the operation.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import compile_fixed_point_multiply

        circuit = compile_fixed_point_multiply(0, 50, scale=10)
        print(circuit.encrypt_run_decrypt(20, 15))  # (2.0 * 1.5) = 30
        ```
"""
    minimum, maximum = validate_bounds(min_input, max_input)
    function = make_fixed_point_multiply(scale=scale, rounding=rounding)
    inputset = [
        (minimum, minimum),
        (minimum, maximum),
        (maximum, minimum),
        (maximum, maximum),
    ]
    return compile_function(
        function,
        {"left": "encrypted", "right": "encrypted"},
        inputset,
        configuration,
    )

make_encode_fixed_point

make_encode_fixed_point(scale: int = 10) -> Callable[[float], int]

Create a client-side helper to encode a clear real value as a scaled integer.

Parameters:

Name	Type	Description	Default
scale	int	The scaling factor applied to the fixed-point representation.	10

Returns:

Type	Description
Callable[[float], int]	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_encode_fixed_point

encode_fn = make_encode_fixed_point(scale=10)
print(encode_fn(2.5))  # 25

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

@client_side_helper
def make_encode_fixed_point(scale: int = 10) -> Callable[[float], int]:
    """Create a client-side helper to encode a clear real value as a scaled integer.

    Args:
        scale: The scaling factor applied to the fixed-point representation.

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_encode_fixed_point

        encode_fn = make_encode_fixed_point(scale=10)
        print(encode_fn(2.5))  # 25
        ```
"""
    normalized_scale = _validate_scale("scale", scale)
    def encode_fixed_point(value: float) -> int:
        """Encode a float into integer."""
        return int(round(value * normalized_scale))

    return encode_fixed_point

make_decode_fixed_point

make_decode_fixed_point(scale: int = 10) -> Callable[[int], float]

Create a client-side helper to decode a decrypted scaled integer back to a real value.

Parameters:

Name	Type	Description	Default
scale	int	The scaling factor applied to the fixed-point representation.	10

Returns:

Type	Description
Callable[[int], float]	A callable function that computes the operation over the given domain.

Example

from concrete_fhe_toolkit.math.fixed_point import make_decode_fixed_point

decode_fn = make_decode_fixed_point(scale=10)
print(decode_fn(25))  # 2.5

Source code in src/concrete_fhe_toolkit/math/fixed_point.py

@client_side_helper
def make_decode_fixed_point(scale: int = 10) -> Callable[[int], float]:
    """Create a client-side helper to decode a decrypted scaled integer back to a real value.

    Args:
        scale: The scaling factor applied to the fixed-point representation.

    Returns:
        A callable function that computes the operation over the given domain.

    Example:
        ```python
        from concrete_fhe_toolkit.math.fixed_point import make_decode_fixed_point

        decode_fn = make_decode_fixed_point(scale=10)
        print(decode_fn(25))  # 2.5
        ```
"""
    normalized_scale = _validate_scale("scale", scale)
    def decode_fixed_point(value: Any) -> float:
        """Decode fixed-point into float."""
        return value / normalized_scale

    return decode_fixed_point