def calc_with_Fraction(self): def process_operation(operation): r_operand = operands[-1] operands.pop() if operation[0] == 'u': if operation == 'u-': operands.append(-r_operand) if operation == 'u+': operands.append(r_operand) else: l_operand = operands[-1] operands.pop() if operation == '+': operands.append(l_operand + r_operand) if operation == '-': operands.append(l_operand - r_operand) if operation == '*': operands.append(l_operand * r_operand) if operation == '/': operands.append(l_operand / r_operand) operands = list() for element in self.polish_notation_list: if RPN.is_operation(element): process_operation(element) else: if element.isalpha(): operands.append(Fraction({element: 1})) else: operands.append(Fraction({'1': float(element)})) return operands[-1]
def test_ne(self): f1 = Fraction(1, 2) f2 = Fraction(1, 2) f3 = Fraction(1, 3) self.assertTrue(f1 != f3) self.assertFalse(f1 != f2)
def canPlay(self, alavu, diff): # This function tells whether we can play a the Korvai of alavu # mathirai. Also the difference can be anything. i.e. If # self.nadai = [ 3, 3, 4] and the parameter diff = 0, # and alavu = 1, then we know that it is not possible to play the # korvai of 1 Mathirai in this pattern of nadai # if alavu = 3, we can play and we return true. The function checks # for the criteria on which alavu and diff is possible. assert isinstance(alavu, int) if isinstance(diff, int): diff = itertools.repeat(diff) _alavu = alavu total = Fraction(0, 1) for group, d in zip(self.nadais, diff): for nadai in group: # Check whether we can start nadai at this place if not self.can_start(total, nadai): return None total = total + Fraction(_alavu, nadai) _alavu = _alavu + d if (self.can_start(total, 4)): tot = (total * 4) assert (tot.getD() == 1) return SetTot(alavu, tot.getN()) else: return None
def Zero(n): k = 0 total = Fraction(k, 1) for x in range(k, n + 1): i = (Fraction(1, 2)**x) total += i return Fraction(2, 1) - total
def test_mult(self): f1 = Fraction(1, 2) f2 = Fraction(1, 4) f3 = f1 * f2 self.assertEqual(f3.get_num(), 1) self.assertEqual(f3.get_den(), 8)
def test_when_fractions_have_gcd_denominators_non_equal_to_1(self): fraction1 = Fraction(3, 2) fraction2 = Fraction(5, 10) result = fraction1 + fraction2 # 2/1 self.assertEqual(result.numerator, 2) self.assertEqual(result.denominator, 1)
def get_roots(self): roots_list = [] c0 = self.coefficients[len(self.coefficients) - 1] c0_divisors = [] for i in range(1, int(sqrt(abs(c0))) + 2): if c0 % i == 0: c0_divisors.append(i) cn = self.coefficients[0] cn_divisors = [] for i in range(1, int(sqrt(abs(cn))) + 2): if cn % i == 0: cn_divisors.append(i) for numerator in c0_divisors: for denominator in cn_divisors: self.x = Fraction(numerator, denominator) if self.get_value().fraction_numerator == 0: roots_list.append(Fraction(numerator, denominator)) if not roots_list: return 0 return roots_list
def H(n): frac = Fraction(1, 1) k = 2 while k <= n: frac = frac + Fraction(1, k) k += 1 return frac
def test_eq(self): f = Fraction(1,2) g = Fraction(-40,-80) h = Fraction(10000,20001) self.assertTrue(f==g) self.assertTrue(f.__eq__(g))
def Z(n): frac = Fraction(1, 1) k = 1 while k <= n: frac = frac + (Fraction(1, 2)**k) k += 1 return Fraction(2, 1) - frac
def R(n, b): frac = Fraction(1, 1) k = 2 while k <= n: frac = frac + (Fraction(1, k)**b) k += 1 return frac
def T(n): frac = Fraction(1, 1) k = 1 while k <= n: frac = frac + (Fraction(1, 2)**k) k += 1 return frac
def test_init(self): with self.assertRaises(TypeError): Fraction("hi", 3) with self.assertRaises(TypeError): Fraction(2, "Hello") with self.assertRaises(TypeError): Fraction("bear", "wolf")
def test_not_a_int(self): with self.assertRaises(TypeError): Fraction([1,2,3]) with self.assertRaises(TypeError): Fraction({}) with self.assertRaises(TypeError): Fraction("Hello")
def test_init(self): a = Fraction(2, 4) self.assertEqual(1, a.numerator) self.assertEqual(2, a.denominator) b = Fraction(-3, 9) self.assertEqual(-1, b.numerator) self.assertEqual(3, b.denominator) c = Fraction(4, -2) self.assertEqual(-2, c.numerator) self.assertEqual(1, c.denominator) d = Fraction(-800, -200) self.assertEqual(4, d.numerator) self.assertEqual(1, d.denominator) e = Fraction(-4) self.assertEqual(-4, e.numerator) self.assertEqual(1, e.denominator) g = Fraction(5) self.assertEqual(5, g.numerator) self.assertEqual(1, g.denominator) h = Fraction(0, 1) self.assertEqual(0, h.numerator) self.assertEqual(1, h.denominator) i = Fraction(-1, 0) self.assertEqual(-1, i.numerator) self.assertEqual(0, i.denominator) j = Fraction(-3, 0) self.assertEqual(-1, j.numerator) self.assertEqual(0, j.denominator) k = Fraction(0, 0) self.assertEqual(0, k.numerator) self.assertEqual(0, k.denominator)
def test_divide(): """ """ f1 = Fraction(5, 8) f2 = Fraction(1, 1) f3 = f1 / f2 assert f3.__str__() != "5/8" assert f3.as_decimal == 0.625
def test_when_numerator_equals_denominator_then_return_1(self): fraction = Fraction(19, 19) simplified_fraction = fraction.simplify() self.assertEqual(simplified_fraction.numerator, 1) self.assertEqual(simplified_fraction.denominator, 1)
def test_multiply(): """ """ f1 = Fraction(5, 8) f2 = Fraction(2 / 1) f3 = f1 * f2 assert f3.__str__() != "10/8" assert f3.as_decimal == 1.25
def test_add(self): f1 = Fraction(1, 2) f2 = Fraction(3, 4) f3 = f1 + f2 self.assertEqual(f3.get_num(), 5) self.assertEqual(f3.get_den(), 4)
def test_div_two_fractions(self): f1 = Fraction(1, 3) f2 = Fraction(1, 2) f3 = f1 / f2 self.assertEqual(f3.num, 2) self.assertEqual(f3.den, 3)
def T(n): t = Fraction(0, 1) k = 0 while (k <= n): t += Fraction(1, 2)**k k += 1 return t
def test_mul_two_fractions(self): f1 = Fraction(2, 3) f2 = Fraction(1, 2) f3 = f1 * f2 self.assertEqual(f3.num, 1) self.assertEqual(f3.den, 3)
def test_sub(self): num4 = self.num1 - self.num2 num5 = self.num3 - self.num1 num6 = self.num2 - self.num3 self.assertEqual(num4, Fraction(0, 1)) self.assertEqual(num5, Fraction(-1, 6)) self.assertEqual(num6, Fraction(1, 6))
def test_sub_two_fractions(self): f1 = Fraction(1, 2) f2 = Fraction(1, 3) f3 = f1 - f2 self.assertEqual(f3.num, 1) self.assertEqual(f3.den, 6)
def test_div(self): f1 = Fraction(1, 2) f2 = Fraction(1, 4) f3 = f1 / f2 self.assertEqual(f3.get_num(), 2) self.assertEqual(f3.get_den(), 1)
def test_sub(self): f1 = Fraction(1, 2) f2 = Fraction(1, 4) f3 = f1 - f2 self.assertEqual(f3.get_num(), 1) self.assertEqual(f3.get_den(), 4)
def classify(pieceList): for piece in pieceList: if isFractionBar(piece): fracbar = Fraction(piece.width, piece.height, piece.centre) above, below = getAboveBelow(fracbar, pieceList) fracbar.numerator = classify(above) fracbar.denominator = classify(below) symlist = [] for piece in pieceList: if not isFractionBar(piece): symbol = recognise(piece) #maybe not?????????? symlist.append(symbol) tree = Tree() superscriptList = [] subscriptList = [] parentList = [] for sym in symlist: if isSuperscript(sym, symlist): parent = findSuperscriptParent(sym, symlist) superscriptList.append((sym, parent)) elif isSubscript(sym, symlist): parent = findSubscriptParent(sym, symlist) subscriptList.append((sym, parent)) else: t = Tree(data=sym) tree.children.append(t) parentList.append(sym) # for (sym,parent) in superscriptList: # tree.findById(parent.id).children.append(sym) # for (sym,parent) in subscriptList: # tree.findById(parent.id).children.append(sym) for parent in parentList: superscript = [] for (sym, p) in superscriptList: if p == parent: superscript.append(sym) if len(superscript) > 0: t = Tree() t.data = "superscript" #TODO make good lol t.children.append(classify(superscript)) parent.children.append(t) subscript = [] for (sym, p) in subscriptList: if p == parent: subscript.append(sym) if len(subscript) > 0: t = Tree() t.data = "subscript" #TODO make good lol t.children.append(classify(subscript)) parent.children.append(t) tree.children.append(Tree(data=parent)) return tree
def partialRiemannZeta(n, b): total = Fraction(0, 1) for i in range(1, n + 1): fraction = Fraction(1, i)**b total = total + fraction return total
def testArithmetic(self): half = Fraction(1, 2) third = Fraction(1, 3) quarter = Fraction(1, 4) self.assertEqual(half + quarter, Fraction(3, 4)) self.assertEqual(half - quarter, quarter) self.assertEqual(half * half, quarter) self.assertEqual(half / third, Fraction(3, 2))
def test_subtract(): """Test the addition function""" f1 = Fraction(1, 2) f2 = Fraction(2, 1) total = f1 / f2 assert total.__str__() == "1/4" assert total.as_decimal == 0.25
def makeFraction(e): #reference for possibleX/Y. See actual value at beginning of class #possibleX = [0,1,2,3,5,7,9,11,13,17,19,23] #possibleY = [1,2,3,5,7,9,11,13,17,19,23] simpX = -1 simpY = -1 unSimpX = -1 unSimpY = -1 if (e.level == 1): theFactor = random.randint(2,5) unSimpX = 1 * theFactor unSimpY = random.randint(1,5) * theFactor elif (e.level == 2): theFactor = random.randint(3,7) unSimpX = random.randint(1,2) * theFactor unSimpY = e.possibleY[random.randint(2,4)] * theFactor elif (e.level == 3): theFactor = random.randint(7,12) unSimpX = random.randint(1,7) * theFactor unSimpY = random.randint(2,10) * theFactor #create Fraction theFraction = Fraction() theFraction.theFactor = theFactor theFraction.unSimpX = unSimpX theFraction.unSimpY = unSimpY theFraction.gcd = gcd(theFraction.unSimpX, theFraction.unSimpY) theFraction.ansX = theFraction.unSimpX / theFraction.gcd theFraction.ansY = theFraction.unSimpY / theFraction.gcd return theFraction
def valid_m(M, bad_a, bad_b, row = 1): if row == 5: #net spoilage in A / net spoilage in B f = Fraction(bad_a, tot_a) / Fraction(bad_b, tot_b) return f == M #easy early termination test if Fraction(ca[row] + bad_a, tot_a) < M * Fraction(bad_b, tot_b): return False rate_a = Fraction(a[row], b[row]) / M rate_a.reduce() for i in range(rate_a.denom, b[row]+1, rate_a.denom): ct = rate_a * i assert ct.whole() if valid_m(M, bad_a + ct.int(), bad_b + i, row + 1): return True return False
def evaluate(fraction, inputString): ''' evaluate the value of a string ''' storeValue = fraction # the value held by the calculator storeOp = None inputItem = inputString.split() for i in range(len(inputItem)): currentItem = inputItem[i] if attribute(currentItem) is 'clear': # reset everything storeValue = Fraction(0, 1) storeOp = None elif attribute(currentItem) is 'EOF': raise EOFError elif attribute(currentItem) is 'error': raise ValueError elif attribute(currentItem) is 'value': if storeOp == None: # no operation, renew the value storeValue = setFraction(currentItem) else: # has operation, calculate it and forget the operation storeValue = setOperation(storeValue, storeOp, setFraction(currentItem)) storeOp = None elif attribute(currentItem) is 'operator': if storeOp == None: # store the operation storeOp = currentItem else: # double operation raise ValueError elif attribute(currentItem) is 'abs': storeValue = storeValue.absValue() elif attribute(currentItem) is 'negate': storeValue = storeValue.negate() return storeValue
def test_get_reduced_6_9(self): original_fraction = Fraction(6, 9) reduced_fraction = original_fraction.get_reduced() correct_reduced_fraction = Fraction(2, 3) self.assertEqual(correct_reduced_fraction, reduced_fraction) return
def xml_to_abc(filename): global default_len if os.path.splitext(filename)[1].lower() == '.mxl': root = ElementTree().parse(mxl_to_xml(filename)) else: root = ElementTree().parse(filename) debug = False results_for_different_L_fields = [] for L in [Fraction(1, 8), Fraction(1, 16)]: default_len = L tune_fields = [] parts = [] if root.findtext('work/work-title', ''): tune_fields.append(Field('T', root.findtext('work/work-title', '').strip())) if root.findtext('movement-title', ''): tune_fields.append(Field('T', root.findtext('movement-title', '').strip())) for credit in root.findall('credit'): credits = ''.join(e.text or '' for e in credit.findall('credit-words')) # ran into issues with Unicode strings, so except TypeError to avoid processing these strings try: credits = credits.translate(None, '\r\n') if credits.strip(): tune_fields.append(Field('T', credits)) except TypeError: pass for creator in root.findall('identification/creator'): if creator.get('type') == 'composer': for line in creator.text.split('\n'): tune_fields.append(Field('S', line.strip())) elif creator.get('type') == 'lyricist': text = creator.text for line in text.split('\n'): tune_fields.append(Field('Z', line.strip())) num_parts = len(list(root.findall('part'))) for part_no, part in enumerate(root.findall('part')): accidentals = defaultdict(lambda: 0) measure_accidentals = accidentals cur_divisions = 768 bar_number = 0 bar_offset = 0 lyric_numbers = sorted(set(lyric.get('number', '1') for lyric in part.findall('*/note/lyric'))) lyrics = dict((lyric_number, []) for lyric_number in lyric_numbers) voice_names = sorted([voice.text for voice in part.findall('measure/note/voice')]) if voice_names: first_voice = voice_names[0] else: first_voice = None voices = defaultdict(list) num_staves = int(root.findtext('part/measure/attributes/staves', '1')) for measure in part.findall('measure'): bar_number += 1 bar_offset = 0 last_measure_accidentals = measure_accidentals measure_accidentals = accidentals.copy() notes_with_accidentals_in_this_measure = set() for measure_element in measure.getchildren(): # fields if measure_element.tag == 'attributes': attributes = measure_element for element in attributes.getiterator(): if element.tag == 'key': # determine modal scale mode, base_note_distance = key_mode_map.get(element.findtext('mode'), '') # insert new key in all voices fifths = int(element.findtext('fifths')) key_name = get_key_name(fifths, base_note_distance) + mode field = Field('K', key_name) if voices: for voice in voices.values(): voice.append(field) elif part_no == 0: tune_fields.append(field) # update accidentals accidentals = get_accidentals(fifths) measure_accidentals = accidentals.copy() elif element.tag == 'time': metre = '%s/%s' % (element.findtext('beats'), element.findtext('beat-type')) field = Field('M', metre) if voices: for voice in voices.values(): voice.append(field) elif part_no == 0: tune_fields.append(field) elif element.tag == 'divisions': cur_divisions = int(element.text) # notes elif measure_element.tag == 'note': note = measure_element voice = note.findtext('voice') # name if note.get('print-object') == 'no': note_name = 'x' elif note.find('rest') is not None: note_name = 'z' else: if note.findtext('pitch/step') != None and note.findtext('pitch/octave') != None: note_name = note.findtext('pitch/step') + note.findtext('pitch/octave') else: note_name = "?" # duration and whether it's a grace note is_grace_note = note.find('grace') is not None grace_slash = False if is_grace_note: duration = name2duration[note.findtext('type')] grace_slash = note.find('grace').get('slash') == 'yes' else: duration = Fraction(int(note.findtext('duration')), cur_divisions) / 4 duration.reduce() # find any time-modifications (due to tuplets) and rescale displayed duration accordingly actual_notes = note.findtext('time-modification/actual-notes') normal_notes = note.findtext('time-modification/normal-notes') if actual_notes and normal_notes: # if time modification time_modification = Fraction(int(actual_notes), int(normal_notes)) else: time_modification = Fraction(1, 1) displayed_duration = duration * time_modification # create Note object n = Note(note_name, duration, displayed_duration, bar_number, bar_offset, is_grace_note, grace_slash) # tuplet tuplet = note.find('notations/tuplet') if tuplet is not None: if tuplet.get('type') == 'start': actual_notes, normal_notes = int(actual_notes), int(normal_notes) if actual_notes == 3 and normal_notes == 2: n.tuplet_begin = '(3' elif actual_notes == 5: n.tuplet_begin = '(5' else: raise Exception('unrecognized tuplet: %d/%d' % (actual_notes, normal_notes)) #n.tuplet_begin = '(%d' % int(Fraction(actual_notes, normal_notes) * 2) # TODO: make more generally applicable elif tuplet.get('type') == 'stop': n.tuplet_end = True # accidental if not note_name in 'zx': # unless rest or invisible rest alter = int(note.findtext('pitch/alter', '0')) try: if alter != measure_accidentals[note_name] or note.find('accidental') is not None: n.accidental = {-2: '__', -1: '_', 0: '=', 1: '^', 2: '^^'}[alter] measure_accidentals[note_name] = alter notes_with_accidentals_in_this_measure.add(note_name) except KeyError: print "Error processing accidental. Skipping..." # tie tie = note.find('tie') if tie is not None and tie.get('type') == 'start': n.tie = '-' # slurs for slur in note.findall('notations/slur'): if slur.get('type') == 'start': n.slur_begin = n.slur_begin + '(' if slur.get('type') == 'stop': n.slur_end = n.slur_end + ')' # ornaments for key, value in note_ornamentation_map.items(): if note.find(key) is not None: n.ornaments = n.ornaments + value # fingering fingering = note.find('notations/technical/fingering') if fingering is not None: n.ornaments = '!%s!' % fingering.text + n.ornaments # spacing due to beam ends or long notes if not is_grace_note: beams = [beam for beam in note.findall('beam') if beam.text in ['begin', 'continue', 'end']] all_beams_end_here = beams and not [b for b in beams if b.text != 'end'] if all_beams_end_here or duration >= Fraction(1, 4) or (duration < Fraction(1, 4) and len(beams)==0): n.trailing_space = ' ' ##if duration < Fraction(1, 4) and len(beams)==0: ## n.trailing_space = ' !%s!' % len(beams) # chord if note.find('chord') is not None: n.trailing_space = '' # beam detection only works for first chord note, so erase any incorrectly generated space last = voices[voice].pop() if not isinstance(last, Chord): last = Chord([last]) last.add(n) n = last # lyrics elif voice == first_voice and not is_grace_note and note_name not in 'zx': for lyric_number in lyric_numbers: lyrics_text = '*' # skip this note unless we find a lyric element that matches the current lyrics number for lyric in note.findall('lyric'): if lyric_number == lyric.get('number', '1'): # match found, so get the lyrics text (replace spaces and elision elements by '~') lyrics_text = '' for lyr_element in lyric: if lyr_element.tag == 'elision': lyrics_text = lyrics_text + '~' elif lyr_element.tag == 'text': lyrics_text = lyrics_text + (lyr_element.text or '').replace('-', r'\-').replace(' ', '~') # escape '-' characters # add - and _ characters if lyric.findtext('syllabic') in ['begin', 'middle']: lyrics_text = lyrics_text + '-' if lyric.find('extend') is not None: lyrics_text = lyrics_text.replace('*', '') + '_' # if the current element is silence and the last element was '_', then discard the silence since the '_' covers this if lyrics_text == '*' and lyrics[lyric_number] and lyrics[lyric_number][-1].endswith('_'): lyrics[lyric_number].append('') # adding '' ensures that the if condition is not true next time around else: lyrics[lyric_number].append(lyrics_text) # add note/chord to its voice voices[voice].append(n) if not is_grace_note: bar_offset += n.duration # backup elif measure_element.tag == 'backup': duration = Fraction(int(measure_element.findtext('duration')), cur_divisions) / 4 duration.reduce() bar_offset -= duration elif measure_element.tag == 'barline': for voice_name, voice in voices.items(): barline = measure_element location = barline.get('location') bar_style = barline.findtext('bar-style') if bar_style == 'light-light': s = '|-|' elif bar_style == 'light-heavy': s = '|]' else: s = '|' repeat = barline.find('repeat') if repeat is not None: if repeat.get('direction') == 'forward': s = '|:' else: s = ':|' # handle segno, coda, fermata ornament = None if barline.find('segno'): ornament = 'S' elif barline.find('coda'): ornament = 'O' elif barline.find('fermata'): ornament = 'H' if ornament: for voice in voices.values(): voice.append(ornament) ending = barline.find('ending') if ending is not None: if ending.get('type') == 'start': if part_no == 0 and voice_name == first_voice: # only read endings for first part since this is the way ABC handles it text = ending.text or ending.get('number') if text is None: text = '' elif text.strip() in '1 2 3 4 5 6 1. 2. 3. 4. 5. 6.': text = text.replace('.', '') # delete any trailing dot after the ending number else: text = '"%s"' % text s = s + '[' + text else: s = s + '|-|' voice.append(s) debug_print(s) elif measure_element.tag == 'direction': direction = measure_element s = None if direction.find('direction-type/coda') is not None: s = 'O' elif direction.find('direction-type/segno') is not None: s = 'S' elif direction.find('direction-type/words') is not None: words = direction.find('direction-type/words') offset = words.get('default-y') text = direction.findtext('direction-type/words', '').strip() ##if text.lower() == 'fine': ## s = '!fine!' ##elif text.upper() == 'D.C.': ## s = '!D.C.!' ##elif text.upper() == 'D.S.': ## s = '!D.S.!' if text == '$': # Sibelius sometimes seems to use this for segno s = 'S' elif offset and int(offset) < 0: s = '"_%s"' % text else: s = '"^%s"' % text s = s.replace('\n', ' ') if s: voices[first_voice].append(s) #for voice in voices.values(): # voice.append(s) elif measure_element.tag == 'harmony': voices['1'].append(xml_harmony_to_abc(measure_element)) elif measure_element.tag == 'print': print_element = measure_element if print_element is not None and print_element.get('new-system') == 'yes': for voice in voices.values(): voice[-1] = voice[-1] + '\n' for lyrics_number in lyrics: lyrics[lyrics_number].append('\n') for voice in voices.values(): voice.append('|') debug_print('|') for voice in voices: fix_chords(voices[voice]) fix_tuplets(voices[voice]) voices[voice] = introduce_grace_starts_and_ends(voices[voice]) voices[voice] = fix_barlines(voices[voice]) fix_slurs_before_repeat_ends(voices[voice]) introduce_broken_rythms(voices[voice]) pass for voice_name, voice in sorted(voices.items()): if not voice_name and not voice: continue s = ''.join(map(unicode, voice)) s = s.replace('|-|', '||').replace(':|||:', '::').replace('||:', '|:').replace(':||', ':|').replace('||[', '|[').replace('||[', '|[').replace('|-|', '||').replace('|||', '||').replace('|||', '||').replace(']|', ']').replace('|]|', '|]').strip() if s.endswith('||'): s = s[0:-2] + '|]' if num_parts > 1: if voice_name: voice_name = part.get('id') + '_' + str(voice_name) else: voice_name = part.get('id') # if this is the first voice, then pair up each line of note output with the lyrics lines (if there are any) if voice_name == first_voice: result = [] notes_lines = s.split('\n') lines_for_each_lyrics = [' '.join(lyrics[lyrics_number]).split('\n') for (lyrics_number, lyrics_parts) in sorted(lyrics.items())] for line_no in range(len((notes_lines))): result.append(notes_lines[line_no]) for lines in lines_for_each_lyrics: if re.search(r'[^-*_ ]', lines[line_no]): # if line is not empty result.append('w: %s' % lines[line_no]) s = '\n'.join(result) parts.append(('V:%s' % str(voice_name), s)) file_numbers = [int(x) for x in re.findall(r'(\d+)', filename)] if file_numbers and 0 <= file_numbers[-1] <= 100000: tune_fields.insert(0, Field('X', str(file_numbers[-1]))) else: tune_fields.insert(0, Field('X', '1')) tune_fields.append(Field('L', str(default_len))) ##tune_fields.append(Field('R', '')) ##tune_fields.append(Field('O', '')) output = StringIO.StringIO(u'') for f in tune_fields: if f.field_name != 'K': output.write(unicode(f).replace('[', '').replace(']', '') + '\n') for f in tune_fields: if f.field_name == 'K': output.write(unicode(f).replace('[', '').replace(']', '') + '\n') if not [f for f in tune_fields if f.field_name == 'K']: output.write('K:C\n') for pname, p in parts: if len(parts) > 1 and pname: output.write(pname + '\n') lines = p.split('\n') for line in lines: output.write(line.strip() + '\n') results_for_different_L_fields.append(output.getvalue()) # use the L-field that gives the shortest output (but add some extra penalty for using many '/' characters) len_and_texts = [(len(s) + s.count('/')*0.15, s) for s in results_for_different_L_fields] len_and_texts.sort() return len_and_texts[0][1]
# also numerator must be < denominator # also if numerator is divisible by 10, denominator can't be # keys are numerators, values are list of possible denominators denoms_by_num = generate_denoms_for_nums(nums) # where we'll store the Fractions that cancel to same value fractions_to_keep = [] # get the cases where they are the same as their form when a common # digit removed for num, denom_list in denoms_by_num.items(): for denom in denom_list: fraction = Fraction(num, denom) # generate all possible fractions by removing those common digits cancelled_fractions = fraction.generate_cancelled_fractions() # determine if any of those possible fractions equals the original fraction_reduced = fraction.get_reduced() for cf in cancelled_fractions: cf_reduced = cf.get_reduced() if fraction_reduced == cf_reduced: fractions_to_keep.append(fraction) assert len(fractions_to_keep) == NUM_FRACTIONS_TO_FIND
def test_get_reduced_2_4(self): original_fraction = Fraction(2, 4) reduced_fraction = original_fraction.get_reduced() correct_reduced_fraction = Fraction(1, 2) self.assertEqual(correct_reduced_fraction, reduced_fraction) return
def test_get_reduced_2_3(self): original_fraction = Fraction(2, 3) reduced_fraction = original_fraction.get_reduced() self.assertTrue(original_fraction == reduced_fraction) return
def test_get_reduced_1_1(self): original_fraction = Fraction(1, 1) reduced_fraction = original_fraction.get_reduced() self.assertTrue(original_fraction == reduced_fraction) return
def test_generate_cancelled_fractions_1(self): f = Fraction(13, 39) answer = [Fraction(1, 9)] self.assertEqual(answer, f.generate_cancelled_fractions()) return
def test_get_gcd_1_2(self): f = Fraction(1, 2) self.assertEqual(1, f.get_gcd()) return
def test_get_gcd_2_3(self): f = Fraction(2, 3) self.assertEqual(1, f.get_gcd()) return
def test_get_gcd_2_4(self): f = Fraction(2, 4) self.assertEqual(2, f.get_gcd()) return
def test_get_common_digits_2(self): f = Fraction(12, 21) answer = set('12') self.assertEqual(answer, f.get_common_digits()) return
def test_get_gcd_8_12(self): f = Fraction(8, 12) self.assertEqual(4, f.get_gcd()) return
def test_cant_simplify(self): a = Fraction(7, 23) a.simplify() self.assertEqual(a.nominator, 7) self.assertEqual(a.denominator, 23)
def test_generate_cancelled_fractions_2(self): f = Fraction(23, 32) answer = [Fraction(2, 2), Fraction(3, 3)] self.assertEqual(answer, f.generate_cancelled_fractions()) return