Module index

Module ida_ieee

IEEE floating point functions.

Global variables

var E_SPECIAL_EXP
Exponent in fpvalue_t for NaN and Inf.
var FPVAL_NWORDS
FPVAL_NWORDS = 6
var FPV_BADARG
wrong value of max_exp
var FPV_NAN
NaN.
var FPV_NINF
negative infinity
var FPV_NORM
regular value
var FPV_PINF
positive infinity
var IEEE_E
IEEE_E = 1
var IEEE_EXONE
The exponent of 1.0.
var IEEE_M
IEEE_M = 2
var IEEE_NI
IEEE_NI = 9
var MAXEXP_DOUBLE
MAXEXP_DOUBLE = 1024
var MAXEXP_FLOAT
MAXEXP_FLOAT = 128
var MAXEXP_LNGDBL
MAXEXP_LNGDBL = 16384
var REAL_ERROR_BADDATA
REAL_ERROR_BADDATA = -3
var REAL_ERROR_BADSTR
REAL_ERROR_BADSTR = 2
var REAL_ERROR_FORMAT
REAL_ERROR_FORMAT = -1
var REAL_ERROR_FPOVER
floating overflow or underflow
var REAL_ERROR_INTOVER
eetol*: integer overflow
var REAL_ERROR_OK
no error
var REAL_ERROR_RANGE
REAL_ERROR_RANGE = -2
var REAL_ERROR_ZERODIV
REAL_ERROR_ZERODIV = 3

Functions

def ecleaz(*args) ‑> void
ecleaz(x)
x: unsigned short [(6+3)]

Classes

class fpvalue_shorts_array_t (*args)
Proxy of C++ wrapped_array_t< uint16,FPVAL_NWORDS > class.
__init__(self, data) -> fpvalue_shorts_array_t
data: unsigned short (&)[FPVAL_NWORDS]

Instance variables

var bytes : bytevec_t
_get_bytes(self) -> bytevec_t
var data
data
class fpvalue_t (*args)
Proxy of C++ fpvalue_t class.
__init__(self) -> fpvalue_t
__init__(self, _in) -> fpvalue_t
in: bytevec12_t const &

Instance variables

var bytes : void
_get_bytes(self)
var float : double
_get_float(self) -> double
var int64
var shorts : wrapped_array_t< uint16,FPVAL_NWORDS >
_get_shorts(self) -> fpvalue_shorts_array_t
var sval
var uint64
var w
w

Methods

def assign(self, *args) ‑> void
assign(self, r)
r: fpvalue_t const &
def clear(self, *args) ‑> void
clear(self)
def compare(self, *args) ‑> int
compare(self, r) -> int
r: fpvalue_t const &
def eabs(self, *args) ‑> void
eabs(self)
Calculate absolute value.
def fadd(self, *args) ‑> fpvalue_error_t
fadd(self, y) -> fpvalue_error_t
Arithmetic operations.
y: (C++: const fpvalue_t &) fpvalue_t const &
def fdiv(self, *args) ‑> fpvalue_error_t
fdiv(self, y) -> fpvalue_error_t
y: fpvalue_t const &
def fmul(self, *args) ‑> fpvalue_error_t
fmul(self, y) -> fpvalue_error_t
y: fpvalue_t const &
def from_10bytes(self, *args) ‑> fpvalue_error_t
from_10bytes(self, fpval) -> fpvalue_error_t
Conversions for 10-byte floating point values.
fpval: (C++: const void *) void const *
def from_12bytes(self, *args) ‑> fpvalue_error_t
from_12bytes(self, fpval) -> fpvalue_error_t
Conversions for 12-byte floating point values.
fpval: (C++: const void *) void const *
def from_int64(self, *args) ‑> void
from_int64(self, x)
x: int64
def from_str(self, *args) ‑> fpvalue_error_t
from_str(self, p) -> fpvalue_error_t
Convert string to IEEE.
p_str: (C++: const char **) pointer to pointer to string. it will advanced.
def from_sval(self, *args) ‑> void
from_sval(self, x)
Convert integer to IEEE.
x: (C++: sval_t)
def from_uint64(self, *args) ‑> void
from_uint64(self, x)
x: uint64
def fsub(self, *args) ‑> fpvalue_error_t
fsub(self, y) -> fpvalue_error_t
y: fpvalue_t const &
def get_kind(self, *args) ‑> fpvalue_kind_t
get_kind(self) -> fpvalue_kind_t
Get value kind.
def is_negative(self, *args) ‑> bool
is_negative(self) -> bool
Is negative value?
def mul_pow2(self, *args) ‑> fpvalue_error_t
mul_pow2(self, power_of_2) -> fpvalue_error_t
Multiply by a power of 2.
power_of_2: (C++: int32)
def negate(self, *args) ‑> void
negate(self)
Negate.
def to_10bytes(self, *args) ‑> fpvalue_error_t
to_10bytes(self, fpval) -> fpvalue_error_t
fpval: void *
def to_12bytes(self, *args) ‑> fpvalue_error_t
to_12bytes(self, fpval) -> fpvalue_error_t
fpval: void *
def to_int64(self, *args) ‑> fpvalue_error_t
to_int64(self, round=False) -> fpvalue_error_t
round: bool
def to_str(self, *args) ‑> void
to_str(self, mode)
Convert IEEE to string.
mode: (C++: uint) broken down into:
  • low byte: number of digits after '.'
  • second byte: FPNUM_LENGTH
  • third byte: FPNUM_DIGITS
def to_sval(self, *args) ‑> fpvalue_error_t
to_sval(self, round=False) -> fpvalue_error_t
Convert IEEE to integer (+-0.5 if round)
round: (C++: bool)
def to_uint64(self, *args) ‑> fpvalue_error_t
to_uint64(self, round=False) -> fpvalue_error_t
round: bool