const nb::int_& python_long_int_bit_pattern,

std::optional<int> int_bits,

std::optional<int> frac_bits,

std::optional<int> bits

)

: APyFixed(int_bits, frac_bits, bits)

{

_data = python_long_to_limb_vec(python_long_int_bit_pattern, _data.size());

_overflow_twos_complement(_data.begin(), _data.end(), _bits, _int_bits);

std::optional<int> int_bits, std::optional<int> frac_bits, std::optional<int> bits

)

: _bits { bits_from_optional(bits, int_bits, frac_bits) }

, _int_bits { int_bits.has_value() ? *int_bits : *bits - *frac_bits }

, _data(bits_to_limbs(_bits), 0)

{

: _bits { bits }

, _int_bits { int_bits }

, _data(bits_to_limbs(_bits), 0)

{

: APyFixed(bits, int_bits)

{

assert(std::distance(begin, end) >= 0);

// Copy data into resulting vector

std::size_t it_elements = std::distance(begin, end);

std::copy_n(begin, std::min(vector_size(), it_elements), std::begin(_data));

// Two's-complements overflow bits outside of the range

_overflow_twos_complement(std::begin(_data), std::end(_data), _bits, _int_bits);

{

const int res_int_bits = std::max(rhs.int_bits(), int_bits()) + 1;

const int res_frac_bits = std::max(rhs.frac_bits(), frac_bits());

const int res_bits = res_int_bits + res_frac_bits;

APyFixed result(res_bits, res_int_bits);

auto lhs_shift_amount = unsigned(res_frac_bits - frac_bits());

auto rhs_shift_amount = unsigned(res_frac_bits - rhs.frac_bits());

if (unsigned(res_bits) <= APY_LIMB_SIZE_BITS) {

// Result bits fits in a single limb. Use native operation

result._data[0] = base_op {}(

_data[0] << lhs_shift_amount, rhs._data[0] << rhs_shift_amount

);

} else {

// Resulting number of bits is more than one limb. Use ripple-carry operation

ScratchVector<apy_limb_t, 8> operand(bits_to_limbs(res_bits));

_cast_no_quantize_no_overflow(

std::begin(_data),

std::end(_data),

std::begin(result._data),

std::end(result._data),

lhs_shift_amount

);

_cast_no_quantize_no_overflow(

std::begin(rhs._data),

std::end(rhs._data),

std::begin(operand),

std::end(operand),

rhs_shift_amount

);

ripple_carry_op {}(

&result._data[0], // dst

&result._data[0], // src1

&operand[0], // src2

result.vector_size() // limb vector length

);

}

return result;

{

const int res_bits = _bits + 1;

APyFixed result(res_bits, _int_bits + 1);

if (unsigned(res_bits) <= APY_LIMB_SIZE_BITS) {

result._data[0] = std::abs(apy_limb_signed_t(_data[0]));

} else {

limb_vector_abs(_data.begin(), _data.end(), result._data.begin());

}

return result;

{

return apy_inplace_add_one_lsb(

&_data[0], // dst

vector_size() // limb vector length

);

{

nb::module_ fractions = nb::module_::import_("fractions");

nb::object Fraction = fractions.attr("Fraction");

if (is_zero()) {

return Fraction(0, 1);

}

auto trailing_zs = trailing_zeros();

auto frac_bits = this->frac_bits();

// Negative fractional bits special case

if (frac_bits <= 0) {

// Must add more bits to numerator

auto numerator = std::vector<apy_limb_t>(bits_to_limbs(bits() - frac_bits));

limb_vector_copy_sign_extend(

std::begin(_data),

std::end(_data),

std::begin(numerator),

std::end(numerator)

);

limb_vector_lsl(

std::begin(numerator), std::end(numerator), -frac_bits // shift amount

);

return Fraction(

python_limb_vec_to_long(numerator.begin(), numerator.end(), true), 1

);

}

// Copy numerator

auto numerator = std::vector<apy_limb_t>(_data.size());

limb_vector_copy_sign_extend(

std::begin(_data), std::end(_data), std::begin(numerator), std::end(numerator)

);

if (trailing_zs >= std::size_t(frac_bits)) {

// Integer result, get rid of fractional bits

limb_vector_asr(std::begin(numerator), std::end(numerator), frac_bits);

return Fraction(

python_limb_vec_to_long(numerator.begin(), numerator.end(), true), 1

);

}

// Remove the trailing zeros from numerator and denominator

limb_vector_asr(std::begin(numerator), std::end(numerator), trailing_zs);

// Create power-of-two denominator

auto denominator = std::vector<apy_limb_t>(

bits_to_limbs(std::size_t(frac_bits) - trailing_zs) + 2

);

denominator[0] = 1;

limb_vector_lsl(

std::begin(denominator),

std::end(denominator),

std::size_t(frac_bits) - trailing_zs

);

return Fraction(

python_limb_vec_to_long(numerator.begin(), numerator.end(), true),

python_limb_vec_to_long(denominator.begin(), denominator.end(), false)

);

{

nb::module_ fractions = nb::module_::import_("fractions");

nb::object Fraction = fractions.attr("Fraction");

if (is_zero()) {

return nb::make_tuple(0, 1);

}

auto trailing_zs = trailing_zeros();

auto frac_bits = this->frac_bits();

// Negative fractional bits special case

if (frac_bits <= 0) {

// Must add more bits to numerator

auto numerator = std::vector<apy_limb_t>(bits_to_limbs(bits() - frac_bits));

limb_vector_copy_sign_extend(

std::begin(_data),

std::end(_data),

std::begin(numerator),

std::end(numerator)

);

limb_vector_lsl(

std::begin(numerator), std::end(numerator), -frac_bits // shift amount

);

return nb::make_tuple(

python_limb_vec_to_long(numerator.begin(), numerator.end(), true), 1

);

}

// Copy numerator

auto numerator = std::vector<apy_limb_t>(_data.size());

limb_vector_copy_sign_extend(

std::begin(_data), std::end(_data), std::begin(numerator), std::end(numerator)

);

if (trailing_zs >= std::size_t(frac_bits)) {

// Integer result, get rid of fractional bits

limb_vector_asr(std::begin(numerator), std::end(numerator), frac_bits);

return nb::make_tuple(

python_limb_vec_to_long(numerator.begin(), numerator.end(), true), 1

);

}

// Remove the trailing zeros from numerator and denominator

limb_vector_asr(std::begin(numerator), std::end(numerator), trailing_zs);

// Create power-of-two denominator

auto denominator = std::vector<apy_limb_t>(

bits_to_limbs(std::size_t(frac_bits) - trailing_zs) + 2

);

denominator[0] = 1;

limb_vector_lsl(

std::begin(denominator),

std::end(denominator),

std::size_t(frac_bits) - trailing_zs

);

return nb::make_tuple(

python_limb_vec_to_long(numerator.begin(), numerator.end(), true),

python_limb_vec_to_long(denominator.begin(), denominator.end(), false)

);

{

return fixed_point_to_string_dec(

std::begin(_data), std::end(_data), _bits, _int_bits

);

{

switch (base) {

case 10:

return to_string_dec();

default:

auto msg = fmt::format("APyFixed.__str__: base={} is not supported", base);

throw nb::value_error(msg.c_str());

}

{

// Trim the string from leading and trailing whitespace

std::string str_trimmed = string_trim_whitespace(str);

// Check the validity as a decimal string

if (!is_valid_decimal_numeric_string(str_trimmed)) {

throw nb::value_error("Not a valid decimal numeric string");

}

// Test if negative. If so, remove the negative sign from the string.

// `is_valid_decimal_numeric_string()` makes sure that str_trimmed[0] is valid.

bool is_negative = str_trimmed.front() == '-';

if (is_negative) {

str_trimmed.erase(0, 1);

}

// Trim leading and trailing zeros that don't affect the numeric value of the

// decimal number

str_trimmed = string_trim_zeros(str_trimmed);

// Find the binary point of the trimmed string and remove it from the string

std::size_t binary_point_dec = str_trimmed.find('.');

binary_point_dec = (binary_point_dec == std::string::npos) ? 0 : binary_point_dec;

str_trimmed.erase(

std::remove(str_trimmed.begin(), str_trimmed.end(), '.'), str_trimmed.end()

);

// Copy characters (from back) of the trimmed string into a BCD list

std::vector<uint8_t> bcd_list;

std::for_each(str_trimmed.crbegin(), str_trimmed.crend(), [&](char c) {

bcd_list.push_back(c - 0x30);

});

// Multiply BCD number by 2^(frac_bits() + 1) (extra bit for quantization)

auto bcd_list_size_prev = bcd_list.size();

for (int i = 0; i < frac_bits() + 1; i++) {

bcd_mul2(bcd_list);

}

// Remove elements after decimal dot

if (binary_point_dec) {

bcd_list.erase(

bcd_list.begin(), bcd_list.begin() + bcd_list_size_prev - binary_point_dec

);

}

// Reverse double-dabble algorithm (BCD -> binary)

std::vector<apy_limb_t> data = reverse_double_dabble(bcd_list);

// Round the data

apy_inplace_add_one_lsb(

&data[0], // dst

data.size() // limb vector length

);

apy_inplace_right_shift(

&data[0], // dst/src

data.size(), // limb vector length

1 // shift amount

);

// Adjust limb vector if negative fractional bits are present

if (frac_bits() + 1 < 0) {

limb_vector_asr(data.begin(), data.end(), -(frac_bits() + 1));

}

// Copy the data into the result vector

_data = data;

_data.resize(bits_to_limbs(bits()));

if (is_negative) {

limb_vector_negate_inplace(_data.begin(), _data.end());

}

// Two's complement overflow and we're done

_overflow_twos_complement(_data.begin(), _data.end(), bits(), int_bits());

{

(void)str;

throw NotImplementedException();

{

(void)str;

throw NotImplementedException("Not implemented: APyFixed::from_string_oct()");

{

switch (base) {

case 8:

set_from_string_oct(str);

break;

case 10:

set_from_string_dec(str);

break;

case 16:

set_from_string_hex(str);

break;

default:

throw NotImplementedException();

break;

}

{

return python_limb_vec_to_long(

_data.begin(), _data.end(), false, bits() % APY_LIMB_SIZE_BITS

);

{

std::stringstream ss {};

ScratchVector<apy_limb_t> data = _data;

if (bits() % APY_LIMB_SIZE_BITS) {

apy_limb_t and_mask = (apy_limb_t(1) << (bits() % APY_LIMB_SIZE_BITS)) - 1;

data.back() &= and_mask;

}

// Double-dabble for binary-to-BCD conversion

ss << bcds_to_string(double_dabble(static_cast<std::vector<apy_limb_t>>(data)));

return ss.str();

{

return fmt::format(

"APyFixed({}, bits={}, int_bits={})",

bit_pattern_to_string_dec(),

bits(),

int_bits()

);

{

if (this->is_negative()) {

APyFixed absval = abs();

return fmt::format(

"$-\\frac{{{}}}{{2^{{{}}}}} = {}$",

absval.bit_pattern_to_string_dec(),

frac_bits(),

to_string_dec()

);

}

return fmt::format(

"$\\frac{{{}}}{{2^{{{}}}}} = {}$",

bit_pattern_to_string_dec(),

frac_bits(),

to_string_dec()

);

const std::variant<const APyFixed*, const APyFixedArray*>& other

) const

{

if (!std::holds_alternative<const APyFixed*>(other)) {

return false;

} else {

auto&& other_scalar = *std::get<const APyFixed*>(other);

return bits() == other_scalar.bits() && int_bits() == other_scalar.int_bits()

&& *this == other_scalar;

}

{

std::size_t leading_zeros = limb_vector_leading_zeros(_data.begin(), _data.end());

if (leading_zeros == 0) {

return 0;

} else {

std::size_t utilized_bits_last_limb = ((bits() - 1) % APY_LIMB_SIZE_BITS) + 1;

return leading_zeros - (APY_LIMB_SIZE_BITS - utilized_bits_last_limb);

}

{

std::size_t leading_ones = limb_vector_leading_ones(_data.begin(), _data.end());

if (leading_ones == 0) {

return 0;

} else {

std::size_t utilized_bits_last_limb = (bits() - 1) % APY_LIMB_SIZE_BITS + 1;

return leading_ones - (APY_LIMB_SIZE_BITS - utilized_bits_last_limb);

}

{

std::size_t trailing_zeros = limb_vector_trailing_zeros(_data.begin(), _data.end());

return std::min(trailing_zeros, static_cast<std::size_t>(bits()));

{

int frac_bits = bits() - int_bits();

if (frac_bits <= 0) {

return 0; // early return

}

std::size_t utilized_full_frac_limbs = frac_bits / APY_LIMB_SIZE_BITS;

std::size_t utilized_frac_bits_last_limb = frac_bits % APY_LIMB_SIZE_BITS;

std::size_t leading_frac_bits_full_limbs = limb_vector_leading_zeros(

_data.begin(), _data.begin() + utilized_full_frac_limbs

);

std::size_t leading_frac_bits_last_limb = 0;

if (utilized_frac_bits_last_limb) {

apy_limb_t mask = (apy_limb_t(1) << utilized_frac_bits_last_limb) - 1;

apy_limb_t limb = _data[utilized_full_frac_limbs];

limb &= mask;

leading_frac_bits_last_limb = ::leading_zeros(limb)

- (APY_LIMB_SIZE_BITS - utilized_frac_bits_last_limb);

}

if (leading_frac_bits_last_limb != utilized_frac_bits_last_limb) {

return leading_frac_bits_last_limb;

} else {

return leading_frac_bits_last_limb + leading_frac_bits_full_limbs;

}

{

unsigned test_binary_point = std::max(0, frac_bits() + n);

return limb_vector_gte_pow2(_data.begin(), _data.end(), test_binary_point);

{

const unsigned binary_point = std::max(0, frac_bits() + n);

limb_vector_set_bit(_data.begin(), _data.end(), binary_point, bit);

{

if (n < 0) {

throw NotImplementedException("Not implemented: power with negative integers.");

}

if (n == 1) {

return *this;

}

if (n == 0) {

if (frac_bits() < 0) {

return APyFixed(int_bits(), int_bits(), { 1 });

} else {

return APyFixed(

bits(), int_bits(), { apy_limb_t(1) << (unsigned int)frac_bits() }

);

}

}

// Early exit for one of the most common cases

if (n == 2) {

return *this * *this;

}

auto result = ipow(n);

// Remove two integer bit as the starting value has two bits

return result.cast_no_overflow(result.bits() - 2, result.int_bits() - 2);

{

// Because how pown is written, we know n will be >= 3,

// this fact can probably be used to optimize this code further.

APyFixed base = *this;

APyFixed result = APyFixed(2, 2, { 1 });

for (;;) {

if (n & 1) {

result = result * base; // Until *= is implemented

}

n >>= 1;

if (!n) {

break;

}

base = base * base; // Until *= is implemented

}

return result;

const nb::object& py_obj,

std::optional<int> int_bits,

std::optional<int> frac_bits,

std::optional<int> bits

)

{

if (nb::isinstance<nb::int_>(py_obj)) {

return APyFixed::from_integer(

nb::cast<nb::int_>(py_obj), int_bits, frac_bits, bits

);

} else if (nb::isinstance<nb::float_>(py_obj)) {

const auto d = static_cast<double>(nb::cast<nb::float_>(py_obj));

return APyFixed::from_double(d, int_bits, frac_bits, bits);

} else if (nb::isinstance<APyFixed>(py_obj)) {

const auto d = static_cast<APyFixed>(nb::cast<APyFixed>(py_obj));

return d.cast(

int_bits, frac_bits, QuantizationMode::RND_INF, OverflowMode::WRAP, bits

);

} else if (nb::isinstance<APyFloat>(py_obj)) {

const auto d = static_cast<APyFloat>(nb::cast<APyFloat>(py_obj));

return d.to_fixed().cast(

int_bits, frac_bits, QuantizationMode::RND_INF, OverflowMode::WRAP, bits

);

} else {

const nb::type_object type = nb::cast<nb::type_object>(py_obj.type());

const nb::str type_string = nb::str(type);

throw std::domain_error(

fmt::format("Non supported type: {}", type_string.c_str())

);

}