fxpmath

https://francof2a.github.io/fxpmath/
Admin
A Python library for fractional fixed-point (base 2) arithmetic and binary manipulation with NumPy...
Tokens:8,989
Snippets:124
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Clone and install fxpmath from source

Source: https://francof2a.github.io/fxpmath/docs/install

Clone the fxpmath repository and install it locally. This is useful for development or if you need the latest unreleased version.

```bash
git clone https://github.com/francof2a/fxpmath.git
```

```bash
cd fxpmath
```

```bash
pip install .
```

--------------------------------

### Install fxpmath using pip

Source: https://francof2a.github.io/fxpmath/docs/install

Use this command to install the fxpmath library from the Python Package Index.

```bash
pip install fxpmath
```

--------------------------------

### Install fxpmath using conda

Source: https://francof2a.github.io/fxpmath/docs/install

Use this command to install the fxpmath library from the conda-forge channel.

```bash
conda install -c francof2a fxpmath
```

--------------------------------

### Zero Fractional Bits Example

Source: https://francof2a.github.io/fxpmath/docs/generalized_sizing

Demonstrates zero fractional bits, representing pure integer scaling in fixed-point form.

```python
from fxpmath import Fxp

w = Fxp(7, signed=True, n_word=8, n_frac=0)
print(w.dtype, w.n_int, w())
# fxp-s8/0 7 7.0
```

--------------------------------

### Negative Fractional Bits Example

Source: https://francof2a.github.io/fxpmath/docs/generalized_sizing

Demonstrates negative fractional bits, resulting in coarser resolution and larger step size. Useful for scaled accumulators.

```python
from fxpmath import Fxp

x = Fxp(16, signed=True, n_word=8, n_frac=-2)
print(x.dtype, x.n_int, x())
# fxp-s8/-2 9 16.0
```

--------------------------------

### Set Rounding Mode at Instantiation

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Instantiate an Fxp object with a specific rounding mode. The 'floor' mode is used as an example here.

```python
x = Fxp(3.25, True, 16, 8, rounding='floor')
```

--------------------------------

### Zero Integer Bits Example

Source: https://francof2a.github.io/fxpmath/docs/generalized_sizing

Illustrates zero integer bits, commonly used for normalized signals and coefficients, providing a fractional-style range.

```python
from fxpmath import Fxp

u = Fxp(0.75, signed=True, n_word=8, n_frac=7)
print(u.dtype, u.n_int, u())
# fxp-s8/7 0 0.75
```

--------------------------------

### Negative Integer Bits Example

Source: https://francof2a.github.io/fxpmath/docs/generalized_sizing

Shows negative integer bits, which is geometrically equivalent to the binary point being outside the stored word. This case is the same as fractional bits greater than word bits.

```python
from fxpmath import Fxp

z = Fxp(1, signed=False, n_word=4, n_frac=5)
print(z.dtype, z.n_int, z.raw(), z())
# fxp-u4/5 -1 15 0.46875
```

--------------------------------

### Getting and Setting Fxp Values from Operations

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Retrieve the numerical value of an Fxp operation using `get_val()` and set it into another Fxp variable using `set_val()`. Alternatively, use the shorthand `()` for getting the value.

```python
y.set_val( (x1*x3 - 3*x2).get_val() )   # equivalent to y.equal(x1*x3 - 3*x2), but less elegant
y( (x1*x3 - 3*x2)() )                   # just a little more elegant
```

--------------------------------

### Fractional Bits Greater Than Word Bits Example

Source: https://francof2a.github.io/fxpmath/docs/generalized_sizing

Illustrates fractional bits exceeding word bits, leading to very small magnitudes and negative integer bits. The binary point is to the left of the MSB.

```python
from fxpmath import Fxp

y = Fxp(-3, signed=True, n_word=1, n_frac=10)
print(y.dtype, y.n_int, y.raw(), y())
# fxp-s1/10 -10 -1 -0.0009765625
```

--------------------------------

### Get Fxp Value as Numpy Array

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Retrieve the numerical value stored in the Fxp variable as a NumPy array. This is useful for numerical operations or inspection.

```python
x.get_val()
```

```python
x()
```

--------------------------------

### Use Fxp Templates for Initialization

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Initialize new Fxp objects using the `like` method with predefined templates to ensure they inherit the correct properties.

```python
# init
x1 = Fxp(-3.2).like(DATA)
x2 = Fxp(25.5).like(DATA)
c  = Fxp(2.65).like(CONSTANTS)
m  = Fxp().like(MULTIPLIERS)
y  = Fxp().like(ADDERS)
```

--------------------------------

### Explore Fxp Sizing Options for Addition

Source: https://francof2a.github.io/fxpmath/docs/config

Iterates through various `op_sizing` options ('optimal', 'same', 'fit', 'largest', 'smallest') for Fxp addition and displays the resulting Fxp object's info for each. This demonstrates how different sizing strategies affect the output type.

```python
x = Fxp(3.5, True, 16, 4)
y = Fxp(-1.25, True, 24, 8)

for s in x.config._op_sizing_list:
    x.config.op_sizing = s
    print('{}:'.format(x.config.op_sizing))
    (x + y).info()
```

--------------------------------

### Print Fxp Configuration

Source: https://francof2a.github.io/fxpmath/docs/config

Instantiate an Fxp object and print its configuration parameters. This shows the default settings for various behavior-controlling options.

```python
x = Fxp(None, True, 16, 4)
x.config.print()
```

--------------------------------

### Initialize Fxp Variable with Various Data Types

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Demonstrates initializing Fxp variables with diverse input types including numbers, lists, NumPy arrays, and string representations of numbers.

```python
x(2)
```

```python
x(-1.75)
```

```python
x(-2.5 + 1j*0.25)
```

```python
x([1.0, 1.5, 2.0])
```

```python
x(np.random.uniform(size=(2,4)))
```

```python
x('3.5')
```

```python
x('0b11001010')
```

```python
x('0xA4')
```

--------------------------------

### Initialize Fxp with Scaling and Bias

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Initialize an Fxp object using scaling and bias to represent numbers within a specific range and precision, using fewer bits.

```python
x = Fxp(10128.5, signed=False, n_word=12, scale=1, bias=10000)
```

--------------------------------

### Initialize Fxp Templates

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Define Fxp objects as templates with specific properties (signed, word bits, fractional bits) to ensure consistent behavior across multiple instances.

```python
# Fxp like templates
DATA        = Fxp(None, True, 24, 15)
ADDERS      = Fxp(None, True, 40, 16)
MULTIPLIERS = Fxp(None, True, 24, 8)
CONSTANTS   = Fxp(None, True, 8, 4)
```

--------------------------------

### Raw Operation Method for Fxp Addition

Source: https://francof2a.github.io/fxpmath/docs/config

Demonstrates Fxp addition using the 'raw' operation method, which uses internal integer representation for accuracy. This method is suitable for extended precision calculations.

```python
a = Fxp([-1.0, 0.0, 1.0], True, 128, 96)
b = Fxp([2**-64, -2**48, 2**32], True, 128, 96)

c = a + b
print(c)
print(c-a) # equal to b
```

--------------------------------

### Display Fxp Info with Scaling

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Display detailed information about an Fxp object, including its value, scaling, bias, and bit allocation, using the `info` method.

```python
x.info(3)
```

--------------------------------

### Basic Arithmetic Operations with Constants

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Perform addition, subtraction, multiplication, division, floor division, modulo, and power operations with Fxp objects and constants. The precision of the result depends on Fxp configuration.

```python
0.75 + x    # add a constant
x - 0.125   # substract a constant
3 * x       # multiply by a constant
x / 1.5     # division by a constant
x // 1.5    # floor division by a constant
x % 2       # modulo
x ** 3      # power
```

```python
y = 3.25 * (x - 0.5)    # y is a new Fxp object
```

--------------------------------

### Create Fractional Fixed-Point Variable

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Create an Fxp variable with a given value. Bit sizes are automatically calculated to satisfy the value. Use .info() to see details.

```python
from fxpmath import Fxp

x = Fxp(-7.25)      # create fxp variable with value 7.25
x.info()
```

--------------------------------

### Configure Array Operation Output Like

Source: https://francof2a.github.io/fxpmath/docs/config

Analogous to `op_out_like`, this configuration is used with numpy functions. It ensures the output of array operations matches the properties of a specified Fxp object.

```python
w = Fxp([1.0, -2.5, 3.0, -4.5], dtype='fxp-s16/4')
w.config.array_op_out_like = Fxp(0.0, True, 32, 8)

y = np.sum(w)
y.info()

y = np.cumsum(w)
y.info()
```

--------------------------------

### Configure Overflow Behavior on Fxp Instantiation

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Set the overflow behavior ('saturate' or 'wrap') when creating a new Fxp instance. The default behavior is 'saturate'.

```python
x = Fxp(3.25, True, 16, 8, overflow='saturate')
```

--------------------------------

### Generating a Sine Wave with Fxp

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Use Fxp objects in conjunction with NumPy to generate a sine wave. Ensure the Fxp object is configured appropriately for the desired precision and range.

```python
import numpy as np

f = 5.0         # signal frequency
fs = 400.0      # sampling frequency
N = 1000        # number of samples

n = Fxp( list(range(N)) )                       # sample indices
y( 0.5 * np.sin(2 * np.pi * f * n() / fs) )     # a sin wave with 5.0 Hz of frequecy sampled at 400 samples per second
```

--------------------------------

### Signedness and Overflow Orthogonality

Source: https://francof2a.github.io/fxpmath/docs/generalized_sizing

Shows how sizing is separate from runtime overflow behavior. Use 'wrap' or 'saturate' based on desired behavior at the limits.

```python
from fxpmath import Fxp

a = Fxp(20.0, signed=False, n_word=4, n_frac=0, overflow='wrap')
b = Fxp(20.0, signed=False, n_word=4, n_frac=0, overflow='saturate')

print(a())  # wrapped modulo range
print(b())  # clipped to max
```

--------------------------------

### Repr Operation Method for Fxp Addition

Source: https://francof2a.github.io/fxpmath/docs/config

Illustrates Fxp addition with the 'repr' operation method, which uses the original data types. This can lead to precision loss due to float limitations, as shown when subtracting the original value.

```python
a.config.op_method = 'repr'
b.config.op_method = 'repr'

c = a + b
print(c)
print(c-a) # should be equal to b, but it doesn't
```

--------------------------------

### Access Fxp Upper and Lower Limits

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Retrieve the maximum and minimum representable values for a given Fxp configuration using the 'upper' and 'lower' attributes.

```python
print(x.upper)
print(x.lower)
```

--------------------------------

### Same Input Size for Fxp Multiplication

Source: https://francof2a.github.io/fxpmath/docs/config

Configures the Fxp object to use 'same' input size when multiplying with a non-Fxp object. The non-Fxp object is converted to Fxp with the same bit and fraction sizes, potentially losing precision.

```python
x = Fxp(2.0, True, 16, 2)
x.config.op_input_size = 'same'

z = x * 2.125

z.info()
```

--------------------------------

### Copy and Assign New Value to Fxp

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Copy an Fxp object and immediately assign a new value to the copy. The `like` method can be chained for property copying.

```python
y = x.copy()(-1.25)     # where -1.25 y the new value for `y` after copying `x`. It isn't necessary the `y` exists previously.
```

```python
y = Fxp(-1.25).like(x)
```

```python
y = Fxp(-1.25, like=x)
```

```python
y = y.like(x)(-1.25)    # better!
```

--------------------------------

### Logical (Bitwise) Operations with Fxp

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Perform bitwise AND, NOT (inversion), OR, and XOR operations on Fxp objects with constants or other Fxp variables. Bit shifting to the left and right is also supported.

```python
x & 0b1100110011110000          # Fxp var AND constant
x & Fxp('0b11001100.11110000')  # Fxp var AND other Fxp with same constant
x & y                           # x AND y, both previoulsy defined

~x      # bits inversion
x | y   # x OR y
x ^ y   # x XOR y

x << 5  # x shifted 5 bits to the left
x >> 3  # x shifted 3 bits to the right (filled with sign bit)
```

--------------------------------

### Copy Fxp Object

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Create a copy of an Fxp object, including its value. `deepcopy` is also available. `like` copies properties to an existing object.

```python
y = x.copy()        # copy also the value stored
```

```python
y = x.deepcopy()
```

```python
y = y.like(x) # if you want to preserve a value previously stored in `y` and only copy the properties from `x`:
```

--------------------------------

### Create Fxp Variable Using Dtype String

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Specify Fxp variable properties using a dtype string in 'fxp-s<n_word>/<n_frac>' format or Qm.n notation.

```python
x = Fxp(-7.25, dtype='fxp-s16/8')
```

```python
x = Fxp(-7.25, dtype='S8.8')
```

--------------------------------

### Perform Calculations with Fxp Objects

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Perform arithmetic operations between Fxp objects, ensuring they have compatible properties or are initialized using templates.

```python
# do the calc!
m.equal(c*x2)
y.equal(x1 + m)
```

--------------------------------

### Comparison Operations with Fxp

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Compare Fxp objects with constants or other Fxp variables using standard comparison operators like greater than, equal to, etc.

```python
x > 5
x == y
# ... and other comparison availables
```

--------------------------------

### Configure Constant Operation Sizing

Source: https://francof2a.github.io/fxpmath/docs/config

Demonstrates how `const_op_sizing` affects the output size when a constant is used as an operand with an Fxp object. The constant is first converted to Fxp based on `op_input_size`, and then the output size is determined by `const_op_sizing`.

```python
x = Fxp(3.5, True, 16, 4)

for s in x.config._const_op_sizing_list:
    x.config.const_op_sizing = s
    print('{}:'.format(x.config.const_op_sizing))
    (x + 2).info()
```

--------------------------------

### Best Input Size for Fxp Multiplication

Source: https://francof2a.github.io/fxpmath/docs/config

Sets the Fxp object to use 'best' input size when multiplying with a non-Fxp object. The non-Fxp value is converted to an Fxp with the optimal size to represent its value accurately before the operation.

```python
x = Fxp(2.0, True, 16, 2)
x.config.op_input_size = 'best'

z = x * 2.125

z.info()
```

--------------------------------

### Check Fxp Precision

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Print the precision of an Fxp object, which is determined by the number of fractional bits.

```python
print(Fxp(n_frac=7).precision)  # print the precision of a fxp with 7 bits for fractional part.
```

--------------------------------

### Configure Array Operation Output

Source: https://francof2a.github.io/fxpmath/docs/config

Similar to `op_output`, this setting is used specifically with numpy functions. It defines the Fxp object that will store the result of array operations.

```python
w = Fxp([1.0, -2.5, 3.0, -4.5], dtype='fxp-s16/4')
z = Fxp(0.0, True, 16, 4)
w.config.array_op_out = z

y = np.sum(w)
y.info()
z.info()
print(y is z)
```

--------------------------------

### Explicitly Define Fxp Variable Properties

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Create an Fxp variable by explicitly defining its signedness, total word bits, and fractional bits. This ensures precise control over the variable's representation.

```python
x = Fxp(-7.25, signed=True, n_word=16, n_frac=8)
```

```python
x = Fxp(-7.25, True, 16, 8)
```

--------------------------------

### Detailed Fxp Variable Information

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Print detailed information about an Fxp variable, including its data type, value, bit allocation, and numerical limits, by increasing the verbosity of the info method.

```python
x.info(verbose=3)
```

--------------------------------

### Set Rounding Mode to 'floor'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'floor'.

```python
x.rounding = 'floor'
```

--------------------------------

### Assigning Arithmetic Results to a Specific Fxp Variable

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Store the result of an arithmetic operation into a pre-defined Fxp variable with a specific format. Use the `equal` method for direct assignment.

```python
# variable to store a result
y = Fxp(None, signed=True, n_word=32, n_frac=16)

y.equal(x1*x3 - 3*x2)
```

--------------------------------

### Print Fxp Precision

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Retrieve and print the precision of an Fxp object. This is useful for understanding the current storage capabilities of the fixed-point number.

```python
print(x.precision)
```

--------------------------------

### Set Rounding Mode to 'nearest_neginf'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'nearest_neginf'.

```python
x.rounding = 'nearest_neginf'
```

--------------------------------

### Set Array Operation Method for Fxp Conversion

Source: https://francof2a.github.io/fxpmath/docs/config

Determines the values used for numpy arrays created from Fxp objects. 'repr' uses the Fxp's representation type values, while 'raw' uses the object's raw internal values. This also affects kernel op_method when array conversion is involved.

```python
w = Fxp([1.0, -2.5, 3.0, -4.5], dtype='fxp-s8/2')
w.config.array_op_method = 'repr'

w_array = np.asarray(w)
print(w_array, type(w_array))

w.config.array_op_method = 'raw'
w_array = np.asarray(w)
print(w_array, type(w_array))
```

--------------------------------

### Check Fxp Status Flags

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Retrieve status flags (overflow, underflow, inaccuracy) from an Fxp object. Use format=str for a string representation of raised flags.

```python
x.get_status()  # returns a dictionary with the flags
```

```python
x.get_status(format=str)    # return a string with flags RAISED only
```

--------------------------------

### Set Rounding Mode to 'ceil'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'ceil'.

```python
x.rounding = 'ceil'
```

--------------------------------

### Set Rounding Mode to 'nearest_posinf'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'nearest_posinf'.

```python
x.rounding = 'nearest_posinf'
```

--------------------------------

### Represent Fxp Value in Binary and Hexadecimal

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Convert the Fxp variable's value to its binary or hexadecimal string representation. Options include showing a fractional dot or using a sign symbol.

```python
x.bin()
```

```python
x.bin(frac_dot=True)    # binary with fractional dot
```

```python
x.base_repr(2)          # binary with sign symbol (not complement)
```

```python
x.hex()
```

```python
x.base_repr(16)         # hex with sign symbol (not complement)
```

--------------------------------

### Define Fxp Result Type with op_out_like

Source: https://francof2a.github.io/fxpmath/docs/config

Uses `op_out_like` to specify the Fxp type for the operation's result. The result will conform to the bit and fraction size defined by the Fxp object assigned to `op_out_like`.

```python
x = Fxp(2.0, True, 16, 2)
x.config.op_out = Fxp(None, True, 24, 4)

z = x * 3.5 

z.info()
```

--------------------------------

### Arithmetic Operations with Two Fxp Operands

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Perform arithmetic operations between two Fxp objects. The size of the resulting Fxp object is determined by the operands' sizes and the 'op_sizing' configuration.

```python
# Fxp as operands
x1 = Fxp(-7.25, signed=True, n_word=16, n_frac=8)
x2 = Fxp(1.5, signed=True, n_word=16, n_frac=8)
x3 = Fxp(-0.5, signed=True, n_word=8, n_frac=7)

y = 2*x1 + x2 - 0.5     # y is a new Fxp object

y = x1*x3 - 3*x2        # y is a new Fxp object, again
```

--------------------------------

### Set Rounding Mode to 'nearest_zero'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'nearest_zero'.

```python
x.rounding = 'nearest_zero'
```

--------------------------------

### Set Rounding Mode to 'bit_trunc'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'bit_trunc'.

```python
x.rounding = 'bit_trunc'
```

--------------------------------

### Set Rounding Mode to 'nearest_away'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'nearest_away'.

```python
x.rounding = 'nearest_away'
```

--------------------------------

### Set Rounding Mode to 'around'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'around'.

```python
x.rounding = 'around'
```

--------------------------------

### Reshape Fxp Variable with fxpmath.functions

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Use the dedicated reshape function from fxpmath.functions to reshape an Fxp variable, supporting both 'shape' and 'newshape' keyword arguments.

```python
from fxpmath import functions

functions.reshape(x, shape=(1, 4))
```

```python
functions.reshape(x, newshape=(1, 4))
```

--------------------------------

### Access Raw Fxp Value

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Retrieve the raw, integer-like value stored in the Fxp variable's memory. This value is not intended for direct calculations but can be useful for low-level inspection.

```python
x.val
```

--------------------------------

### Set Rounding Mode to 'fix'

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Change the rounding mode of an Fxp object to 'fix'.

```python
x.rounding = 'fix'
```

--------------------------------

### Set Array Output Type for Numpy Functions

Source: https://francof2a.github.io/fxpmath/docs/config

Controls the return type when using numpy functions on Fxp objects. Set to 'fxp' to return an Fxp object or 'array' to return a numpy n-dimensional array.

```python
x = Fxp([1.0, 2.5, 3.0, 4.5], dtype='fxp-s16/4')
x.config.array_output_type = 'fxp'

z = np.sum(x)
z.info()

x.config.array_output_type = 'array'
z = np.sum(x)
print(z, type(z))
```

--------------------------------

### Represent Fxp Variable Value

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Display the Fxp variable's value in its default representation, which includes its dtype and value.

```python
x
```

--------------------------------

### Index and Modify Fxp Array Elements

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Access and modify individual elements within an Fxp variable that holds array data using standard Python indexing. This allows for targeted updates to specific values.

```python
x[2] = 1.0      # modify the value in the index 2
```

```python
print(x[2])
```

--------------------------------

### Change Rounding Mode After Instantiation

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Modify the rounding mode of an existing Fxp object. This demonstrates changing the rounding mode to 'trunc'.

```python
x.rounding = 'trunc'
```

--------------------------------

### Check Fxp Overflow and Underflow Status

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Determine if an overflow or underflow condition occurred during the last operation by inspecting the 'overflow' and 'underflow' fields within the Fxp's status dictionary. No warnings are raised by default.

```python
print(x.status['overflow'])
print(x.status['underflow'])
```

--------------------------------

### Store Fxp Operation Result in a Specific Object

Source: https://francof2a.github.io/fxpmath/docs/config

Assigns an Fxp object to `op_out` to store the result of an arithmetic operation. Both the operand and the output object are updated with the result.

```python
x = Fxp(2.0, True, 16, 2)
z = Fxp(0.0, True, 16, 4)

x.config.op_out = z

(x + 1).info()
z.info()
```

--------------------------------

### Reset Fxp Status Flags

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Reset all raised status flags for an Fxp object.

```python
x.reset()
```

--------------------------------

### Resize Fxp Variable

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Modify the size (signedness, word bits, fractional bits) of an existing Fxp variable in-place.

```python
x.resize(True, 8, 6)    # signed=True, n_word=8, n_frac=6
```

--------------------------------

### Change Overflow Behavior After Fxp Instantiation

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Modify the overflow behavior of an existing Fxp object by assigning 'saturate' or 'wrap' to its overflow attribute.

```python
x.overflow = 'saturate'
```

```python
x.overflow = 'wrap'
```

--------------------------------

### Change Fxp Variable Value

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Update the value of an existing Fxp variable. The simplest method is direct assignment using parentheses, or use set_val(). Avoid reassigning the variable to a non-Fxp type.

```python
x(10.75)            # the simpliest way
```

```python
x.set_val(2.125)    # another option
```

```python
x.set_val(43, raw=True)
```

--------------------------------

### Reshape Fxp Variable with NumPy

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Reshape an Fxp variable using NumPy's reshape function. This is useful for integrating Fxp arrays into existing NumPy workflows.

```python
np.reshape(x, (1, 4))
```

```python
np.reshape(x, shape=(1, 4))
```

--------------------------------

### Convert Fxp Value to Other Data Types

Source: https://francof2a.github.io/fxpmath/docs/quick_start

Cast the Fxp variable's value to standard Python types like int, float, or complex. Note that casting to int may involve truncation or rounding.

```python
x.astype(int)
```

```python
x.astype(float)
```

```python
x.astype(complex)
```
Tokens:
Raw