def to_num(value): if value[0] == "+": value = value[1:] if value == "inf.0": return W_Flonum.INF elif value == "-inf.0": return W_Flonum.NEGINF elif value == "nan.0": return W_Flonum.NAN if "/" in value: if len(re.findall('/', value)) > 1: raise Exception( "Something's wrong with this rational number : %s" % value) sides = value.split("/") numer = sides[0] denom = sides[1] return W_Rational.make(to_num(numer), to_num(denom)) v = float(value) if "." in value: return W_Flonum(v) else: try: return W_Fixnum.make(string_to_int(value)) except ParseStringOverflowError: val = rbigint.fromdecimalstr(value) return W_Bignum(val) raise Exception("Didn't know what to do with this number : %s" % value)
def string_to_int_or_long(space, string, base=10): w_longval = None value = 0 try: value = string_to_int(string, base) except ParseStringError, e: raise OperationError(space.w_ValueError, space.wrap(e.msg))
def _to_num(json): assert json.is_object obj = json.value_object() if "real" in obj: r = obj["real"] return values.W_Flonum.make(r.value_float()) if "real-part" in obj: r = obj["real-part"] i = obj["imag-part"] return values.W_Complex.make(_to_num(r), _to_num(i)) if "numerator" in obj: n = obj["numerator"] d = obj["denominator"] return values.W_Rational.make(_to_num(n), _to_num(d)) if "extended-real" in obj: rs = obj["extended-real"].value_string() if rs == "+inf.0": return values.W_Flonum.INF if rs == "-inf.0": return values.W_Flonum.NEGINF if rs == "+nan.0": return values.W_Flonum.NAN if "integer" in obj: rs = obj["integer"].value_string() try: return values.W_Fixnum.make(string_to_int(rs)) except ParseStringOverflowError: val = rbigint.fromdecimalstr(rs) return values.W_Bignum(val) assert False
def read_number_or_id(f, init): sofar = StringBuilder(64) sofar.append(init) while True: c = f.peek() if c == "": break if idchar(c): v = f.read(1) assert v == c sofar.append(v) else: break got = sofar.build() try: val = string_to_int(got) return values.W_Fixnum.make_or_interned(val) except ParseStringOverflowError: val = rbigint.fromdecimalstr(got) return values.W_Bignum(val) except ParseStringError: try: return values.W_Flonum(float(got)) except: return values.W_Symbol.make(got)
def _to_num(json): assert json.is_object obj = json.value_object() if "real" in obj: r = obj["real"] return values.W_Flonum.make(r.value_float()) if "real-part" in obj: r = obj["real-part"] i = obj["imag-part"] return values.W_Complex.make(_to_num(r), _to_num(i)) if "numerator" in obj: n = obj["numerator"] d = obj["denominator"] return values.W_Rational.make(_to_num(n), _to_num(d)) if "extended-real" in obj: rs = obj["extended-real"].value_string() if rs == "+inf.0": return INF if rs == "-inf.0": return NEGINF if rs == "+nan.0": return NAN if "integer" in obj: rs = obj["integer"].value_string() try: return values.W_Fixnum.make(string_to_int(rs)) except ParseStringOverflowError: val = rbigint.fromdecimalstr(rs) return values.W_Bignum(val) assert False
def _string_to_int_or_long(space, w_source, string, base=10): w_longval = None value = 0 try: value = string_to_int(string, base) except ParseStringError as e: raise wrap_parsestringerror(space, e, w_source) except ParseStringOverflowError as e: w_longval = _retry_to_w_long(space, e.parser, w_source) return value, w_longval
def _str2num(s, radix): from rpython.rlib import rarithmetic, rfloat, rbigint from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError from rpython.rlib.rsre import rsre_re as re import math try: if ((radix == 16 and re.match("^[0-9A-Fa-f]+$", s)) or (radix == 8 and re.match("^[0-7]+$", s)) or (radix == 10 and re.match("^[0-9]+$", s))): try: return values.W_Fixnum(rarithmetic.string_to_int(s, base=radix)) except ParseStringOverflowError: return values.W_Bignum(rbigint.rbigint.fromstr(s, base=radix)) if re.match("[+-]?([\d]+)?.?\d+[tT]\d", s): # it's an extflonum return values.W_ExtFlonum(s) if re.match("[+-]?([\d]+)?.?\d+[sf]\d", s): if "f" in s: f_parts = s.split("f") elif "s" in s: f_parts = s.split("s") else: raise ParseStringError("invalid floating point number : %s" % s) if len(f_parts) > 2: raise ParseStringError("invalid floating point number : %s" % s) try: numb = float(f_parts[0]) prec = int(f_parts[1]) p = math.pow(10, prec) except ValueError, e: return values.w_false return values.W_Flonum.make(numb * p, True) if re.match("[+-]?([\d]+)?.?\d+e\d", s): e_parts = s.split("e") if len(e_parts) > 2: raise ParseStringError("invalid floating point number : %s" % s) try: num = float(e_parts[0]) exp = int(e_parts[1]) p = math.pow(10, exp) except ValueError, e: return values.w_false return values.W_Flonum(num * p)
def _string_to_int_or_long(space, w_source, string, base=10): try: value = string_to_int(string, base, allow_underscores=True, no_implicit_octal=True) return wrapint(space, value) except ParseStringError as e: raise wrap_parsestringerror(space, e, w_source) except ParseStringOverflowError as e: return _retry_to_w_long(space, e.parser, w_source)
def _str2num(s, radix): from rpython.rlib import rarithmetic, rfloat, rbigint from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError from rpython.rlib.rsre import rsre_re as re import math try: if ((radix == 16 and re.match("^[0-9A-Fa-f]+$", s)) or (radix == 8 and re.match("^[0-7]+$", s)) or (radix == 10 and re.match("^[0-9]+$", s))): try: return values.W_Fixnum(rarithmetic.string_to_int(s, base=radix)) except ParseStringOverflowError: return values.W_Bignum(rbigint.rbigint.fromstr(s, base=radix)) if re.match("[+-]?([\d]+)?.?\d+[tT]\d", s): # it's an extflonum return values.W_ExtFlonum(s) if re.match("[+-]?([\d]+)?.?\d+[sf]\d", s): if "f" in s: f_parts = s.split("f") elif "s" in s: f_parts = s.split("s") else: raise ParseStringError("invalid floating point number : %s" % s) if len(f_parts) > 2: raise ParseStringError("invalid floating point number : %s" % s) try: numb = float(f_parts[0]) prec = int(f_parts[1]) p = math.pow(10, prec) except ValueError, e: return values.w_false return values.W_Flonum.make(numb*p, True) if re.match("[+-]?([\d]+)?.?\d+e\d", s): e_parts = s.split("e") if len(e_parts) > 2: raise ParseStringError("invalid floating point number : %s" % s) try: num = float(e_parts[0]) exp = int(e_parts[1]) p = math.pow(10, exp) except ValueError, e: return values.w_false return values.W_Flonum(num*p)
def _string_to_int_or_long(space, w_inttype, w_source, string, base=10): try: value = string_to_int(string, base) except ParseStringError as e: raise wrap_parsestringerror(space, e, w_source) except ParseStringOverflowError as e: return _retry_to_w_long(space, e.parser, w_inttype, w_source) if space.is_w(w_inttype, space.w_int): w_result = wrapint(space, value) else: w_result = space.allocate_instance(W_IntObject, w_inttype) W_IntObject.__init__(w_result, value) return w_result
def str2num(w_s): from rpython.rlib import rarithmetic, rfloat, rbigint from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError try: s = w_s.as_str_utf8() if "." in s: return values.W_Flonum(rfloat.string_to_float(s)) else: try: return values.W_Fixnum(rarithmetic.string_to_int(s, base=0)) except ParseStringOverflowError: return values.W_Bignum(rbigint.rbigint.fromstr(s)) except ParseStringError as e: return values.w_false
def str2num(w_s): from rpython.rlib import rarithmetic, rfloat, rbigint from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError s = w_s.as_str_utf8() try: if "." in s: return values.W_Flonum(rfloat.string_to_float(s)) else: try: return values.W_Fixnum(rarithmetic.string_to_int(s, base=10)) except ParseStringOverflowError: return values.W_Bignum(rbigint.rbigint.fromstr(s)) except ParseStringError as e: return values.w_false
def exact_from_node(self, node, radix): s = node.token.source i = 0 # Skip prefixes while s[i] == "#": i += 2 s = s[i:] src_pos = self.make_src_pos(node) try: return kt.Fixnum(string_to_int(s, radix), src_pos) except rstring.ParseStringOverflowError: if radix == 10: bi = rbigint.fromdecimalstr(s) else: bi = rbigint.fromstr(s, radix) return kt.Bignum(bi, src_pos)
def _literal_integer(self, negate_value): try: i = string_to_int(self._text) if negate_value: i = 0 - i result = self._universe.new_integer(i) except ParseStringOverflowError: bigint = rbigint.fromstr(self._text) if negate_value: bigint.sign = -1 result = self._universe.new_biginteger(bigint) except ValueError: raise ParseError("Could not parse integer. " "Expected a number but got '%s'" % self._text, Symbol.NONE, self) self._expect(Symbol.Integer) return result
def _literal_integer(self, negate_value): try: i = string_to_int(self._text) if negate_value: i = 0 - i result = self._universe.new_integer(i) except ParseStringOverflowError: bigint = rbigint.fromstr(self._text) if negate_value: bigint.sign = -1 result = self._universe.new_biginteger(bigint) except ValueError: raise ParseError( "Could not parse integer. " "Expected a number but got '%s'" % self._text, Symbol.NONE, self) self._expect(Symbol.Integer) return result
def read_number_or_id(f, init): sofar = [init] while True: (count, c) = f.peek() if c == "": break c = c[0] if c.isalnum(): sofar.append(f.read(1)) else: break got = "".join(sofar) try: return NumberToken(values.W_Fixnum.make(string_to_int(got))) except ParseStringOverflowError: val = rbigint.fromdecimalstr(got) return NumberToken(values.W_Bignum(val)) except ParseStringError: try: return NumberToken(values.W_Flonum.make(float(got))) except: return SymbolToken(values.W_Symbol.make(got))
def read_number_or_id(f, init): sofar = [init] while True: c = f.peek() if c == "": break if idchar(c): v = f.read(1) assert v == c sofar.append(v) else: break got = "".join(sofar) try: return NumberToken(values.W_Fixnum.make(string_to_int(got))) except ParseStringOverflowError: val = rbigint.fromdecimalstr(got) return NumberToken(values.W_Bignum(val)) except ParseStringError: try: return NumberToken(values.W_Flonum.make(float(got))) except: return SymbolToken(values.W_Symbol.make(got))
def cons_to_num(charlist): from prolog.interpreter.helper import unwrap_list, unwrap_atom unwrapped = unwrap_list(charlist) numlist = [] saw_dot = False first = True i = 0 for elem in unwrapped: if not isinstance(elem, term.Atom): error.throw_type_error("text", charlist) digit = elem.name() if digit not in digits: if digit == ".": if saw_dot or first or (i == 1 and numlist[0] == "-"): error.throw_syntax_error("Illegal number") else: saw_dot = True elif digit == "-": if not first: error.throw_syntax_error("Illegal number") else: error.throw_syntax_error("Illegal number") numlist.append(digit) i += 1 first = False numstr = "".join(numlist) if numstr.find(".") == -1: # no float try: return term.Number(string_to_int(numstr)) except ParseStringOverflowError: return term.BigInt(rbigint.fromdecimalstr(numstr)) try: return term.Float(float(numstr)) except ValueError: error.throw_syntax_error("Illegal number")
def string_to_int(s): return model.w_integer( rarithmetic.string_to_int(rstring.replace(s, "_", ""), base=0))
try: num = float(e_parts[0]) exp = int(e_parts[1]) p = math.pow(10, exp) except ValueError, e: return values.w_false return values.W_Flonum(num*p) if "." in s or re.match("[+-]?([\d]+)(\.[\d]+)?e[+-][\d]+$", s): if not radix == 10: # FIXME raise SchemeException("string->number : floats with base different than 10 are not supported yet : given number : %s - radix : %s" % (s, str(radix))) return values.W_Flonum(rfloat.string_to_float(s)) else: try: return values.W_Fixnum(rarithmetic.string_to_int(s, base=radix)) except ParseStringOverflowError: return values.W_Bignum(rbigint.rbigint.fromstr(s, base=radix)) except ParseStringError as e: return values.w_false @expose("number->string", [values.W_Number, default(values.W_Fixnum, values.W_Fixnum.make(10))]) def num2str(a, radix): from rpython.rlib.rbigint import BASE8, BASE16 if radix.value == 10: return W_String.fromascii(a.tostring()) else: if isinstance(a, values.W_Fixnum): if radix.value == 16: res = hex(a.value)
def str2num(w_s, radix, convert_mode, decimal_mode): from rpython.rlib import rarithmetic, rfloat, rbigint from rpython.rlib.rstring import ParseStringError, ParseStringOverflowError from rpython.rlib.rsre import rsre_re as re import math s = w_s.as_str_utf8() try: if re.match("[+-]?([\d]+)?.?\d+[tT]\d", s): # it's an extflonum return values.W_ExtFlonum(s) if re.match("[+-]?([\d]+)?.?\d+[sf]\d", s): if "f" in s: f_parts = s.split("f") elif "s" in s: f_parts = s.split("s") else: raise ParseStringError("invalid floating point number : %s" % s) if len(f_parts) > 2: raise ParseStringError("invalid floating point number : %s" % s) try: numb = float(f_parts[0]) prec = int(f_parts[1]) p = math.pow(10, prec) except ValueError: return values.w_false return values.W_Flonum.make(numb * p, True) if re.match("[+-]?([\d]+)?.?\d+e\d", s): e_parts = s.split("e") if len(e_parts) > 2: raise ParseStringError("invalid floating point number : %s" % s) try: num = float(e_parts[0]) exp = int(e_parts[1]) p = math.pow(10, exp) except ValueError: return values.w_false return values.W_Flonum(num * p) if "." in s or re.match("[+-]?([\d]+)(\.[\d]+)?e[+-][\d]+$", s): if not radix.equal(values.W_Fixnum(10)): # FIXME raise SchemeException( "string->number : floats with base different than 10 are not supported yet : given number : %s - radix : %s" % (w_s.tostring(), radix.tostring())) return values.W_Flonum(rfloat.string_to_float(s)) else: try: return values.W_Fixnum( rarithmetic.string_to_int(s, base=radix.toint())) except ParseStringOverflowError: return values.W_Bignum(rbigint.rbigint.fromstr(s)) except ParseStringError as e: return values.w_false
try: num = float(e_parts[0]) exp = int(e_parts[1]) p = math.pow(10, exp) except ValueError, e: return values.w_false return values.W_Flonum(num*p) if "." in s or re.match("[+-]?([\d]+)(\.[\d]+)?e[+-][\d]+$", s): if not radix == 10: # FIXME raise SchemeException("string->number : floats with base different than 10 are not supported yet : given number : %s - radix : %s" % (w_s.tostring(), str(radix))) return values.W_Flonum(rfloat.string_to_float(s)) else: try: return values.W_Fixnum(rarithmetic.string_to_int(s, base=radix)) except ParseStringOverflowError: return values.W_Bignum(rbigint.rbigint.fromstr(s, base=radix)) except ParseStringError as e: return values.w_false @expose("number->string", [values.W_Number, default(values.W_Fixnum, values.W_Fixnum.make(10))]) def num2str(a, radix): from rpython.rlib.rbigint import BASE8, BASE16 if radix.value == 10: return W_String.fromascii(a.tostring()) else: if isinstance(a, values.W_Fixnum): if radix.value == 16: res = hex(a.value)