Numeric Types¶
Builtin numeric types¶
There are three numeric types: plain integers (also called integers), long integers, floating point numbers.
Attention
Complex numbers are not supported as builtin types in RPython. However, you can use RPython libraries to handle complex numbers.
This table describes the details of RPython’s builtin types: lowlevel (LL) types, corresponding C types and sizes in memory (64bit).
Type 
LL Type 
C Type 
Size (32bit) 
Size (64bit) 


Signed 
long 
32 
64 

Signed 
long 
32 
64 

Float 
double 
64 
64 
For more primitive types, you can find them in the primitive type cheat sheet section.
Note that the int
type and long
type are same type in RPython, which
have same low level representation and size.
All builtin numeric types support the following operations.
def numeric(x, y, f, l):
print "int: 1024 =", x
print "float: 3.14 =", f
print "long: 1L =", l
print "x + y =", x + y # sum of x and y
print "x  y =", x  y # difference of x and y
print "x * y =", x * y # product of x and y
print "x / y =", x / y # quotient of x and y
print "x // y =", x // y # (floored) quotient of x and y
print "x % y =", x % y # remainder of x / y
print "x =", x # x negated
print "+x =", +x # x unchanged
print "abs(x) =", abs(x) # absolute value or magnitude of x
print "int(x) =", int(f) # x converted to integer
print "float(x) =", float(y) # x converted to floating point
# print "divmod(x, y) =", divmod(x, y) # the pair (x // y, x % y)
# print "pow(x, y) =", pow(x, y) # x to the power y
def entry_point(argv):
x = 1024 # plain integer
y = 42
f = 3.14 # float
l = 1L # a long integer
numeric(x, y, f, l)
return 0
def target(*args): return entry_point
if __name__ == "__main__": import sys; entry_point(sys.argv)
Attention
Some operations or builtin functions can be used in Python but currently not
supported in RPython such as long()
, complex()
, conjugate()
,
x ** y
, divmode(x, y)
, pow(x, y)
and float(nan)
. However,
RPython’s math library provided some mathematical functions.
Also, it’s worth noting that RPython do constant folding at the compilation
time. Therefore, you may found that some builtin functions work with
RPython’s code in some scenarios. For example, you can write pow(123, 456)
in RPython code and the compiler will calculate the value at the compilation
time.
The code snippet shows that although RPython does not support above mentioned
builtin functions, it still can do constant folding. For instance, divmod(x, y)
will not yield any compilation error if x and y are constants.
def numeric_constfold():
"""Constant folding on numeric."""
x = 1024
y = 42
j = 1j # yield an imaginary number (complex number with zero real part)
print "complex: 1j =", j
print "divmod(x, y) =", divmod(x, y) # the pair (x // y, x % y)
print "pow(x, y) =", pow(x, y) # x to the power y
def numeric_no_constfold(x, y):
"""RPython cannot do constant folding on x and y"""
print "divmod(x, y) =", divmod(x, y) # the pair (x // y, x % y)
print "pow(x, y) =", pow(x, y) # x to the power y
def entry_point(argv):
numeric_constfold()
# numeric_no_constfold(int(argv[1]), int(argv[2])) # compilation error, comment this function to try constant folding
return 0
def target(*args): return entry_point
if __name__ == "__main__": import sys; entry_point(sys.argv)
In addition to above functions, the following code illustrated some other unsupported operations in RPython but supported in CPython.
################### UNSUPPORTED IN RPYTHON ######################
def numeric_unsupported():
"""Operations and functions supported in Python but not supported in RPython."""
x = 1024
y = 42
print "long(x) =", long(x) # x converted to long integer
re = 1
im = 2
# a complex number with real part re, imaginary part im. im defaults to zero.
print "complex(x) =", complex(re, im)
c = 0
# conjugate of the complex number c. (Identity on real numbers)
print "c.conjugate() =", c.conjugate()
print "x ** y =", x ** y # x to the power y
# float also accepts the strings "nan" and "inf" with an optional prefix
# "+" or "" for Not a Number (NaN) and positive or negative infinity.
print "float(inf) =", float("inf")
print "float(+inf) =", float("+inf")
print "float(inf) =", float("inf")
print "float(nan) =", float("nan")
print "float(+nan) =", float("+nan")
print "float(nan) =", float("nan")
def entry_point(argv):
numeric_unsupported()
return 0
def target(*args): return entry_point
if __name__ == "__main__": import sys; entry_point(sys.argv)
Attention
Besides these three builtin numeric types, RPython provides more types such as
r_uint
, r_int32
, r_longlong
, etc in the arithmetic module. For more
information, please refer to rarithmetic in the rlib section
Not like Python, RPython will not automatically use big integer when
appropriate. The big integer type and corresponding operations are provided
in the rbigint
library, please refer to rbigint in the rlib
section.
Bitwise operations¶
Bitwise operations on integer types in RPython are same as Python.
def numeric_bitwise():
x = 2
y = 4
n = 1
print "x = ", x, ", y = ", y
# the bitwise operations sorted in ascending priority
print "x  y =", x  y # bitwise or of x and y
print "x ^ y =", x ^ y # bitwise exclusive or of x and y
print "x & y =", x & y # bitwise and of x and y
print "x << n =", x << n # x shifted left by n bits
print "x >> n =", x >> n # x shifted right by n bits
print "~x =", ~x # the bits of x inverted
def entry_point(argv):
numeric_bitwise()
return 0
def target(*args): return entry_point
if __name__ == "__main__": import sys; entry_point(sys.argv)
Additional methods¶
In Python, there are several additional methods
on integer and float types.
However, all these methods are not supported in RPython. For example,
int.bit_length()
and long.bit_length()
can be used to get the number
of bits to present an integer. Others like float.as_integer_ratio()
,
float.is_integer()
, float.hex()
, and float.fronhex(S)
are also
not supported.
Attention
All additional methods such as int.bit_length()
and
float.float.as_integer_ratio()
on numeric types are not supported in
RPython.
Math functions¶
In Python, the math
module provides access to the mathematical functions
defined by the C standard. For RPython, you can call math functions in the
similar way.
The math functions contain
fabs
, log
, log10
, log1p
, copysign
, atan2
, frexp
,
modf
, ldexp
, pow
, fmod
, hypot
, floor
, sqrt
, sin
,
cos
, acos
, asin
, atan
, ceil
, cosh
, exp
, fabs
,
sinh
, tan
, tanh
, acosh
, asinh
, atanh
, expm1
.
These math functions will call corresponding C functions in libc.
import math
def numeric_math():
print math.exp(1e5)  1
print math.pi
print math.log(10)
print math.floor(1.5)
print math.sqrt(2)
def entry_point(argv):
numeric_math()
return 0
def target(*args): return entry_point
if __name__ == "__main__": import sys; entry_point(sys.argv)