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