Esempio n. 1
0
    def test_number(self):
        src = "123"
        col = simplify(src)
        self.assertEqual(col, 123)

        src = "-123"
        col = simplify(src)
        self.assertEqual(col, -123)

        src = "1/2"
        col = simplify(src)
        self.assertEqual(col, fraction(1, 2))

        src = "-1/2"
        col = simplify(src)
        self.assertEqual(col, fraction(-1, 2))

        src = "1.5"
        col = simplify(src)
        self.assertEqual(col, 1.5)

        src = ".5"
        col = simplify(src)
        self.assertEqual(col, 0.5)

        src = "1."
        col = simplify(src)
        self.assertEqual(col, 1.0)

        src = "-1.5"
        col = simplify(src)
        self.assertEqual(col, -1.5)

        src = "-.5"
        col = simplify(src)
        self.assertEqual(col, -0.5)

        src = "-1."
        col = simplify(src)
        self.assertEqual(col, -1.0)

        src = "8+1j"
        col = simplify(src)
        self.assertEqual(col, complex("8+1j"))

        src = "3+i"
        col = simplify(src)
        self.assertEqual(col, complex("3+j"))

        src = "-1.1+2j"
        col = simplify(src)
        self.assertEqual(col, complex("-1.1+2j"))
Esempio n. 2
0
    def test_number(self):
        src = "123"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), 123)

        src = "-123"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), -123)

        src = "1/2"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), fraction(1, 2))

        src = "-1/2"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), fraction(-1, 2))

        src = "1.5"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), 1.5)

        src = ".5"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), 0.5)

        src = "1."
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), 1.0)

        src = "-1.5"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), -1.5)

        src = "-1."
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), -1.0)

        src = "8+1j"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), complex("8+1j"))

        src = "3+i"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), complex("3+j"))

        src = "-1.1+2j"
        stmt, env = compile_expr(src)
        self.assertEqual(stmt(), complex("-1.1+2j"))
Esempio n. 3
0
def main():
    product = 1
    for denominator in range(10+1, 100):
        for numerator in range(10, denominator):
            if is_digit_cancelling_fraction(numerator, denominator):
                product *= fraction(numerator, denominator)
    print product.denominator
Esempio n. 4
0
def is_digit_cancelling_fraction(num, denom):
    str_num, str_denom = str(num), str(denom)
    frac = None
    try:
        if str_num[0] == str_denom[0] != '0':
            frac = fraction(int(str_num[1]), int(str_denom[1]))
        elif str_num[0] == str_denom[1] != '0':
            frac = fraction(int(str_num[1]), int(str_denom[0]))
        elif str_num[1] == str_denom[0] != '0':
            frac = fraction(int(str_num[0]), int(str_denom[1]))
        elif str_num[1] == str_denom[1] != '0':
            frac = fraction(int(str_num[0]), int(str_denom[0]))
    except ZeroDivisionError:
        pass
    if frac == fraction(num, denom):
        return True
    return False
Esempio n. 5
0
def cal_faction(sequence, extend):
    sequence += extend
    length = len(extend)
    nround = length-1
    frac = fraction(sequence[length-1], 1)
    for i in range(nround):
        frac = one_round(sequence[length-2-i], frac)
    return frac
Esempio n. 6
0
def main():
    round = 1000
    count = 0
    num = fraction(3,2)

    for i in range(1,round):
        num = sr_deduction(num)
        if is_longer(num):
            count += 1
    print count
Esempio n. 7
0
def _as_fraction(s):

    # this will raise a type error if s cannot be parsed into a
    # fraction
    s = fraction(s)

    # the fraction type cannot be stored in a const pool, so we have
    # to turn it into a source form of (fraction NUMERATOR
    # DENOMINATOR) instead. We take the integer values from the
    # parsing attempt above, so that we end up with integers in the
    # const pool rather than the literal string, which should make for
    # faster instantiation of the fraction (parsing once at compile
    # rather than parsing over and over every time we evaluate this
    # code)
    return cons(_symbol_fraction, s.numerator, s.denominator, nil)
Esempio n. 8
0
    def test_fraction(self):
        self.setup(Fraction, default=fraction('8/1'), allow_none=False)

        self.commons(FractionVariable)

        self.assertEqual(self.obj.prop1, fraction('8/1'))
        self.assertRaises(NoneError, setattr, self.obj, 'prop1', None)
        self.obj.prop2 = None
        self.assertEqual(self.obj.prop2, None)

        self.obj.prop1 = fraction('1.20')
        self.assertEqual(self.obj.prop1, fraction('6/5'))
        self.obj.prop1 = fraction('1.40')
        self.assertEqual(self.obj.prop1, fraction('7/5'))

        self.assertRaises(TypeError, setattr, self.obj, 'prop1', 1)
Esempio n. 9
0
 def simplify(self, positions):
     return fraction(self.token)
Esempio n. 10
0
def main():
    e = gen_e_constant(100)
    result = fraction(e[len(e)-1], 1)
    for iter in range(len(e)-2, -1, -1):
        result = one_round(e[iter], result)
    print sum([int(k) for k in str(result.numerator)])
Esempio n. 11
0
def generate_continued_fraction():
    result = 1
    while True:
        result = fraction(1 + 1 / (1 + result))
        yield result
Esempio n. 12
0
    print('x1 : {0}'.format(x_1))
    print('x2 : {0}'.format(x_2))
if __name__ == "__main__":

    a = (input('enter a :'))
    b = (input('enter b :'))
    c = (input('enter c :'))
    roots = (float(a),float(b),float(c))

# fraction calculator
from fractions import fraction
def  add(a,b):
    print('result of addition:{0}'.format(a+b))
if __name__ = '__main__':
    a = fraction(input('enter the first fraction'))
    b = fraction(input('enter the second fraction'))
    op = input('operation to perform - add,subtract,division,multiply: ')
    if op == 'add':
        add(a,b)

# even odd vending machine
def even_odd_vend(num):
    if (num%2) == 0:
        print('even')
    else:
        print('odd')
    count = 1
    while count <=9:
        num+=2
        print(num)
Esempio n. 13
0
from time import clock
from fractions import Fraction as fraction
start = clock()
i = fraction(1, 2)
count = 0
answer = 0
for x in range(1000):
    i = fraction(1, 2 + i)
    a, b = str(1 + i).split('/')
    if len(a) > len(b):
        answer += 1
end = clock()
print answer
print end - start