def test_unitaire_8(visible=False):
print("*** fraction: test_unitaire_8 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "a"))
a = a.joindre(mo.monome(ra.rationnel(1), "b"))
# if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(3)))
# if visible: print(b)
c = po.polynome(mo.monome(ra.rationnel(5)))
# if visible: print(c)
f = frac.fraction(a, b)
if visible: print(f)
g = frac.fraction(c, po.polynome_un())
if visible: print(g)
r = f**g
if visible:
print(r)
print(r.joli())
ok = (r.lire_num().valuation() == ra.rationnel(1, 243))
return ok
def test_unitaire_9(visible=False):
print("*** fraction: test_unitaire_9 ***")
a = po.polynome(mo.monome(ra.rationnel(2)))
# if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(1)))
# if visible: print(b)
c = po.polynome(mo.monome(ra.rationnel(3)))
# if visible: print(c)
d = po.polynome(mo.monome(ra.rationnel(4)))
# if visible: print(d)
f = frac.fraction(a, b)
# if visible: print(f)
g = frac.fraction(c, d)
# if visible: print(g)
r = (f + g) + (f - g) + (f * g) + (f / g)
if visible: print(r)
ok = (r == ra.rationnel(49, 6))
return ok
def test_unitaire_4(visible=False):
print("*** fraction: test_unitaire_4 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "x"))
a = a.joindre(mo.monome(ra.rationnel(1)))
# if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(1), "x"))
b = b.joindre(mo.monome(ra.rationnel(3)))
# if visible: print(b)
c = po.polynome(mo.monome(ra.rationnel(-1), "xx"))
# if visible: print(c)
d = po.polynome(mo.monome(ra.rationnel(1)))
# if visible: print(d)
f = frac.fraction(a, b)
if visible: print(f)
g = frac.fraction(c, d)
if visible: print(g)
r = f + g
if visible: print(r)
ok = r.est_valide()
return ok
def __div__( self, obj ): """ Division. Call: matrix / x :Parameters: obj : number The number to divide each item in the matrix by. """ if ( type( obj ) in MATRIX_VALID_TYPES): returnvalue = matrix( ) for row in self._value: newRow = list( ) for item in row: if ( MATRIX_USE_FRACTION ): newItem = _fraction.fraction( item, obj ) else: newItem = item / obj # convert all of the round values to int. if ( type( newItem ) != types.ComplexType ) and ( round( newItem, 4 ) == long( newItem ) ): if not ( MATRIX_USE_FRACTION and ( type( newItem ) == type( _fraction.fraction( 1, 2 ) ) ) ): newItem = int( round( newItem ) ) newRow.append( newItem ) returnvalue.addRow( *newRow ) return returnvalue else: return NotImplemented
def test_unitaire_1(visible=False):
print("*** fraction: test_unitaire_1 ***")
f = frac.fraction(po.polynome_nul(), po.polynome_un(), False)
if visible: print(f)
ok = not f.est_valide()
return ok
def test_unitaire_0(visible=False):
print("*** fraction: test_unitaire_0 ***")
f = frac.fraction()
if visible: print(f)
ok = f.est_valide()
return ok
def test_unitaire_2(visible=False):
print("*** fraction: test_unitaire_2 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "a"))
b = po.polynome(mo.monome(ra.rationnel(1), "b"))
c = po.polynome(mo.monome(ra.rationnel(1), "c"))
d = po.polynome(mo.monome(ra.rationnel(1), "d"))
f = frac.fraction(a, b)
g = frac.fraction(c, d)
r = f + g
if visible:
print(r)
print(r.joli())
ok = r.est_valide()
return ok
def createNum(self):
n = fraction.fraction()
b = random.randint(1, 9)
a = random.randint(1, b * 10 - 1)
tmp = create()
divisor = tmp.getMaxDivisor(a, b)
a = a / divisor
b = b / divisor
n.setNumerator(a)
n.setDenominator(b)
return n
def test_unitaire_3(visible=False):
print("*** fraction: test_unitaire_3 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "a"))
#
# on provoque volontairement une erreur
#
b = po.polynome(mo.monome(ra.rationnel(1), "b", False))
c = po.polynome(mo.monome(ra.rationnel(1), "c"))
d = po.polynome(mo.monome(ra.rationnel(1), "d"))
f = frac.fraction(a, b)
g = frac.fraction(c, d)
r = f + g
if visible: print(r)
ok = not r.est_valide()
return ok
def test_fraction():
assert fraction(90, 120) == 7
assert fraction(2, 4) == 3
assert fraction(100, 1000) == 11
assert fraction(3, 15) == 6
assert fraction(114, 200) == 157
assert fraction(3, 118) == 121
def test_unitaire_0(visible=False):
print("*** expression: test_unitaire_0 ***")
e = ex.expression("{5 * {x / 3} + [x - 1]}")
if visible:
print(e)
print(repr(e))
f = frac.fraction()
if visible: print(f)
ok = e.est_valide() and f.est_valide()
return ok
def test_unitaire_10(visible=False):
print("*** fraction: test_unitaire_10 ***")
a = po.polynome(mo.monome(ra.rationnel(1), "a"))
a = a.joindre(mo.monome(ra.rationnel(1), "b"))
# if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(3)))
# if visible: print(b)
f = frac.fraction(a, b)
if visible: print(f)
r = f**5
if visible: print(r)
ok = (r.lire_denom().valuation().lire_num().lire_valeur() == 243)
return ok
def test_unitaire_12(visible=False):
print("*** fraction: test_unitaire_12 ***")
a = po.polynome(mo.monome(ra.rationnel(3)))
if visible: print(a)
b = po.polynome(mo.monome(ra.rationnel(19)))
if visible: print(b)
b = b.joindre(mo.monome(ra.rationnel(1)))
if visible: print(b)
b = b.joindre(mo.monome(ra.rationnel(-20)))
if visible: print(b)
f = frac.fraction(a, b)
if visible: print(f)
ok = (not f.est_valide())
return ok
def split_frac(frac):
assert fraction.is_proper(frac) and not frac.is_unit()
n, d = frac.get_numerator(), frac.get_denominator()
return fraction.reduce_to_lowest_terms(fraction(n-1, d)), fraction(1, d)
# 1_getNumDen.py ####################################################################################################################### # # 1. Implement the simple methods get_num and get_den that will return the numerator and denominator of a fraction. # ####################################################################################################################### from fraction import fraction x = fraction(3,5) x.get_num() x.get_den()
from fraction import fraction a = fraction(3, 5) b = fraction(4, 5) print(a) print(b) print(a + b)
def split_frac(frac):
assert fraction.is_proper(frac) and not frac.is_unit()
n, d = frac.get_numerator(), frac.get_denominator()
return fraction.reduce_to_lowest_terms(fraction(n - 1, d)), fraction(1, d)
import fraction frac = fraction.fraction(2, 4) frac.print_frac() frac1 = frac.add(fraction.fraction(1, 2)) frac1.print_frac() frac1 = frac.sub(fraction.fraction(1, 2)) frac1.print_frac() frac1 = frac.mul(fraction.fraction(1, 2)) frac1.print_frac() frac1 = frac.div(fraction.fraction(1, 2)) frac1.print_frac()
import fraction
f1 = fraction.fraction(1,2)
f2 = fraction.fraction(1,3)
f3 = fraction.add(f1, f2)
print('{} + {} = {}'.format(fraction.tostring(f1), fraction.tostring(f2), fraction.tostring(f3)))
from fraction import *
f4 = fraction(2,3)
f5 = fraction(1,2)
f6 = multiply(f4, f5)
print('{} + {} = {}'.format(tostring(f1), tostring(f2), tostring(f3)))
print('{} * {} = {}'.format(tostring(f4), tostring(f4), tostring(f6)))
from fraction import fraction
from mathFractions import mathFractions
my_objects = []
'captura de numero de iteraciones'
numeroOperaciones = int(input())
for i in range(numeroOperaciones):
'camptura de cada renglon de par de fracciones'
operation = input()
'se divide cada renglon por espacios'
data = operation.split()
'se arman fracciones'
fr = fraction(int(data[0]), int(data[2]))
fr2 = fraction(int(data[4]), int(data[6]))
'custom Objetc'
teacher = mathFractions(data[3], fr, fr2)
'add current instance'
my_objects.append(teacher)
for i in range(numeroOperaciones):
my_objects[i].result()
from sys import argv import os VERSION = "0.3-pre" MATRIX_VALID_TYPES = ( types.IntType, types.FloatType, types.LongType, types.ComplexType ) MATRIX_VALID_TYPENAMES = ( 'int', 'float', 'long', 'complex' ) MATRIX_VALID_INTS = ( types.IntType, types.LongType ) MATRIX_VALID_COLLECTIONS = ( types.ListType, types.TupleType ) MATRIX_USE_FRACTION = False # add the fraction class if it is available if os.path.exists( os.path.join( os.path.abspath( os.path.dirname( argv[ 0 ] ) ), "fraction.py" ) ): import fraction as _fraction MATRIX_USE_FRACTION = True MATRIX_VALID_TYPES = MATRIX_VALID_TYPES + ( type( _fraction.fraction( 1, 2 ) ), ) MATRIX_VALID_TYPENAMES += ( 'fraction', ) class matrix( object ): """ A class for matrix operations. All indices start at 0. """ def __init__( self, *rows ): """ Accepts either a matrix, a 2-dimensional list of numbers, a list with a matrix width ( int ), or a series of one-dimensional lists of numbers. :Parameters: rows : list
