From f2904603606db1b09a4033f2f5d35da2c1b0469d Mon Sep 17 00:00:00 2001
From: ajaycode <writeajay@gmail.com>
Date: Tue, 20 Oct 2015 14:18:56 +0530
Subject: [PATCH 01/39] Updated logging of answer.

---
 class05/math/factors.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/class05/math/factors.py b/class05/math/factors.py
index c32e0d7..0fda898 100644
--- a/class05/math/factors.py
+++ b/class05/math/factors.py
@@ -378,10 +378,11 @@ def main():
         print ("{i}) ".format(i=i+1), end="")
         f = functions[i]
         f()
+        logging.info ('Answer  : %s' % answers[i])
 
     print ()
     print("Answer Key # {}".format(str(unique_id)))
-    for i in range(0, len(answers)):
+    for i in range(0, len (functions)): #len(answers)):
         print(i + 1, answers[i])
         #primes = [ _is_prime(x) for x in range (100)]
         #print (primes)

From a953b40671b61d6ab073f03373bec4ab83203299 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Tue, 26 Jan 2016 17:57:22 +0530
Subject: [PATCH 02/39] fraction sum and difference working

---
 class05/__init__.py                 |  0
 class05/math/README.md              |  3 ++-
 class05/math/__init__.py            |  0
 class05/math/fraction.py            | 33 ++++++++++++++++++++++++-----
 class05/math/tests/test_fraction.py | 18 ++++++++++++++++
 5 files changed, 48 insertions(+), 6 deletions(-)
 create mode 100644 class05/__init__.py
 create mode 100644 class05/math/__init__.py
 create mode 100644 class05/math/tests/test_fraction.py

diff --git a/class05/__init__.py b/class05/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/class05/math/README.md b/class05/math/README.md
index 8e0158c..83fa0f1 100644
--- a/class05/math/README.md
+++ b/class05/math/README.md
@@ -5,4 +5,5 @@ geared towards class 5 students in the CBSE system.
 
 The practice tests pertain to:
 * Practice Mathematics learned in class IV
-* Factors, Multiples, LCM, HCF 
\ No newline at end of file
+* Factors, Multiples, LCM, HCF
+* Work on fractions in in progress
\ No newline at end of file
diff --git a/class05/math/__init__.py b/class05/math/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/class05/math/fraction.py b/class05/math/fraction.py
index 66f8ce4..aba892d 100644
--- a/class05/math/fraction.py
+++ b/class05/math/fraction.py
@@ -24,13 +24,36 @@ def fractions_sum():
     fraction2_numerator = random.randint(1, 9)
     fraction2_denominator = random.randint(1, 9) + fraction2_numerator
     answer = Fraction(fraction1_numerator, fraction1_denominator) + Fraction(fraction2_numerator, fraction2_denominator)
-    #answers.append (answer)
-    question = "The sum of {} and {}/{} is __________".format(r'$\frac {2}{9}$',
-                                                                 fraction2_numerator, fraction2_denominator)
+
+    #print ('{}/{}'.format (fraction2_numerator, fraction2_denominator))
+    question = "The sum of {} and {} is __________".format(printable_fraction(fraction1_numerator, fraction1_denominator),
+                                                                 printable_fraction(fraction2_numerator, fraction2_denominator))
+    answer = printable_fraction (answer.numerator, answer.denominator)
+    answers.append (answer)
+    return (question, answer)
+
+def fractions_difference ():
+    subtrahend_numerator = random.randint(1, 9)
+    subtrahend_denominator = random.randint(1, 11) + subtrahend_numerator
+    difference_numerator = random.randint(1, 5)
+    difference_denominator = random.randint(1, 9) + difference_numerator
+    minuend = Fraction (subtrahend_numerator, subtrahend_denominator) + Fraction (difference_numerator, difference_denominator)
+    question = "The difference between {} and {} is __________".format(printable_fraction(minuend.numerator, minuend.denominator),
+                                                                 printable_fraction(subtrahend_numerator, subtrahend_denominator))
+    answer = minuend - Fraction(subtrahend_numerator, subtrahend_denominator)
+    answer = printable_fraction (answer.numerator, answer.denominator)
+    answers.append (answer)
     return (question, answer)
 
 
-functions = [fractions_sum]
+'''input: numerator and denominator
+   output: a string, that appears as a fraction in LaTeX format
+   '''
+def printable_fraction (numerator: int, denominator: int):
+    printable = "$\\frac {" + str(numerator) +"}{" +  str(denominator) + "}$"
+    return printable
+
+functions = [fractions_sum, fractions_difference]
 
 
 def main():
@@ -47,7 +70,7 @@ def main():
 
     html_text = r'<ul>'
     for i in range(0, len(questions)):
-        html = "<li> {} is {} </li>".format (question, r'$\frac {2}{9}$')
+        html = "<li> {} </li>".format (questions[i])
         html_text += html
 
         #print(answer)
diff --git a/class05/math/tests/test_fraction.py b/class05/math/tests/test_fraction.py
new file mode 100644
index 0000000..cfcecfb
--- /dev/null
+++ b/class05/math/tests/test_fraction.py
@@ -0,0 +1,18 @@
+from unittest import TestCase
+
+__author__ = 'Ajay'
+import sys
+
+sys.path.append('..\\')
+from fraction import *
+
+
+class TestFraction(TestCase):
+    def test_fraction(self):
+        self.assertEqual(r'$\frac {2}{3}$', printable_fraction(2, 3))
+        self.assertEqual(r'$\frac {12}{3}$', printable_fraction(12, 3))
+        self.assertEqual(r'$\frac {2}{403}$', printable_fraction(2, 403))
+
+    def test_fractions_sum (self):
+        #self.assertEqual()
+        pass

From f4082cb79253c87c0743eb34c61347185ae4fb04 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Tue, 26 Jan 2016 23:09:32 +0530
Subject: [PATCH 03/39] fraction sum,difference, mixed fraction addition, unit
 tests

---
 class05/math/fraction.py            | 132 +++++++++++++++++++++-------
 class05/math/tests/test_fraction.py |  26 +++++-
 2 files changed, 123 insertions(+), 35 deletions(-)

diff --git a/class05/math/fraction.py b/class05/math/fraction.py
index aba892d..c502da4 100644
--- a/class05/math/fraction.py
+++ b/class05/math/fraction.py
@@ -1,22 +1,57 @@
 __author__ = 'Ajay'
 
 '''Generates questions on fractions'''
-'''Usage: python <this_file.py> '''
+'''Usage: python <this_file.py> > test.html''' #test.html can be opened in  a browser to view the fraction problems
 ''' Output: Generates a html file, with the questions and answers'''
+# references : https://docs.python.org/2/library/fractions.html
+#              http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference
 
 import random
 import logging
 # from fractions import Fraction
 from fractions import Fraction
 
+
 questions = []
 answers = []
 
+style = r'<style>body{font-size:16;font-family:Verdana;}</style>'
 html_pre_context = r'<html> <head> <title> Quiz on fractions </title>' + r'<script type="text/x-mathjax-config">MathJax.Hub.Config({' + \
   r'tex2jax: {' + r"inlineMath: [ ['$','$'], ['\\(','\\)'] ]" + \
-  r'}' + r'})'+ r'</script><script type="text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" ></script> </head > <body> '
+  r'}' + r'})'+ r'</script><script type="text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" ></script> ' +\
+  style + r'</head > <body> '
 html_post_content = r'</body></html>'
 
+'''Generates a fraction ranging from 1...9/1..9'''
+def __generate_fraction ():
+    return (Fraction(random.randint(1,9),random.randint(1,9) ))
+
+def __generate_mixed_fraction ():
+    frac = __generate_fraction()
+    while frac.denominator == 1:
+        frac = __generate_fraction()
+    return frac + random.randint (1,9)
+
+'''input: numerator and denominator
+   output: a string, that appears as a fraction in LaTeX format
+   '''
+def printable_fraction (numerator: int, denominator: int):
+    printable = "$\\frac {" + str(numerator) +"}{" +  str(denominator) + "}$"
+    return printable
+
+'''Takes a Fraction data structure'''
+def printable_fraction_from_fraction (fraction: Fraction):
+    return printable_fraction(fraction.numerator, fraction.denominator)
+
+def printable_mixed_fraction (fraction: Fraction):
+    if fraction.numerator <= fraction.denominator:
+        return printable_fraction_from_fraction(fraction)
+    else:
+        whole_number = fraction.numerator // fraction.denominator
+        fraction = fraction - whole_number
+        printable = "${}".format(whole_number) +"\\frac {" + str(fraction.numerator) +"}{" +  str(fraction.denominator) + "}$"
+        return printable
+
 
 def fractions_sum():
     fraction1_numerator = random.randint(1, 9)
@@ -24,42 +59,82 @@ def fractions_sum():
     fraction2_numerator = random.randint(1, 9)
     fraction2_denominator = random.randint(1, 9) + fraction2_numerator
     answer = Fraction(fraction1_numerator, fraction1_denominator) + Fraction(fraction2_numerator, fraction2_denominator)
-
-    #print ('{}/{}'.format (fraction2_numerator, fraction2_denominator))
     question = "The sum of {} and {} is __________".format(printable_fraction(fraction1_numerator, fraction1_denominator),
                                                                  printable_fraction(fraction2_numerator, fraction2_denominator))
     answer = printable_fraction (answer.numerator, answer.denominator)
-    answers.append (answer)
     return (question, answer)
 
 def fractions_difference ():
-    subtrahend_numerator = random.randint(1, 9)
-    subtrahend_denominator = random.randint(1, 11) + subtrahend_numerator
-    difference_numerator = random.randint(1, 5)
-    difference_denominator = random.randint(1, 9) + difference_numerator
-    minuend = Fraction (subtrahend_numerator, subtrahend_denominator) + Fraction (difference_numerator, difference_denominator)
-    question = "The difference between {} and {} is __________".format(printable_fraction(minuend.numerator, minuend.denominator),
-                                                                 printable_fraction(subtrahend_numerator, subtrahend_denominator))
-    answer = minuend - Fraction(subtrahend_numerator, subtrahend_denominator)
+    subtrahend= Fraction (random.randint(1, 9), random.randint(1,9))
+    difference = Fraction (random.randint(1, 9),random.randint(1, 5))
+    minuend = subtrahend + difference
+    question = "The difference between {} and {} is __________".format(printable_fraction_from_fraction(minuend),
+                                                                 printable_fraction_from_fraction(subtrahend))
+    answer = minuend - subtrahend
     answer = printable_fraction (answer.numerator, answer.denominator)
-    answers.append (answer)
     return (question, answer)
 
 
-'''input: numerator and denominator
-   output: a string, that appears as a fraction in LaTeX format
-   '''
-def printable_fraction (numerator: int, denominator: int):
-    printable = "$\\frac {" + str(numerator) +"}{" +  str(denominator) + "}$"
-    return printable
 
-functions = [fractions_sum, fractions_difference]
+def sort_unlike_fractions (fractions_list = [], ascending=True):
+    list = []
+    if  not fractions_list:
+        i = 0
+        while len (list) < 5:
+            frac = __generate_fraction()
+            if frac not in list:
+                list.append(frac)
+                i+=1
+    else:
+        list = fractions_list
+    logging.info ("Fractions to be sorted: {}".format(list))
+    sorted_fraction_list = sorted(list)
+    if ascending is not True:
+        sorted_fraction_list.reverse()
+    question_sub_text = ""
+    for i in range (0, len(list)):
+        question_sub_text += printable_fraction_from_fraction(list[i])
+        if i != len (list)-1:
+            question_sub_text += ','
+    if ascending is True:
+        order = "ascending"
+    else:
+        order = "descending"
+    question = 'Arrange the fractions {} in {} order'.format (question_sub_text, order )
+    logging.info (question)
+    answer = ""
+    for i in range (0, len(list)):
+        answer += printable_fraction_from_fraction(sorted_fraction_list[i])
+        if i != len (list)-1:
+            answer += ','
+    logging.info (answer)
+    logging.info (sorted_fraction_list)
+
+    return (question, answer)
+
+def sort_unlike_fractions_descending (fractions_list = [], ascending=False):
+    return sort_unlike_fractions(fractions_list, ascending)
+
+def mixed_fractions_sum (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_mixed_fraction()
+        number2 = __generate_mixed_fraction()
+    answer = number1 + number2
+    #logging.info (number1, number2, answer)
+    question = "The sum of {} and {} is _____.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+def mixed_fractions_difference ():
+    pass
+
+functions = [fractions_sum, fractions_difference, sort_unlike_fractions, sort_unlike_fractions_descending, mixed_fractions_sum]
 
 
 def main():
     logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y%m%d %I:%M:%S %p',
                         filename='class.log', level=logging.INFO)
     #random.seed (os.urandom(5))
+
     for i in range(0, len(functions)):
         logging.info('Function : %s' % functions[i])
         f = functions[i]
@@ -68,22 +143,15 @@ def main():
         answers.append(answer)
 
 
-    html_text = r'<ul>'
+    html_text = r'<ol>'
     for i in range(0, len(questions)):
-        html = "<li> {} </li>".format (questions[i])
+        html = "<li> {} : {}</li>".format (questions[i], answers[i])
         html_text += html
 
         #print(answer)
-    #html_text += r'$\frac {2}{9}$'
-    html_text += r'</ul>'
+    #html_text += r'$2\frac {2}{9}$'
+    html_text += r'</ol>'
     print ("{} {} {}".format(html_pre_context, html_text, html_post_content))
-        #primes = [ _is_prime(x) for x in range (100)]
-        #print (primes)
-        #for i in squat ():
-        #    print (i)
-
-        #for i in range (100, 500):
-        #   print (i, all_factors(i))
 
 
 if __name__ == "__main__":
diff --git a/class05/math/tests/test_fraction.py b/class05/math/tests/test_fraction.py
index cfcecfb..b738b9c 100644
--- a/class05/math/tests/test_fraction.py
+++ b/class05/math/tests/test_fraction.py
@@ -1,5 +1,7 @@
-from unittest import TestCase
+# ..\tests>python test_fraction.py
 
+import unittest
+from unittest import TestCase
 __author__ = 'Ajay'
 import sys
 
@@ -8,11 +10,29 @@
 
 
 class TestFraction(TestCase):
-    def test_fraction(self):
+    def test_printable_fraction(self):
         self.assertEqual(r'$\frac {2}{3}$', printable_fraction(2, 3))
         self.assertEqual(r'$\frac {12}{3}$', printable_fraction(12, 3))
         self.assertEqual(r'$\frac {2}{403}$', printable_fraction(2, 403))
 
+    def test_printable_fraction_from_fraction (self):
+        self.assertEqual(r'$\frac {2}{403}$', printable_fraction_from_fraction(Fraction(2, 403)))
+
+    def test_sort_unlike_fractions(self):
+        question, answer = sort_unlike_fractions ([Fraction(1,2), Fraction (3,4), Fraction (2,3), Fraction (15,16)])
+        self.assertEqual(r'$\frac {1}{2}$,$\frac {2}{3}$,$\frac {3}{4}$,$\frac {15}{16}$', answer)
+        question, answer = sort_unlike_fractions ([Fraction(1,2), Fraction (3,4), Fraction (2,3), Fraction (15,16)], ascending=False)
+        self.assertEqual(r'$\frac {15}{16}$,$\frac {3}{4}$,$\frac {2}{3}$,$\frac {1}{2}$', answer)
+
     def test_fractions_sum (self):
-        #self.assertEqual()
+        self.assertEqual(3, 2+1)
         pass
+
+    def test_mixed_fraction_sum (self):
+        number1 = Fraction(25,3)
+        number2 = Fraction (33,4)
+        question, answer = mixed_fractions_sum(number1, number2)
+        self.assertEqual(r'$16\frac {7}{12}$', answer )
+
+if __name__ == '__main__':
+    unittest.main()

From c7c8f583070cd9252dd6d406ee8c86994dee4362 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Tue, 26 Jan 2016 23:21:36 +0530
Subject: [PATCH 04/39] TO DO

---
 class05/math/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/class05/math/README.md b/class05/math/README.md
index 83fa0f1..50bcf83 100644
--- a/class05/math/README.md
+++ b/class05/math/README.md
@@ -6,4 +6,4 @@ geared towards class 5 students in the CBSE system.
 The practice tests pertain to:
 * Practice Mathematics learned in class IV
 * Factors, Multiples, LCM, HCF
-* Work on fractions in in progress
\ No newline at end of file
+* Work on fractions in in progress. TO DO: Multiplication, division, word problems, ...
\ No newline at end of file

From cc2721d3af324e01aa870bb3a971537a9aef6d7b Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Wed, 27 Jan 2016 10:55:18 +0530
Subject: [PATCH 05/39] mixed fractions add/sub/mul/div

---
 class05/math/fraction.py            | 79 +++++++++++++++++++++++++----
 class05/math/tests/test_fraction.py | 59 +++++++++++++++++++++
 2 files changed, 127 insertions(+), 11 deletions(-)

diff --git a/class05/math/fraction.py b/class05/math/fraction.py
index c502da4..af8e6a1 100644
--- a/class05/math/fraction.py
+++ b/class05/math/fraction.py
@@ -24,7 +24,7 @@
 
 '''Generates a fraction ranging from 1...9/1..9'''
 def __generate_fraction ():
-    return (Fraction(random.randint(1,9),random.randint(1,9) ))
+    return (Fraction(random.randint(1,9),random.randint(2,9) ))
 
 def __generate_mixed_fraction ():
     frac = __generate_fraction()
@@ -80,7 +80,7 @@ def sort_unlike_fractions (fractions_list = [], ascending=True):
     list = []
     if  not fractions_list:
         i = 0
-        while len (list) < 5:
+        while len (list) < 4:
             frac = __generate_fraction()
             if frac not in list:
                 list.append(frac)
@@ -121,13 +121,65 @@ def mixed_fractions_sum (number1=Fraction(), number2=Fraction()):
         number2 = __generate_mixed_fraction()
     answer = number1 + number2
     #logging.info (number1, number2, answer)
-    question = "The sum of {} and {} is _____.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
+    question = "The sum of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
     return (question, printable_mixed_fraction(answer))
 
-def mixed_fractions_difference ():
-    pass
+def mixed_fractions_difference (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_mixed_fraction()
+        number2 = __generate_mixed_fraction()
+        while number2 >= number1:
+            number2 = __generate_mixed_fraction()
+    answer = number1 - number2
+    #logging.info (number1, number2, answer)
+    question = "The difference of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+def mixed_fractions_multiplication (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_mixed_fraction()
+        number2 = __generate_fraction()
+    answer = number1 * number2
+    question = "The product of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_fraction_from_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
 
-functions = [fractions_sum, fractions_difference, sort_unlike_fractions, sort_unlike_fractions_descending, mixed_fractions_sum]
+def fractions_division (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_fraction()
+        number2 = __generate_fraction()
+
+    answer = number1 / number2
+    question = "Divide {} by {}. Convert any improper fraction into a mixed fraction.".format (printable_fraction_from_fraction(number1), printable_fraction_from_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+def fractions_division_by_whole_number (number1=Fraction(), number2=0):
+    if number1 == Fraction() or number2 == 0:
+        number1 = __generate_fraction()
+        number2 = random.randint (3,9)
+    answer = number1 / number2
+    question = "Divide {} by {}.".format (printable_fraction_from_fraction(number1), number2)
+    return (question, printable_fraction_from_fraction(answer))
+
+def whole_number_by_fractions_division (number1=0, number2=Fraction()):
+    if number2 == Fraction() or number1 == 0:
+        number2 = __generate_fraction()
+        number1 = random.randint (3,9)
+    answer = number1 / number2
+    question = "Divide {} by {}.".format (number1, printable_fraction_from_fraction(number2))
+    return (question, printable_fraction_from_fraction(answer))
+
+def mixed_fractions_division (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_mixed_fraction()
+        number2 = __generate_mixed_fraction()
+    answer = number1 / number2
+    question = "Divide {} by {}. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+
+functions = [fractions_sum, fractions_difference, sort_unlike_fractions, sort_unlike_fractions_descending, mixed_fractions_sum, \
+             mixed_fractions_difference, mixed_fractions_multiplication,fractions_division, fractions_division_by_whole_number, \
+             whole_number_by_fractions_division, mixed_fractions_division]
 
 
 def main():
@@ -143,13 +195,18 @@ def main():
         answers.append(answer)
 
 
-    html_text = r'<ol>'
+    html_text = r'<h2>Questions</h2>'
+    html_text += r'<ol>'
     for i in range(0, len(questions)):
-        html = "<li> {} : {}</li>".format (questions[i], answers[i])
+        html = "    <li> {} </li>\n".format (questions[i])
+        html_text += html
+    html_text += r'</ol>'
+    html_text += r'<br/><hr>'
+    html_text += r'<h2>Answers</h2>'
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (answers[i])
         html_text += html
-
-        #print(answer)
-    #html_text += r'$2\frac {2}{9}$'
     html_text += r'</ol>'
     print ("{} {} {}".format(html_pre_context, html_text, html_post_content))
 
diff --git a/class05/math/tests/test_fraction.py b/class05/math/tests/test_fraction.py
index b738b9c..2be23a3 100644
--- a/class05/math/tests/test_fraction.py
+++ b/class05/math/tests/test_fraction.py
@@ -33,6 +33,65 @@ def test_mixed_fraction_sum (self):
         number2 = Fraction (33,4)
         question, answer = mixed_fractions_sum(number1, number2)
         self.assertEqual(r'$16\frac {7}{12}$', answer )
+        number1 = Fraction (25,3)
+        number2 = Fraction (47,5)
+        question, answer = mixed_fractions_sum(number1, number2)
+        self.assertEqual(r'$17\frac {11}{15}$', answer )
+
+    def test_mixed_fraction_difference (self):
+        number1 = Fraction(77,9)
+        number2 = Fraction (43,7)
+        question, answer = mixed_fractions_difference(number1, number2)
+        self.assertEqual(r'$2\frac {26}{63}$', answer )
+        number1 = Fraction (23,6)
+        number2 = Fraction (7,3)
+        question, answer = mixed_fractions_difference(number1, number2)
+        self.assertEqual(r'$1\frac {1}{2}$', answer )
+
+    def test_mixed_fraction_multiplication (self):
+        number1 = Fraction(65,8)
+        number2 = Fraction (2,1)
+        question, answer = mixed_fractions_multiplication(number1, number2)
+        self.assertEqual(r'$16\frac {1}{4}$', answer )
+        number1 = Fraction (29,3)
+        number2 = Fraction (1,6)
+        question, answer = mixed_fractions_multiplication(number1, number2)
+        self.assertEqual(r'$1\frac {11}{18}$', answer )
+
+    def test_fractions_division (self):
+        number1 = Fraction(8,7)
+        number2 = Fraction (9,8)
+        question, answer = fractions_division(number1, number2)
+        self.assertEqual(r'$1\frac {1}{63}$', answer )
+        number1 = Fraction (2,1)
+        number2 = Fraction (7,9)
+        question, answer = fractions_division(number1, number2)
+        self.assertEqual(r'$2\frac {4}{7}$', answer )
+
+    def test_fractions_division_by_whole_number (self):
+        number1 = Fraction(1,1)
+        number2 = 4
+        question, answer = fractions_division_by_whole_number(number1, number2)
+        self.assertEqual(r'$\frac {1}{4}$', answer )
+        number1 = Fraction (2,1)
+        number2 = Fraction (9)
+        question, answer = fractions_division_by_whole_number(number1, number2)
+        self.assertEqual(r'$\frac {2}{9}$', answer )
+
+    def test_whole_number_by_fractions_division (self):
+        question, answer = whole_number_by_fractions_division (5, Fraction (5,2))
+        self.assertEqual(r'$\frac {2}{1}$', answer )
+        question, answer = whole_number_by_fractions_division (3, Fraction (5,9))
+        self.assertEqual(r'$\frac {27}{5}$', answer )
+
+    def test_mixed_fractions_division (self):
+        question, answer = mixed_fractions_division (Fraction(16,3), Fraction (7,2))
+        self.assertEqual(r'$1\frac {11}{21}$', answer )
+        question, answer = mixed_fractions_division (Fraction(17,4), Fraction (5,2))
+        self.assertEqual(r'$1\frac {7}{10}$', answer )
+
+
+
 
 if __name__ == '__main__':
     unittest.main()

From 95d8bc14ed286356d35cfda642f78cc1b0727ec3 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Wed, 27 Jan 2016 12:17:55 +0530
Subject: [PATCH 06/39] uuid

---
 class05/math/fraction.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/class05/math/fraction.py b/class05/math/fraction.py
index af8e6a1..0f748a4 100644
--- a/class05/math/fraction.py
+++ b/class05/math/fraction.py
@@ -8,6 +8,7 @@
 
 import random
 import logging
+import uuid
 # from fractions import Fraction
 from fractions import Fraction
 
@@ -185,7 +186,7 @@ def mixed_fractions_division (number1=Fraction(), number2=Fraction()):
 def main():
     logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y%m%d %I:%M:%S %p',
                         filename='class.log', level=logging.INFO)
-    #random.seed (os.urandom(5))
+    unique_id = uuid.uuid1(1)
 
     for i in range(0, len(functions)):
         logging.info('Function : %s' % functions[i])
@@ -194,15 +195,14 @@ def main():
         questions.append(question)
         answers.append(answer)
 
-
-    html_text = r'<h2>Questions</h2>'
+    html_text = r'<h2>Questions: {}</h2>'.format(str(unique_id))
     html_text += r'<ol>'
     for i in range(0, len(questions)):
         html = "    <li> {} </li>\n".format (questions[i])
         html_text += html
     html_text += r'</ol>'
     html_text += r'<br/><hr>'
-    html_text += r'<h2>Answers</h2>'
+    html_text += r'<h2>Answer Key: {}</h2>'.format(str(unique_id))
     html_text += r'<ol>'
     for i in range(0, len(questions)):
         html = "    <li> {} </li>\n".format (answers[i])

From 1e1536ded341e0fb0c01833f764ca8c109f9c681 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Wed, 27 Jan 2016 20:49:57 +0530
Subject: [PATCH 07/39] fractions.py added

---
 class05/math/decimals.py | 215 +++++++++++++++++++++++++++++++++++++++
 class05/math/fraction.py |  14 +--
 2 files changed, 222 insertions(+), 7 deletions(-)
 create mode 100644 class05/math/decimals.py

diff --git a/class05/math/decimals.py b/class05/math/decimals.py
new file mode 100644
index 0000000..ad2092b
--- /dev/null
+++ b/class05/math/decimals.py
@@ -0,0 +1,215 @@
+__author__ = 'Ajay'
+
+'''Generates questions on fractions'''
+'''Usage: python <this_file.py> > test.html''' #test.html can be opened in  a browser to view the fraction problems
+''' Output: Generates a html file, with the questions and answers'''
+# references : https://docs.python.org/2/library/fractions.html
+#              http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference
+
+import random
+import logging
+import uuid
+# from fractions import Fraction
+from fractions import Fraction
+
+
+questions = []
+answers = []
+
+style = r'<style>body{font-size:16;font-family:Verdana;}</style>'
+html_pre_context = r'<html> <head> <title> Quiz on fractions </title>' + r'<script type="text/x-mathjax-config">MathJax.Hub.Config({' + \
+  r'tex2jax: {' + r"inlineMath: [ ['$','$'], ['\\(','\\)'] ]" + \
+  r'}' + r'})'+ r'</script><script type="text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" ></script> ' +\
+  style + r'</head > <body> '
+html_post_content = r'</body></html>'
+
+'''Generates a fraction ranging from 1...9/1..9'''
+def __generate_fraction ():
+    return (Fraction(random.randint(1,9),random.randint(2,9) ))
+
+def __generate_mixed_fraction ():
+    frac = __generate_fraction()
+    while frac.denominator == 1:
+        frac = __generate_fraction()
+    return frac + random.randint (1,9)
+
+'''input: numerator and denominator
+   output: a string, that appears as a fraction in LaTeX format
+   '''
+def printable_fraction (numerator: int, denominator: int):
+    printable = "$\\frac {" + str(numerator) +"}{" +  str(denominator) + "}$"
+    return printable
+
+'''Takes a Fraction data structure'''
+def printable_fraction_from_fraction (fraction: Fraction):
+    return printable_fraction(fraction.numerator, fraction.denominator)
+
+def printable_mixed_fraction (fraction: Fraction):
+    if fraction.numerator <= fraction.denominator:
+        return printable_fraction_from_fraction(fraction)
+    else:
+        whole_number = fraction.numerator // fraction.denominator
+        fraction = fraction - whole_number
+        printable = "${}".format(whole_number) +"\\frac {" + str(fraction.numerator) +"}{" +  str(fraction.denominator) + "}$"
+        return printable
+
+
+def fractions_sum():
+    fraction1_numerator = random.randint(1, 9)
+    fraction1_denominator = random.randint(1, 9) + fraction1_numerator
+    fraction2_numerator = random.randint(1, 9)
+    fraction2_denominator = random.randint(1, 9) + fraction2_numerator
+    answer = Fraction(fraction1_numerator, fraction1_denominator) + Fraction(fraction2_numerator, fraction2_denominator)
+    question = "The sum of {} and {} is __________".format(printable_fraction(fraction1_numerator, fraction1_denominator),
+                                                                 printable_fraction(fraction2_numerator, fraction2_denominator))
+    answer = printable_fraction (answer.numerator, answer.denominator)
+    return (question, answer)
+
+def fractions_difference ():
+    subtrahend= Fraction (random.randint(1, 9), random.randint(1,9))
+    difference = Fraction (random.randint(1, 9),random.randint(1, 5))
+    minuend = subtrahend + difference
+    question = "The difference between {} and {} is __________".format(printable_fraction_from_fraction(minuend),
+                                                                 printable_fraction_from_fraction(subtrahend))
+    answer = minuend - subtrahend
+    answer = printable_fraction (answer.numerator, answer.denominator)
+    return (question, answer)
+
+
+
+def sort_unlike_fractions (fractions_list = [], ascending=True):
+    list = []
+    if  not fractions_list:
+        i = 0
+        while len (list) < 4:
+            frac = __generate_fraction()
+            if frac not in list:
+                list.append(frac)
+                i+=1
+    else:
+        list = fractions_list
+    logging.info ("Fractions to be sorted: {}".format(list))
+    sorted_fraction_list = sorted(list)
+    if ascending is not True:
+        sorted_fraction_list.reverse()
+    question_sub_text = ""
+    for i in range (0, len(list)):
+        question_sub_text += printable_fraction_from_fraction(list[i])
+        if i != len (list)-1:
+            question_sub_text += ','
+    if ascending is True:
+        order = "ascending"
+    else:
+        order = "descending"
+    question = 'Arrange the fractions {} in {} order'.format (question_sub_text, order )
+    logging.info (question)
+    answer = ""
+    for i in range (0, len(list)):
+        answer += printable_fraction_from_fraction(sorted_fraction_list[i])
+        if i != len (list)-1:
+            answer += ','
+    logging.info (answer)
+    logging.info (sorted_fraction_list)
+
+    return (question, answer)
+
+def sort_unlike_fractions_descending (fractions_list = [], ascending=False):
+    return sort_unlike_fractions(fractions_list, ascending)
+
+def mixed_fractions_sum (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_mixed_fraction()
+        number2 = __generate_mixed_fraction()
+    answer = number1 + number2
+    #logging.info (number1, number2, answer)
+    question = "The sum of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+def mixed_fractions_difference (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_mixed_fraction()
+        number2 = __generate_mixed_fraction()
+        while number2 >= number1:
+            number2 = __generate_mixed_fraction()
+    answer = number1 - number2
+    #logging.info (number1, number2, answer)
+    question = "The difference of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+def mixed_fractions_multiplication (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_mixed_fraction()
+        number2 = __generate_fraction()
+    answer = number1 * number2
+    question = "The product of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_fraction_from_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+def fractions_division (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_fraction()
+        number2 = __generate_fraction()
+
+    answer = number1 / number2
+    question = "Divide {} by {}. Convert any improper fraction into a mixed fraction.".format (printable_fraction_from_fraction(number1), printable_fraction_from_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+def fractions_division_by_whole_number (number1=Fraction(), number2=0):
+    if number1 == Fraction() or number2 == 0:
+        number1 = __generate_fraction()
+        number2 = random.randint (3,9)
+    answer = number1 / number2
+    question = "Divide {} by {}.".format (printable_fraction_from_fraction(number1), number2)
+    return (question, printable_fraction_from_fraction(answer))
+
+def whole_number_by_fractions_division (number1=0, number2=Fraction()):
+    if number2 == Fraction() or number1 == 0:
+        number2 = __generate_fraction()
+        number1 = random.randint (3,9)
+    answer = number1 / number2
+    question = "Divide {} by {}.".format (number1, printable_fraction_from_fraction(number2))
+    return (question, printable_fraction_from_fraction(answer))
+
+def mixed_fractions_division (number1=Fraction(), number2=Fraction()):
+    if number1 == Fraction() or number2 == Fraction():
+        number1 = __generate_mixed_fraction()
+        number2 = __generate_mixed_fraction()
+    answer = number1 / number2
+    question = "Divide {} by {}. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
+    return (question, printable_mixed_fraction(answer))
+
+
+functions = [fractions_sum, fractions_difference, sort_unlike_fractions, sort_unlike_fractions_descending, mixed_fractions_sum, \
+             mixed_fractions_difference, mixed_fractions_multiplication,fractions_division, fractions_division_by_whole_number, \
+             whole_number_by_fractions_division, mixed_fractions_division]
+
+
+def main():
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y%m%d %I:%M:%S %p',
+                        filename='class.log', level=logging.INFO)
+    unique_id = uuid.uuid1(1)
+
+    for i in range(0, len(functions)):
+        logging.info('Function : %s' % functions[i])
+        f = functions[i]
+        question, answer = f()
+        questions.append(question)
+        answers.append(answer)
+    html_text = "<h1>Fractions</h1>\n"
+    html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (questions[i])
+        html_text += html
+    html_text += r'</ol>'
+    html_text += r'<br/><hr>'
+    html_text += "<h2>Answer Key: {}</h2>\n".format(str(unique_id)[:8])
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (answers[i])
+        html_text += html
+    html_text += r'</ol>'
+    print ("{} {} {}".format(html_pre_context, html_text, html_post_content))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/class05/math/fraction.py b/class05/math/fraction.py
index 0f748a4..24990f2 100644
--- a/class05/math/fraction.py
+++ b/class05/math/fraction.py
@@ -56,9 +56,9 @@ def printable_mixed_fraction (fraction: Fraction):
 
 def fractions_sum():
     fraction1_numerator = random.randint(1, 9)
-    fraction1_denominator = random.randint(1, 9) + fraction1_numerator
+    fraction1_denominator = random.randint(2, 9) + fraction1_numerator
     fraction2_numerator = random.randint(1, 9)
-    fraction2_denominator = random.randint(1, 9) + fraction2_numerator
+    fraction2_denominator = random.randint(2, 9) + fraction2_numerator
     answer = Fraction(fraction1_numerator, fraction1_denominator) + Fraction(fraction2_numerator, fraction2_denominator)
     question = "The sum of {} and {} is __________".format(printable_fraction(fraction1_numerator, fraction1_denominator),
                                                                  printable_fraction(fraction2_numerator, fraction2_denominator))
@@ -66,8 +66,8 @@ def fractions_sum():
     return (question, answer)
 
 def fractions_difference ():
-    subtrahend= Fraction (random.randint(1, 9), random.randint(1,9))
-    difference = Fraction (random.randint(1, 9),random.randint(1, 5))
+    subtrahend= Fraction (random.randint(1, 9), random.randint(2,9))
+    difference = Fraction (random.randint(1, 9),random.randint(2, 5))
     minuend = subtrahend + difference
     question = "The difference between {} and {} is __________".format(printable_fraction_from_fraction(minuend),
                                                                  printable_fraction_from_fraction(subtrahend))
@@ -194,15 +194,15 @@ def main():
         question, answer = f()
         questions.append(question)
         answers.append(answer)
-
-    html_text = r'<h2>Questions: {}</h2>'.format(str(unique_id))
+    html_text = "<h1>Decimals</h1>\n"
+    html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
     html_text += r'<ol>'
     for i in range(0, len(questions)):
         html = "    <li> {} </li>\n".format (questions[i])
         html_text += html
     html_text += r'</ol>'
     html_text += r'<br/><hr>'
-    html_text += r'<h2>Answer Key: {}</h2>'.format(str(unique_id))
+    html_text += "<h2>Answer Key: {}</h2>\n".format(str(unique_id)[:8])
     html_text += r'<ol>'
     for i in range(0, len(questions)):
         html = "    <li> {} </li>\n".format (answers[i])

From 19e04a2fe4b0e5f0fc59581cbfea9fd1b56ebc4b Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Wed, 27 Jan 2016 22:47:17 +0530
Subject: [PATCH 08/39] add/sub/mul/div decimals

---
 class05/math/decimals.py            | 124 ++++++++++++----------------
 class05/math/tests/test_decimals.py |  42 ++++++++++
 2 files changed, 97 insertions(+), 69 deletions(-)
 create mode 100644 class05/math/tests/test_decimals.py

diff --git a/class05/math/decimals.py b/class05/math/decimals.py
index ad2092b..05ec163 100644
--- a/class05/math/decimals.py
+++ b/class05/math/decimals.py
@@ -11,6 +11,7 @@
 import uuid
 # from fractions import Fraction
 from fractions import Fraction
+import decimal
 
 
 questions = []
@@ -53,105 +54,89 @@ def printable_mixed_fraction (fraction: Fraction):
         printable = "${}".format(whole_number) +"\\frac {" + str(fraction.numerator) +"}{" +  str(fraction.denominator) + "}$"
         return printable
 
+def generate_decimal (integer=999, mantissa=9999):
+    return decimal.Decimal ('%d.%d' %(random.randint(0, integer), random.randint(0, mantissa)))
 
-def fractions_sum():
-    fraction1_numerator = random.randint(1, 9)
-    fraction1_denominator = random.randint(1, 9) + fraction1_numerator
-    fraction2_numerator = random.randint(1, 9)
-    fraction2_denominator = random.randint(1, 9) + fraction2_numerator
-    answer = Fraction(fraction1_numerator, fraction1_denominator) + Fraction(fraction2_numerator, fraction2_denominator)
-    question = "The sum of {} and {} is __________".format(printable_fraction(fraction1_numerator, fraction1_denominator),
-                                                                 printable_fraction(fraction2_numerator, fraction2_denominator))
-    answer = printable_fraction (answer.numerator, answer.denominator)
-    return (question, answer)
 
-def fractions_difference ():
-    subtrahend= Fraction (random.randint(1, 9), random.randint(1,9))
-    difference = Fraction (random.randint(1, 9),random.randint(1, 5))
-    minuend = subtrahend + difference
-    question = "The difference between {} and {} is __________".format(printable_fraction_from_fraction(minuend),
-                                                                 printable_fraction_from_fraction(subtrahend))
-    answer = minuend - subtrahend
-    answer = printable_fraction (answer.numerator, answer.denominator)
+def decimals_sum():
+    decimal1 = generate_decimal(0, 99)
+    decimal2 = generate_decimal(99, 9999)
+    answer = decimal1 + decimal2
+    question = "The sum of {} and {} is __________".format(decimal1, decimal2)
     return (question, answer)
 
+def decimals_mantissa_sum ():
+    decimal1 = generate_decimal(0, 99)
+    decimal2 = generate_decimal(0, 9999)
+    answer = decimal1 + decimal2
+    question = "The sum of {} and {} is __________".format(decimal1, decimal2)
+    return (question, answer)
 
+def decimals_difference ():
+    minuend = generate_decimal(99, 99)
+    subtrahend= generate_decimal(49, 99999)
+    while (minuend <= subtrahend):
+        minuend += generate_decimal(10, 9)
+    question = "The difference between {} and {} is __________".format(minuend, subtrahend)
+    answer = minuend - subtrahend
+    return (question, answer)
 
-def sort_unlike_fractions (fractions_list = [], ascending=True):
+def sort_decimals (decimals_list = [], ascending=True):
     list = []
-    if  not fractions_list:
+    if  not decimals_list:
         i = 0
         while len (list) < 4:
-            frac = __generate_fraction()
-            if frac not in list:
-                list.append(frac)
+            dec = generate_decimal(1, 9999)
+            if dec not in list:
+                list.append(dec)
                 i+=1
     else:
-        list = fractions_list
-    logging.info ("Fractions to be sorted: {}".format(list))
-    sorted_fraction_list = sorted(list)
+        list = decimals_list
+    logging.info ("Decimals to be sorted: {}".format(list))
+    sorted_decimals_list = sorted(list)
     if ascending is not True:
-        sorted_fraction_list.reverse()
+        sorted_decimals_list.reverse()
     question_sub_text = ""
     for i in range (0, len(list)):
-        question_sub_text += printable_fraction_from_fraction(list[i])
+        question_sub_text += str(list[i])
         if i != len (list)-1:
             question_sub_text += ','
     if ascending is True:
         order = "ascending"
     else:
         order = "descending"
-    question = 'Arrange the fractions {} in {} order'.format (question_sub_text, order )
+    question = 'Arrange the decimals {} in {} order'.format (question_sub_text, order )
     logging.info (question)
     answer = ""
     for i in range (0, len(list)):
-        answer += printable_fraction_from_fraction(sorted_fraction_list[i])
+        answer += str(sorted_decimals_list[i])
         if i != len (list)-1:
             answer += ','
     logging.info (answer)
-    logging.info (sorted_fraction_list)
-
+    logging.info (sorted_decimals_list)
     return (question, answer)
 
-def sort_unlike_fractions_descending (fractions_list = [], ascending=False):
-    return sort_unlike_fractions(fractions_list, ascending)
+def sort_decimals_descending (fractions_list = [], ascending=False):
+    return sort_decimals(fractions_list, ascending)
 
-def mixed_fractions_sum (number1=Fraction(), number2=Fraction()):
-    if number1 == Fraction() or number2 == Fraction():
-        number1 = __generate_mixed_fraction()
-        number2 = __generate_mixed_fraction()
-    answer = number1 + number2
-    #logging.info (number1, number2, answer)
-    question = "The sum of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
-    return (question, printable_mixed_fraction(answer))
-
-def mixed_fractions_difference (number1=Fraction(), number2=Fraction()):
-    if number1 == Fraction() or number2 == Fraction():
-        number1 = __generate_mixed_fraction()
-        number2 = __generate_mixed_fraction()
-        while number2 >= number1:
-            number2 = __generate_mixed_fraction()
-    answer = number1 - number2
-    #logging.info (number1, number2, answer)
-    question = "The difference of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
-    return (question, printable_mixed_fraction(answer))
 
-def mixed_fractions_multiplication (number1=Fraction(), number2=Fraction()):
-    if number1 == Fraction() or number2 == Fraction():
-        number1 = __generate_mixed_fraction()
-        number2 = __generate_fraction()
+def decimals_multiplication (number1=decimal.Decimal(), number2=decimal.Decimal()):
+    if number1 == decimal.Decimal() or number2 == decimal.Decimal():
+        number1 = generate_decimal(9,99)
+        number2 = generate_decimal(999,9999)
     answer = number1 * number2
-    question = "The product of {} and {} is _____. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_fraction_from_fraction(number2))
-    return (question, printable_mixed_fraction(answer))
-
-def fractions_division (number1=Fraction(), number2=Fraction()):
-    if number1 == Fraction() or number2 == Fraction():
-        number1 = __generate_fraction()
-        number2 = __generate_fraction()
+    question = "The product of {} and {} is _____. ".format (number1,number2)
+    return (question, answer)
 
+def decimals_division (number1=decimal.Decimal(), number2=decimal.Decimal()):
+    if number1 == decimal.Decimal() or number2 == decimal.Decimal():
+        number1 = generate_decimal(99,9999)
+        number2 = generate_decimal(9,99)
+    decimal.getcontext().prec = 6
     answer = number1 / number2
-    question = "Divide {} by {}. Convert any improper fraction into a mixed fraction.".format (printable_fraction_from_fraction(number1), printable_fraction_from_fraction(number2))
-    return (question, printable_mixed_fraction(answer))
+    decimal.getcontext().prec = 28
+    question = "Divide {} by {}. Stop the division at 4 places after decimal point.".format (number1, number2)
+    return (question, answer)
 
 def fractions_division_by_whole_number (number1=Fraction(), number2=0):
     if number1 == Fraction() or number2 == 0:
@@ -178,9 +163,10 @@ def mixed_fractions_division (number1=Fraction(), number2=Fraction()):
     return (question, printable_mixed_fraction(answer))
 
 
-functions = [fractions_sum, fractions_difference, sort_unlike_fractions, sort_unlike_fractions_descending, mixed_fractions_sum, \
-             mixed_fractions_difference, mixed_fractions_multiplication,fractions_division, fractions_division_by_whole_number, \
-             whole_number_by_fractions_division, mixed_fractions_division]
+functions = [ fractions_division_by_whole_number, \
+             whole_number_by_fractions_division, mixed_fractions_division, \
+             decimals_sum, decimals_mantissa_sum, decimals_difference, sort_decimals, sort_decimals_descending, decimals_multiplication, \
+             decimals_division]
 
 
 def main():
diff --git a/class05/math/tests/test_decimals.py b/class05/math/tests/test_decimals.py
new file mode 100644
index 0000000..f28381f
--- /dev/null
+++ b/class05/math/tests/test_decimals.py
@@ -0,0 +1,42 @@
+# ..\tests>python test_fraction.py
+
+import unittest
+from unittest import TestCase
+__author__ = 'Ajay'
+import sys, decimal
+from decimal import ROUND_HALF_UP
+
+sys.path.append('..\\')
+from decimals import *
+
+
+class TestDecimals(TestCase):
+
+    def test_sort_decimals(self):
+        question, answer = sort_decimals ([decimal.Decimal('1.3014'),decimal.Decimal('0.9286'),decimal.Decimal('1.1868'), decimal.Decimal('0.9887')])
+        self.assertEqual(r'0.9286,0.9887,1.1868,1.3014', answer)
+        question, answer = sort_decimals ([decimal.Decimal('1.3573'),decimal.Decimal('0.237'),decimal.Decimal('.1087'), decimal.Decimal('.1673')])
+        self.assertEqual(r'0.1087,0.1673,0.237,1.3573', answer)
+
+    def test_sort_decimals_descending (self):
+        question, answer = sort_decimals_descending ([decimal.Decimal('1.5322'),decimal.Decimal('0.3238'),decimal.Decimal('0.160'),decimal.Decimal('1.9656')])
+        self.assertEqual(r'1.9656,1.5322,0.3238,0.160', answer)
+        question, answer = sort_decimals_descending ([decimal.Decimal('0.2400'),decimal.Decimal('0.3625'),decimal.Decimal('0.4785'),decimal.Decimal('1.6537')])
+        self.assertEqual(r'1.6537,0.4785,0.3625,0.2400', answer)
+
+    def test_decimals_multiplication (self):
+        __, answer = decimals_multiplication (decimal.Decimal('2.60'), decimal.Decimal('251.647'))
+        self.assertEqual(decimal.Decimal('654.28220'), answer)
+
+    def test_decimals_division (self):
+        __, answer = decimals_division (decimal.Decimal('22.7665'), decimal.Decimal('8.79'))
+        self.assertEqual(decimal.Decimal('2.59005'), answer)
+
+
+
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()

From 8b6326f73e194c523d196590775f842141721a8f Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Wed, 27 Jan 2016 22:56:26 +0530
Subject: [PATCH 09/39] get and reset precision in decimals_division

---
 class05/math/decimals.py            | 6 ++++--
 class05/math/tests/test_decimals.py | 2 ++
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/class05/math/decimals.py b/class05/math/decimals.py
index 05ec163..be54711 100644
--- a/class05/math/decimals.py
+++ b/class05/math/decimals.py
@@ -3,7 +3,8 @@
 '''Generates questions on fractions'''
 '''Usage: python <this_file.py> > test.html''' #test.html can be opened in  a browser to view the fraction problems
 ''' Output: Generates a html file, with the questions and answers'''
-# references : https://docs.python.org/2/library/fractions.html
+# references : https://docs.python.org/2/library/decimal.html
+#              https://docs.python.org/2/library/fractions.html
 #              http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference
 
 import random
@@ -132,9 +133,10 @@ def decimals_division (number1=decimal.Decimal(), number2=decimal.Decimal()):
     if number1 == decimal.Decimal() or number2 == decimal.Decimal():
         number1 = generate_decimal(99,9999)
         number2 = generate_decimal(9,99)
+    current_precision = decimal.getcontext().prec
     decimal.getcontext().prec = 6
     answer = number1 / number2
-    decimal.getcontext().prec = 28
+    decimal.getcontext().prec = current_precision
     question = "Divide {} by {}. Stop the division at 4 places after decimal point.".format (number1, number2)
     return (question, answer)
 
diff --git a/class05/math/tests/test_decimals.py b/class05/math/tests/test_decimals.py
index f28381f..6c8d90a 100644
--- a/class05/math/tests/test_decimals.py
+++ b/class05/math/tests/test_decimals.py
@@ -31,6 +31,8 @@ def test_decimals_multiplication (self):
     def test_decimals_division (self):
         __, answer = decimals_division (decimal.Decimal('22.7665'), decimal.Decimal('8.79'))
         self.assertEqual(decimal.Decimal('2.59005'), answer)
+        __, answer = decimals_division (decimal.Decimal('14.6643'), decimal.Decimal('3.87'))
+        self.assertEqual(decimal.Decimal('3.78922'), answer)
 
 
 

From e92603122e5d247b8b34c06b91cffb64ca5f8723 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Thu, 28 Jan 2016 15:15:39 +0530
Subject: [PATCH 10/39] other functions per text book

---
 class05/math/decimals.py            | 110 +++++++++++++++++++++-------
 class05/math/tests/test_decimals.py |  39 ++++++++++
 2 files changed, 123 insertions(+), 26 deletions(-)

diff --git a/class05/math/decimals.py b/class05/math/decimals.py
index be54711..b1b5270 100644
--- a/class05/math/decimals.py
+++ b/class05/math/decimals.py
@@ -19,13 +19,13 @@
 answers = []
 
 style = r'<style>body{font-size:16;font-family:Verdana;}</style>'
-html_pre_context = r'<html> <head> <title> Quiz on fractions </title>' + r'<script type="text/x-mathjax-config">MathJax.Hub.Config({' + \
+html_pre_context = r'<html> <head> <title> Home Work Problems - Decimals </title>' + r'<script type="text/x-mathjax-config">MathJax.Hub.Config({' + \
   r'tex2jax: {' + r"inlineMath: [ ['$','$'], ['\\(','\\)'] ]" + \
   r'}' + r'})'+ r'</script><script type="text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" ></script> ' +\
   style + r'</head > <body> '
 html_post_content = r'</body></html>'
 
-'''Generates a fraction ranging from 1...9/1..9'''
+'''Generates a fraction ranging from 1...9/2..9'''
 def __generate_fraction ():
     return (Fraction(random.randint(1,9),random.randint(2,9) ))
 
@@ -58,6 +58,40 @@ def printable_mixed_fraction (fraction: Fraction):
 def generate_decimal (integer=999, mantissa=9999):
     return decimal.Decimal ('%d.%d' %(random.randint(0, integer), random.randint(0, mantissa)))
 
+def decimal_to_fraction (number = decimal.Decimal()):
+    if number == decimal.Decimal():
+        number = generate_decimal(0, 999)
+    number_in_fraction = Fraction(number)
+    answer = printable_fraction_from_fraction(number_in_fraction)
+    question = "Convert {} to a fraction. Simplify the fraction, if required.".format(number)
+    return (question, answer)
+
+def multiple_decimals_to_fractions (decimal_list = []):
+    dec_list = []
+    if not decimal_list:
+        i = 0
+        if len(decimal_list) <= 4:
+            dec_list.append (decimal.Decimal(random.randint(1,9)/1000).quantize(decimal.Decimal('0.001'), rounding=decimal.ROUND_DOWN))
+            dec_list.append (decimal.Decimal(random.randint(111,999)/1000).quantize(decimal.Decimal('0.001'), rounding=decimal.ROUND_DOWN))
+            dec_list.append (decimal.Decimal(random.randint(1,9)/100).quantize(decimal.Decimal('0.01'), rounding=decimal.ROUND_DOWN))
+            dec_list.append (generate_decimal(0, 9999).quantize(decimal.Decimal('0.001'), rounding=decimal.ROUND_DOWN))
+
+        decimal_list = dec_list
+    fraction_list = []
+    answer = ""
+    question = ""
+    for i in range (0, len (decimal_list)):
+        fraction_list.append( Fraction(decimal_list[i]))
+        answer += printable_fraction_from_fraction(fraction_list[i])
+        question += " {}".format (decimal_list[i])
+        if i != len (decimal_list) -1:
+            answer += ","
+            question += ","
+    question = "Convert the decimals into their equivalent fractions : {}".format (question)
+    return (question, answer)
+
+
+
 
 def decimals_sum():
     decimal1 = generate_decimal(0, 99)
@@ -129,6 +163,15 @@ def decimals_multiplication (number1=decimal.Decimal(), number2=decimal.Decimal(
     question = "The product of {} and {} is _____. ".format (number1,number2)
     return (question, answer)
 
+def decimals_integers_multiplication (number1=decimal.Decimal(), number2=0):
+    if number1 == decimal.Decimal() or number2 == 0:
+        number1 = generate_decimal(0,99)
+        number2 = random.randint (5,50)
+    answer = number1 * number2
+    question = "{} x {} = ______".format (number1, number2)
+    return (question, answer)
+
+
 def decimals_division (number1=decimal.Decimal(), number2=decimal.Decimal()):
     if number1 == decimal.Decimal() or number2 == decimal.Decimal():
         number1 = generate_decimal(99,9999)
@@ -140,35 +183,50 @@ def decimals_division (number1=decimal.Decimal(), number2=decimal.Decimal()):
     question = "Divide {} by {}. Stop the division at 4 places after decimal point.".format (number1, number2)
     return (question, answer)
 
-def fractions_division_by_whole_number (number1=Fraction(), number2=0):
-    if number1 == Fraction() or number2 == 0:
-        number1 = __generate_fraction()
-        number2 = random.randint (3,9)
+def decimals_integers_division (number1=decimal.Decimal(), number2=0):
+    if number1 == decimal.Decimal() or number2 == 0:
+        number1 = generate_decimal(4,99)
+        number2 = random.randint (4,9)
+    original_precision = decimal.getcontext().prec
+    decimal.getcontext().prec=4
     answer = number1 / number2
-    question = "Divide {} by {}.".format (printable_fraction_from_fraction(number1), number2)
-    return (question, printable_fraction_from_fraction(answer))
+    decimal.getcontext().prec = original_precision
+    question = "{} divided by {} = ______".format (number1, number2)
+    return (question, answer)
 
-def whole_number_by_fractions_division (number1=0, number2=Fraction()):
-    if number2 == Fraction() or number1 == 0:
-        number2 = __generate_fraction()
-        number1 = random.randint (3,9)
+def integers_decimals_division (number1=0, number2= decimal.Decimal()):
+    if number1 == 0 or number2 == decimal.Decimal():
+        number1 = random.randint (19, 300)
+        number2 = generate_decimal(9,9)
+    original_precision = decimal.getcontext().prec
+    decimal.getcontext().prec=4
     answer = number1 / number2
-    question = "Divide {} by {}.".format (number1, printable_fraction_from_fraction(number2))
-    return (question, printable_fraction_from_fraction(answer))
+    decimal.getcontext().prec = original_precision
+    question = "{} divided by {} = ______".format (number1, number2)
+    return (question, answer)
+
+
+def percentage_of_whole_numbers (percentage=0, whole_number=0):
+    if percentage == 0 or whole_number == 0:
+        percentage = random.randint (2,15)*5
+        whole_number = random.randint (2,19) * 5
+    answer = whole_number * percentage / 100
+    question = "{}% of {} is _______.".format (percentage, whole_number)
+    return  (question, answer)
+
+def decimal_as_percentage (number1=decimal.Decimal()):
+    if number1 == decimal.Decimal():
+        number1 = generate_decimal(0, 999)
+    answer = number1 * 100
+    answer = float(answer)
+    question = "{} can be expressed as ____%.".format (number1)
+    return (question, answer)
 
-def mixed_fractions_division (number1=Fraction(), number2=Fraction()):
-    if number1 == Fraction() or number2 == Fraction():
-        number1 = __generate_mixed_fraction()
-        number2 = __generate_mixed_fraction()
-    answer = number1 / number2
-    question = "Divide {} by {}. Convert any improper fraction into a mixed fraction.".format (printable_mixed_fraction(number1), printable_mixed_fraction(number2))
-    return (question, printable_mixed_fraction(answer))
 
 
-functions = [ fractions_division_by_whole_number, \
-             whole_number_by_fractions_division, mixed_fractions_division, \
-             decimals_sum, decimals_mantissa_sum, decimals_difference, sort_decimals, sort_decimals_descending, decimals_multiplication, \
-             decimals_division]
+functions = [decimals_sum, decimals_mantissa_sum, decimals_difference, sort_decimals, sort_decimals_descending, decimals_multiplication, \
+             decimals_division, decimal_to_fraction, multiple_decimals_to_fractions, decimals_integers_multiplication, decimals_integers_division,\
+              integers_decimals_division,percentage_of_whole_numbers, decimal_as_percentage]
 
 
 def main():
@@ -182,7 +240,7 @@ def main():
         question, answer = f()
         questions.append(question)
         answers.append(answer)
-    html_text = "<h1>Fractions</h1>\n"
+    html_text = "<h1>Decimals</h1>\n"
     html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
     html_text += r'<ol>'
     for i in range(0, len(questions)):
diff --git a/class05/math/tests/test_decimals.py b/class05/math/tests/test_decimals.py
index 6c8d90a..4551158 100644
--- a/class05/math/tests/test_decimals.py
+++ b/class05/math/tests/test_decimals.py
@@ -34,6 +34,45 @@ def test_decimals_division (self):
         __, answer = decimals_division (decimal.Decimal('14.6643'), decimal.Decimal('3.87'))
         self.assertEqual(decimal.Decimal('3.78922'), answer)
 
+    def test_decimal_to_fraction (self):
+        __, answer = decimal_to_fraction (decimal.Decimal('0.009'))
+        self.assertEqual (r'$\frac {9}{1000}$', answer)
+        __, answer = decimal_to_fraction (decimal.Decimal('0.039'))
+        self.assertEqual (r'$\frac {39}{1000}$', answer)
+        __, answer = decimal_to_fraction (decimal.Decimal('0.39'))
+        self.assertEqual (r'$\frac {39}{100}$', answer)
+        __, answer = decimal_to_fraction (decimal.Decimal('3.9'))
+        self.assertEqual (r'$\frac {39}{10}$', answer)
+
+    def test_multiple_decimals_to_fractions (self):
+        __, answer = multiple_decimals_to_fractions ([decimal.Decimal('0.008'), decimal.Decimal('0.945'), decimal.Decimal('0.01'), decimal.Decimal('0.831')])
+        self.assertEqual(r'$\frac {1}{125}$,$\frac {189}{200}$,$\frac {1}{100}$,$\frac {831}{1000}$', answer)
+        __, answer = multiple_decimals_to_fractions ([decimal.Decimal('0.004'), decimal.Decimal('0.326'), decimal.Decimal('0.02'), decimal.Decimal('0.144')])
+        self.assertEqual(r'$\frac {1}{250}$,$\frac {163}{500}$,$\frac {1}{50}$,$\frac {18}{125}$', answer)
+
+    def test_decimals_integers_multiplication (self):
+        __, answer = decimals_integers_multiplication (decimal.Decimal('0.75'), 36)
+        self.assertEqual(decimal.Decimal('27.00'), answer)
+
+    def test_decimals_integers_division (self):
+        __, answer = decimals_integers_division (decimal.Decimal('3.39'), 8)
+        self.assertEqual(decimal.Decimal('0.42375'), answer)
+        __, answer = decimals_integers_division (decimal.Decimal('0.26'), 5)
+        self.assertEqual(decimal.Decimal('0.052'), answer)
+
+    def test_integers_decimals_division (self):
+        __, answer = integers_decimals_division (81, decimal.Decimal('0.4'))
+        self.assertEqual(decimal.Decimal('202.5'), answer)
+
+    def test_percentage_of_whole_numbers (self):
+        __, answer = percentage_of_whole_numbers (70, 55)
+        self.assertEqual(38.5, answer)
+
+    def test_decimal_as_percentage (self):
+        __, answer = decimal_as_percentage (decimal.Decimal('0.948'))
+        self.assertEqual(94.8, answer)
+
+
 
 
 

From 2fb6fa79d32859c46ff3f93e9f2f985a07730fec Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Thu, 28 Jan 2016 15:29:57 +0530
Subject: [PATCH 11/39] used import instead of duplicating functions

---
 class05/math/decimals.py | 30 +-----------------------------
 1 file changed, 1 insertion(+), 29 deletions(-)

diff --git a/class05/math/decimals.py b/class05/math/decimals.py
index b1b5270..61d606e 100644
--- a/class05/math/decimals.py
+++ b/class05/math/decimals.py
@@ -13,7 +13,7 @@
 # from fractions import Fraction
 from fractions import Fraction
 import decimal
-
+from fraction import printable_fraction, printable_fraction_from_fraction
 
 questions = []
 answers = []
@@ -26,34 +26,6 @@
 html_post_content = r'</body></html>'
 
 '''Generates a fraction ranging from 1...9/2..9'''
-def __generate_fraction ():
-    return (Fraction(random.randint(1,9),random.randint(2,9) ))
-
-def __generate_mixed_fraction ():
-    frac = __generate_fraction()
-    while frac.denominator == 1:
-        frac = __generate_fraction()
-    return frac + random.randint (1,9)
-
-'''input: numerator and denominator
-   output: a string, that appears as a fraction in LaTeX format
-   '''
-def printable_fraction (numerator: int, denominator: int):
-    printable = "$\\frac {" + str(numerator) +"}{" +  str(denominator) + "}$"
-    return printable
-
-'''Takes a Fraction data structure'''
-def printable_fraction_from_fraction (fraction: Fraction):
-    return printable_fraction(fraction.numerator, fraction.denominator)
-
-def printable_mixed_fraction (fraction: Fraction):
-    if fraction.numerator <= fraction.denominator:
-        return printable_fraction_from_fraction(fraction)
-    else:
-        whole_number = fraction.numerator // fraction.denominator
-        fraction = fraction - whole_number
-        printable = "${}".format(whole_number) +"\\frac {" + str(fraction.numerator) +"}{" +  str(fraction.denominator) + "}$"
-        return printable
 
 def generate_decimal (integer=999, mantissa=9999):
     return decimal.Decimal ('%d.%d' %(random.randint(0, integer), random.randint(0, mantissa)))

From 724d5a828974be50de081732aa94e6837a44e8c5 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Thu, 28 Jan 2016 15:34:23 +0530
Subject: [PATCH 12/39] fixed decimal number precision for unit testing
 purposes

---
 class05/math/decimals.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/class05/math/decimals.py b/class05/math/decimals.py
index 61d606e..4696deb 100644
--- a/class05/math/decimals.py
+++ b/class05/math/decimals.py
@@ -62,9 +62,6 @@ def multiple_decimals_to_fractions (decimal_list = []):
     question = "Convert the decimals into their equivalent fractions : {}".format (question)
     return (question, answer)
 
-
-
-
 def decimals_sum():
     decimal1 = generate_decimal(0, 99)
     decimal2 = generate_decimal(99, 9999)
@@ -160,7 +157,7 @@ def decimals_integers_division (number1=decimal.Decimal(), number2=0):
         number1 = generate_decimal(4,99)
         number2 = random.randint (4,9)
     original_precision = decimal.getcontext().prec
-    decimal.getcontext().prec=4
+    decimal.getcontext().prec=5
     answer = number1 / number2
     decimal.getcontext().prec = original_precision
     question = "{} divided by {} = ______".format (number1, number2)
@@ -195,7 +192,6 @@ def decimal_as_percentage (number1=decimal.Decimal()):
     return (question, answer)
 
 
-
 functions = [decimals_sum, decimals_mantissa_sum, decimals_difference, sort_decimals, sort_decimals_descending, decimals_multiplication, \
              decimals_division, decimal_to_fraction, multiple_decimals_to_fractions, decimals_integers_multiplication, decimals_integers_division,\
               integers_decimals_division,percentage_of_whole_numbers, decimal_as_percentage]

From 0c3f0cbdec95947264fe6c257183502723c00ba1 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Fri, 29 Jan 2016 09:53:10 +0530
Subject: [PATCH 13/39] fraction as percentage

---
 class05/math/decimals.py            | 17 +++++++++++++++--
 class05/math/tests/test_decimals.py | 10 ++++++++--
 2 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/class05/math/decimals.py b/class05/math/decimals.py
index 4696deb..bb714f3 100644
--- a/class05/math/decimals.py
+++ b/class05/math/decimals.py
@@ -191,10 +191,23 @@ def decimal_as_percentage (number1=decimal.Decimal()):
     question = "{} can be expressed as ____%.".format (number1)
     return (question, answer)
 
+def fraction_as_percentage (number = Fraction ()):
+    if number == Fraction():
+        possible_denominators = [2, 5, 10, 20, 25, 50]
+        selection = random.randint (0, len (possible_denominators)-1)
+        denominator = possible_denominators[selection]
+        number = Fraction(random.randint (2, 15), denominator)
+    question = "Express fraction {} as a percentage.".format (printable_fraction_from_fraction(number))
+    original_precision = decimal.getcontext().prec
+    decimal.getcontext().prec = 2
+    answer = number.numerator * 100/number.denominator
+    decimal.getcontext().prec = original_precision
+    return (question, answer)
+
 
 functions = [decimals_sum, decimals_mantissa_sum, decimals_difference, sort_decimals, sort_decimals_descending, decimals_multiplication, \
              decimals_division, decimal_to_fraction, multiple_decimals_to_fractions, decimals_integers_multiplication, decimals_integers_division,\
-              integers_decimals_division,percentage_of_whole_numbers, decimal_as_percentage]
+              integers_decimals_division,percentage_of_whole_numbers, decimal_as_percentage, fraction_as_percentage]
 
 
 def main():
@@ -208,7 +221,7 @@ def main():
         question, answer = f()
         questions.append(question)
         answers.append(answer)
-    html_text = "<h1>Decimals</h1>\n"
+    html_text = "<h1>Decimals & Percentages</h1>\n"
     html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
     html_text += r'<ol>'
     for i in range(0, len(questions)):
diff --git a/class05/math/tests/test_decimals.py b/class05/math/tests/test_decimals.py
index 4551158..813389f 100644
--- a/class05/math/tests/test_decimals.py
+++ b/class05/math/tests/test_decimals.py
@@ -3,8 +3,8 @@
 import unittest
 from unittest import TestCase
 __author__ = 'Ajay'
-import sys, decimal
-from decimal import ROUND_HALF_UP
+import sys
+from decimal import ROUND_HALF_UP, Decimal
 
 sys.path.append('..\\')
 from decimals import *
@@ -72,6 +72,12 @@ def test_decimal_as_percentage (self):
         __, answer = decimal_as_percentage (decimal.Decimal('0.948'))
         self.assertEqual(94.8, answer)
 
+    def test_fraction_as_percentage (self):
+        __, answer = fraction_as_percentage (Fraction (11, 25))
+        self.assertEqual(44.0, answer)
+        __, answer = fraction_as_percentage (Fraction (13, 25))
+        self.assertEqual(52.0, answer)
+
 
 
 

From 0e57d1b62fce206b1b9b5c5ebad4d0dd9a694c1a Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Fri, 29 Jan 2016 10:59:39 +0530
Subject: [PATCH 14/39] README update

---
 class05/math/README.md   | 5 +++--
 class05/math/decimals.py | 6 +++++-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/class05/math/README.md b/class05/math/README.md
index 50bcf83..c72e063 100644
--- a/class05/math/README.md
+++ b/class05/math/README.md
@@ -1,9 +1,10 @@
 # Math Practice Test Generator
 
-The python files generate math related practice tests.  They are
+The python files generate math related practice tests for use at home or in the class room.  They are
 geared towards class 5 students in the CBSE system.
 
 The practice tests pertain to:
 * Practice Mathematics learned in class IV
 * Factors, Multiples, LCM, HCF
-* Work on fractions in in progress. TO DO: Multiplication, division, word problems, ...
\ No newline at end of file
+* Fractions (Simplification, Sorting, Addition, Subtraction, Multiplication, Division,...)
+* Decimals (Addition, Subtraction, Multiplication, Division, Percentages, ...)
\ No newline at end of file
diff --git a/class05/math/decimals.py b/class05/math/decimals.py
index bb714f3..2e29044 100644
--- a/class05/math/decimals.py
+++ b/class05/math/decimals.py
@@ -196,7 +196,11 @@ def fraction_as_percentage (number = Fraction ()):
         possible_denominators = [2, 5, 10, 20, 25, 50]
         selection = random.randint (0, len (possible_denominators)-1)
         denominator = possible_denominators[selection]
-        number = Fraction(random.randint (2, 15), denominator)
+        numerator = random.randint(2, 15)
+        while (numerator == denominator):
+            numerator = random.randint (2, 15)
+        number = Fraction(numerator, denominator)
+        logging.info ("{} {} {}".format (selection, denominator, printable_fraction_from_fraction(number)))
     question = "Express fraction {} as a percentage.".format (printable_fraction_from_fraction(number))
     original_precision = decimal.getcontext().prec
     decimal.getcontext().prec = 2

From b0360c23be87d8d9f1488f70b06172b32f61c121 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Fri, 29 Jan 2016 14:07:01 +0530
Subject: [PATCH 15/39] % sign in results

---
 class05/math/decimals.py            | 3 ++-
 class05/math/tests/test_decimals.py | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/class05/math/decimals.py b/class05/math/decimals.py
index 2e29044..31369df 100644
--- a/class05/math/decimals.py
+++ b/class05/math/decimals.py
@@ -197,7 +197,7 @@ def fraction_as_percentage (number = Fraction ()):
         selection = random.randint (0, len (possible_denominators)-1)
         denominator = possible_denominators[selection]
         numerator = random.randint(2, 15)
-        while (numerator == denominator):
+        while (numerator == denominator and numerator % denominator != 0):
             numerator = random.randint (2, 15)
         number = Fraction(numerator, denominator)
         logging.info ("{} {} {}".format (selection, denominator, printable_fraction_from_fraction(number)))
@@ -205,6 +205,7 @@ def fraction_as_percentage (number = Fraction ()):
     original_precision = decimal.getcontext().prec
     decimal.getcontext().prec = 2
     answer = number.numerator * 100/number.denominator
+    answer = "{} %".format (answer)
     decimal.getcontext().prec = original_precision
     return (question, answer)
 
diff --git a/class05/math/tests/test_decimals.py b/class05/math/tests/test_decimals.py
index 813389f..cb4ed16 100644
--- a/class05/math/tests/test_decimals.py
+++ b/class05/math/tests/test_decimals.py
@@ -74,9 +74,9 @@ def test_decimal_as_percentage (self):
 
     def test_fraction_as_percentage (self):
         __, answer = fraction_as_percentage (Fraction (11, 25))
-        self.assertEqual(44.0, answer)
+        self.assertEqual(str(44.0) + " %", answer)
         __, answer = fraction_as_percentage (Fraction (13, 25))
-        self.assertEqual(52.0, answer)
+        self.assertEqual(str (52.0) + " %", answer)
 
 
 

From 2b8efe3be7b21c3cb02bbf82bb31b0983bf11668 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sat, 30 Jan 2016 19:01:25 +0530
Subject: [PATCH 16/39] unit test case

---
 class05/math/tests/test_decimals.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/class05/math/tests/test_decimals.py b/class05/math/tests/test_decimals.py
index cb4ed16..0c297df 100644
--- a/class05/math/tests/test_decimals.py
+++ b/class05/math/tests/test_decimals.py
@@ -63,6 +63,8 @@ def test_decimals_integers_division (self):
     def test_integers_decimals_division (self):
         __, answer = integers_decimals_division (81, decimal.Decimal('0.4'))
         self.assertEqual(decimal.Decimal('202.5'), answer)
+        __, answer = integers_decimals_division (171, decimal.Decimal('1.9'))
+        self.assertEqual(decimal.Decimal('90'), answer)
 
     def test_percentage_of_whole_numbers (self):
         __, answer = percentage_of_whole_numbers (70, 55)

From c1ab2e2409f5ce7f3237f68d5f6ab14f7768029c Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sun, 31 Jan 2016 19:18:46 +0530
Subject: [PATCH 17/39] money and test_money commit

---
 class05/math/money.py            | 105 +++++++++++++++++++++++++++++++
 class05/math/tests/test_money.py |  28 +++++++++
 2 files changed, 133 insertions(+)
 create mode 100644 class05/math/money.py
 create mode 100644 class05/math/tests/test_money.py

diff --git a/class05/math/money.py b/class05/math/money.py
new file mode 100644
index 0000000..b64ea93
--- /dev/null
+++ b/class05/math/money.py
@@ -0,0 +1,105 @@
+__author__ = 'Ajay'
+
+'''Generates questions on money'''
+'''Usage: python <this_file.py> > test.html''' #test.html can be opened in  a browser to view the fraction problems
+''' Output: Generates a html file, with the questions and answers'''
+# references : https://docs.python.org/2/library/decimal.html
+#              https://docs.python.org/2/library/fractions.html
+#              http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference
+
+import random
+import logging
+import uuid
+# from fractions import Fraction
+from fractions import Fraction
+import decimal
+from fraction import printable_fraction, printable_fraction_from_fraction
+
+questions = []
+answers = []
+
+style = r'<style>body{font-size:16;font-family:Verdana;}</style>'
+html_pre_context = r'<html> <head> <title> Home Work Problems - Money </title>' + r'<script type="text/x-mathjax-config">MathJax.Hub.Config({' + \
+  r'tex2jax: {' + r"inlineMath: [ ['$','$'], ['\\(','\\)'] ]" + \
+  r'}' + r'})'+ r'</script><script type="text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" ></script> ' +\
+  style + r'</head > <body> '
+html_post_content = r'</body></html>'
+
+names = ['Rahul', 'Gaurav', 'Rama', 'Utkarsh', 'Govind', 'Akash', 'Anand']
+items = ['soap', 'chocolate', 'ice-cream', 'pant', 'eraser', 'orange']
+
+def __get_name ():
+    i = random.randint(0, len(names)-1)
+    return names[i]
+
+def __get_item ():
+    return items[random.randint(0, len(items)-1)]
+
+'''returns soaps, if soap is provided to it, ie, returns the plural form'''
+def __get_plural (item:str):
+    if item:
+        return "{}s".format (item)
+
+def purchase_costs_input_costs_selling_price (cost_price=0, input_costs=0, selling_price=0):
+    if not cost_price or not input_costs or not selling_price:
+        cost_price = random.randint (4000, 5000)
+        input_costs = random.randint (500, 900)
+        selling_price = cost_price + input_costs + random.randint (-500, 1500)
+    answer = selling_price - (cost_price + input_costs)
+    item = __get_plural(__get_item())
+    question = "Some quantity of {} was bought for Rs {}. Rs {} was spent on transportation. The items were sold for Rs {}.  What was the profit or loss?  Indicate if it was a profit or loss."\
+                 .format (item, cost_price, input_costs, selling_price)
+    return (question, answer)
+
+def cost_input_loss (cost_price=0, input_costs=0, loss=0):
+    if cost_price == 0 or input_costs ==0 or loss ==0:
+        cost_price = random.randint (800,850)
+        input_costs = random.randint (100, 150)
+        loss = random.randint (200, 300)
+    answer = cost_price + input_costs - loss
+    question = "{} were bought for Rs {}. Packing charges were Rs {}. Loss incurred was Rs {}. What was the selling price?".format (__get_plural(__get_item()), \
+                                        cost_price, input_costs, loss)
+    return (question, answer)
+
+def selling_price_profit (selling_price=0, profit = 0):
+    if selling_price == 0 or profit ==0:
+        selling_price = random.randint (8000, 11000)
+        profit = random.randint (800, 1100)
+    answer = selling_price - profit
+    question = "A set of {items} was sold for Rs {sp} at a profit of Rs {profit}.  What was its cost price?".format (items=__get_plural(__get_item()), sp=selling_price, profit=profit)
+    return  (question, answer)
+
+
+functions = [purchase_costs_input_costs_selling_price, cost_input_loss, selling_price_profit]
+
+
+def main():
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y%m%d %I:%M:%S %p',
+                        filename='class.log', level=logging.INFO)
+    unique_id = uuid.uuid1(1)
+
+    for i in range(0, len(functions)):
+        logging.info('Function : %s' % functions[i])
+        f = functions[i]
+        question, answer = f()
+        questions.append(question)
+        answers.append(answer)
+    html_text = "<h1>Decimals & Percentages</h1>\n"
+    html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (questions[i])
+        html_text += html
+    html_text += r'</ol>'
+    html_text += r'<br/><hr>'
+    html_text += "<h2>Answer Key: {}</h2>\n".format(str(unique_id)[:8])
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (answers[i])
+        html_text += html
+    html_text += r'</ol>'
+    print ("{} {} {}".format(html_pre_context, html_text, html_post_content))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/class05/math/tests/test_money.py b/class05/math/tests/test_money.py
new file mode 100644
index 0000000..c1fa144
--- /dev/null
+++ b/class05/math/tests/test_money.py
@@ -0,0 +1,28 @@
+# ..\tests>python test_fraction.py
+
+import unittest
+from unittest import TestCase
+__author__ = 'Ajay'
+import sys
+from decimal import ROUND_HALF_UP, Decimal
+
+sys.path.append('..\\')
+from money import *
+
+
+class TestDecimals(TestCase):
+
+    def test_purchase_costs_input_costs_selling_price(self):
+        question, answer = purchase_costs_input_costs_selling_price (4864, 964, 7398)
+        self.assertEqual(1570, answer)
+
+    def test_cost_input_loss (self):
+        question, answer = cost_input_loss (840, 160, 150)
+        self.assertEqual(850, answer)
+
+    def test_selling_price_profit (self):
+        q, a = selling_price_profit (9104, 1051)
+        self.assertEqual(8053, a)
+
+if __name__ == '__main__':
+    unittest.main()

From cba5e875910d6fc544548ef3932fa11af6fc4b06 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sun, 31 Jan 2016 20:34:26 +0530
Subject: [PATCH 18/39] more functions

---
 class05/math/money.py            | 34 +++++++++++++++++++++++++++++++-
 class05/math/tests/test_money.py | 17 +++++++++++++++-
 2 files changed, 49 insertions(+), 2 deletions(-)

diff --git a/class05/math/money.py b/class05/math/money.py
index b64ea93..90bf07e 100644
--- a/class05/math/money.py
+++ b/class05/math/money.py
@@ -69,8 +69,40 @@ def selling_price_profit (selling_price=0, profit = 0):
     question = "A set of {items} was sold for Rs {sp} at a profit of Rs {profit}.  What was its cost price?".format (items=__get_plural(__get_item()), sp=selling_price, profit=profit)
     return  (question, answer)
 
+def bulk_purchase_with_unit_loss (bulk_purchase_price = 0, units = 0, unit_loss = 0):
+    if bulk_purchase_price == 0 or units == 0 or unit_loss == 0:
+        units = random.randint (31, 55)
+        bulk_purchase_price = units * random.randint (31, 55)
+        unit_loss = random.randint (5, 11)
+    answer = bulk_purchase_price - unit_loss * units
+    question = "A wholesaler purchases {} kg of sugar for Rs {} and sells each kilogram of sugar at a loss of Rs {}. Calculate the amount, he would get at the end of the sale."\
+               .format (units, bulk_purchase_price, unit_loss)
+    return (question, answer)
+
+def bulk_purchase_with_unit_profit (bulk_purchase_price = 0, units = 0, unit_profit = 0):
+    if bulk_purchase_price == 0 or units == 0 or unit_profit == 0:
+        units = random.randint (31, 55)
+        bulk_purchase_price = units * random.randint (31, 55)
+        unit_profit = random.randint (5, 11)
+    answer = bulk_purchase_price + unit_profit * units
+    question = "A wholesaler purchases {} kg of sugar for Rs {} and sells each kilogram of sugar at a profit of Rs {}. Calculate the amount, he would get at the end of the sale."\
+               .format (units, bulk_purchase_price, unit_profit)
+    return (question, answer)
+
+def unit_profit_on_bulk_sale (bulk_purchase_price=0, bulk_sale_price = 0, units = 0):
+    if (bulk_purchase_price == 0 or bulk_sale_price == 0 or units == 0):
+        units = random.randint (12, 19)
+        unit_cost_price = random.randint (6, 14)
+        unit_sale_price = unit_cost_price + random.randint (2,6)
+        bulk_purchase_price = unit_cost_price * units
+        bulk_sale_price = unit_sale_price * units
+    answer = (bulk_sale_price - bulk_purchase_price)/units
+    question = "{} units of {} were bought for Rs {} and sold for Rs {}.   Find the profit or loss per unit?".format (units, __get_plural(__get_item()), bulk_purchase_price, bulk_sale_price)
+    return (question, answer)
+
 
-functions = [purchase_costs_input_costs_selling_price, cost_input_loss, selling_price_profit]
+functions = [purchase_costs_input_costs_selling_price, cost_input_loss, selling_price_profit, bulk_purchase_with_unit_loss, bulk_purchase_with_unit_profit, \
+             unit_profit_on_bulk_sale]
 
 
 def main():
diff --git a/class05/math/tests/test_money.py b/class05/math/tests/test_money.py
index c1fa144..d2275b1 100644
--- a/class05/math/tests/test_money.py
+++ b/class05/math/tests/test_money.py
@@ -10,7 +10,7 @@
 from money import *
 
 
-class TestDecimals(TestCase):
+class TestMoney(TestCase):
 
     def test_purchase_costs_input_costs_selling_price(self):
         question, answer = purchase_costs_input_costs_selling_price (4864, 964, 7398)
@@ -24,5 +24,20 @@ def test_selling_price_profit (self):
         q, a = selling_price_profit (9104, 1051)
         self.assertEqual(8053, a)
 
+    def test_bulk_purchase_with_unit_loss (self):
+        q, a = bulk_purchase_with_unit_loss (1344, 48, 2)
+        self.assertEqual(1248, a)
+        q, a = bulk_purchase_with_unit_loss (1295, 37, 9)
+        self.assertEqual(962, a)
+
+    def test_bulk_purchase_with_unit_profit (self):
+        q, a = bulk_purchase_with_unit_profit (1872, 36, 11)
+        self.assertEqual(2268, a)
+
+    def test_unit_profit_on_bulk_sale (self):
+        q, a = unit_profit_on_bulk_sale (162, 216, 18)
+        self.assertEqual(3.0, a)
+
+
 if __name__ == '__main__':
     unittest.main()

From 2436b47c6eba865275a85e7a041c5b0b8092e773 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sun, 31 Jan 2016 20:38:10 +0530
Subject: [PATCH 19/39] Revert "more functions"

This reverts commit cba5e875910d6fc544548ef3932fa11af6fc4b06.
---
 class05/math/money.py            | 34 +-------------------------------
 class05/math/tests/test_money.py | 17 +---------------
 2 files changed, 2 insertions(+), 49 deletions(-)

diff --git a/class05/math/money.py b/class05/math/money.py
index 90bf07e..b64ea93 100644
--- a/class05/math/money.py
+++ b/class05/math/money.py
@@ -69,40 +69,8 @@ def selling_price_profit (selling_price=0, profit = 0):
     question = "A set of {items} was sold for Rs {sp} at a profit of Rs {profit}.  What was its cost price?".format (items=__get_plural(__get_item()), sp=selling_price, profit=profit)
     return  (question, answer)
 
-def bulk_purchase_with_unit_loss (bulk_purchase_price = 0, units = 0, unit_loss = 0):
-    if bulk_purchase_price == 0 or units == 0 or unit_loss == 0:
-        units = random.randint (31, 55)
-        bulk_purchase_price = units * random.randint (31, 55)
-        unit_loss = random.randint (5, 11)
-    answer = bulk_purchase_price - unit_loss * units
-    question = "A wholesaler purchases {} kg of sugar for Rs {} and sells each kilogram of sugar at a loss of Rs {}. Calculate the amount, he would get at the end of the sale."\
-               .format (units, bulk_purchase_price, unit_loss)
-    return (question, answer)
-
-def bulk_purchase_with_unit_profit (bulk_purchase_price = 0, units = 0, unit_profit = 0):
-    if bulk_purchase_price == 0 or units == 0 or unit_profit == 0:
-        units = random.randint (31, 55)
-        bulk_purchase_price = units * random.randint (31, 55)
-        unit_profit = random.randint (5, 11)
-    answer = bulk_purchase_price + unit_profit * units
-    question = "A wholesaler purchases {} kg of sugar for Rs {} and sells each kilogram of sugar at a profit of Rs {}. Calculate the amount, he would get at the end of the sale."\
-               .format (units, bulk_purchase_price, unit_profit)
-    return (question, answer)
-
-def unit_profit_on_bulk_sale (bulk_purchase_price=0, bulk_sale_price = 0, units = 0):
-    if (bulk_purchase_price == 0 or bulk_sale_price == 0 or units == 0):
-        units = random.randint (12, 19)
-        unit_cost_price = random.randint (6, 14)
-        unit_sale_price = unit_cost_price + random.randint (2,6)
-        bulk_purchase_price = unit_cost_price * units
-        bulk_sale_price = unit_sale_price * units
-    answer = (bulk_sale_price - bulk_purchase_price)/units
-    question = "{} units of {} were bought for Rs {} and sold for Rs {}.   Find the profit or loss per unit?".format (units, __get_plural(__get_item()), bulk_purchase_price, bulk_sale_price)
-    return (question, answer)
-
 
-functions = [purchase_costs_input_costs_selling_price, cost_input_loss, selling_price_profit, bulk_purchase_with_unit_loss, bulk_purchase_with_unit_profit, \
-             unit_profit_on_bulk_sale]
+functions = [purchase_costs_input_costs_selling_price, cost_input_loss, selling_price_profit]
 
 
 def main():
diff --git a/class05/math/tests/test_money.py b/class05/math/tests/test_money.py
index d2275b1..c1fa144 100644
--- a/class05/math/tests/test_money.py
+++ b/class05/math/tests/test_money.py
@@ -10,7 +10,7 @@
 from money import *
 
 
-class TestMoney(TestCase):
+class TestDecimals(TestCase):
 
     def test_purchase_costs_input_costs_selling_price(self):
         question, answer = purchase_costs_input_costs_selling_price (4864, 964, 7398)
@@ -24,20 +24,5 @@ def test_selling_price_profit (self):
         q, a = selling_price_profit (9104, 1051)
         self.assertEqual(8053, a)
 
-    def test_bulk_purchase_with_unit_loss (self):
-        q, a = bulk_purchase_with_unit_loss (1344, 48, 2)
-        self.assertEqual(1248, a)
-        q, a = bulk_purchase_with_unit_loss (1295, 37, 9)
-        self.assertEqual(962, a)
-
-    def test_bulk_purchase_with_unit_profit (self):
-        q, a = bulk_purchase_with_unit_profit (1872, 36, 11)
-        self.assertEqual(2268, a)
-
-    def test_unit_profit_on_bulk_sale (self):
-        q, a = unit_profit_on_bulk_sale (162, 216, 18)
-        self.assertEqual(3.0, a)
-
-
 if __name__ == '__main__':
     unittest.main()

From 31cdae8e339e394f78b4915e3563b8c160e2e0c6 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sun, 31 Jan 2016 22:41:48 +0530
Subject: [PATCH 20/39] Recommit money.py and test_money.py

---
 class05/math/money.py            | 34 +++++++++++++++++++++++++++++++-
 class05/math/tests/test_money.py | 17 +++++++++++++++-
 2 files changed, 49 insertions(+), 2 deletions(-)

diff --git a/class05/math/money.py b/class05/math/money.py
index b64ea93..90bf07e 100644
--- a/class05/math/money.py
+++ b/class05/math/money.py
@@ -69,8 +69,40 @@ def selling_price_profit (selling_price=0, profit = 0):
     question = "A set of {items} was sold for Rs {sp} at a profit of Rs {profit}.  What was its cost price?".format (items=__get_plural(__get_item()), sp=selling_price, profit=profit)
     return  (question, answer)
 
+def bulk_purchase_with_unit_loss (bulk_purchase_price = 0, units = 0, unit_loss = 0):
+    if bulk_purchase_price == 0 or units == 0 or unit_loss == 0:
+        units = random.randint (31, 55)
+        bulk_purchase_price = units * random.randint (31, 55)
+        unit_loss = random.randint (5, 11)
+    answer = bulk_purchase_price - unit_loss * units
+    question = "A wholesaler purchases {} kg of sugar for Rs {} and sells each kilogram of sugar at a loss of Rs {}. Calculate the amount, he would get at the end of the sale."\
+               .format (units, bulk_purchase_price, unit_loss)
+    return (question, answer)
+
+def bulk_purchase_with_unit_profit (bulk_purchase_price = 0, units = 0, unit_profit = 0):
+    if bulk_purchase_price == 0 or units == 0 or unit_profit == 0:
+        units = random.randint (31, 55)
+        bulk_purchase_price = units * random.randint (31, 55)
+        unit_profit = random.randint (5, 11)
+    answer = bulk_purchase_price + unit_profit * units
+    question = "A wholesaler purchases {} kg of sugar for Rs {} and sells each kilogram of sugar at a profit of Rs {}. Calculate the amount, he would get at the end of the sale."\
+               .format (units, bulk_purchase_price, unit_profit)
+    return (question, answer)
+
+def unit_profit_on_bulk_sale (bulk_purchase_price=0, bulk_sale_price = 0, units = 0):
+    if (bulk_purchase_price == 0 or bulk_sale_price == 0 or units == 0):
+        units = random.randint (12, 19)
+        unit_cost_price = random.randint (6, 14)
+        unit_sale_price = unit_cost_price + random.randint (2,6)
+        bulk_purchase_price = unit_cost_price * units
+        bulk_sale_price = unit_sale_price * units
+    answer = (bulk_sale_price - bulk_purchase_price)/units
+    question = "{} units of {} were bought for Rs {} and sold for Rs {}.   Find the profit or loss per unit?".format (units, __get_plural(__get_item()), bulk_purchase_price, bulk_sale_price)
+    return (question, answer)
+
 
-functions = [purchase_costs_input_costs_selling_price, cost_input_loss, selling_price_profit]
+functions = [purchase_costs_input_costs_selling_price, cost_input_loss, selling_price_profit, bulk_purchase_with_unit_loss, bulk_purchase_with_unit_profit, \
+             unit_profit_on_bulk_sale]
 
 
 def main():
diff --git a/class05/math/tests/test_money.py b/class05/math/tests/test_money.py
index c1fa144..d2275b1 100644
--- a/class05/math/tests/test_money.py
+++ b/class05/math/tests/test_money.py
@@ -10,7 +10,7 @@
 from money import *
 
 
-class TestDecimals(TestCase):
+class TestMoney(TestCase):
 
     def test_purchase_costs_input_costs_selling_price(self):
         question, answer = purchase_costs_input_costs_selling_price (4864, 964, 7398)
@@ -24,5 +24,20 @@ def test_selling_price_profit (self):
         q, a = selling_price_profit (9104, 1051)
         self.assertEqual(8053, a)
 
+    def test_bulk_purchase_with_unit_loss (self):
+        q, a = bulk_purchase_with_unit_loss (1344, 48, 2)
+        self.assertEqual(1248, a)
+        q, a = bulk_purchase_with_unit_loss (1295, 37, 9)
+        self.assertEqual(962, a)
+
+    def test_bulk_purchase_with_unit_profit (self):
+        q, a = bulk_purchase_with_unit_profit (1872, 36, 11)
+        self.assertEqual(2268, a)
+
+    def test_unit_profit_on_bulk_sale (self):
+        q, a = unit_profit_on_bulk_sale (162, 216, 18)
+        self.assertEqual(3.0, a)
+
+
 if __name__ == '__main__':
     unittest.main()

From ae8e059fdba5d4e0da5cdba0a95f497b1cdb8572 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Mon, 1 Feb 2016 17:08:04 +0530
Subject: [PATCH 21/39] print date

---
 class05/math/money.py            | 23 +++++++++++++++++++++--
 class05/math/tests/test_money.py |  4 ++++
 2 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/class05/math/money.py b/class05/math/money.py
index 90bf07e..a3863c4 100644
--- a/class05/math/money.py
+++ b/class05/math/money.py
@@ -14,6 +14,7 @@
 from fractions import Fraction
 import decimal
 from fraction import printable_fraction, printable_fraction_from_fraction
+import datetime
 
 questions = []
 answers = []
@@ -23,6 +24,11 @@
   r'tex2jax: {' + r"inlineMath: [ ['$','$'], ['\\(','\\)'] ]" + \
   r'}' + r'})'+ r'</script><script type="text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" ></script> ' +\
   style + r'</head > <body> '
+today = datetime.date.today()
+today = today.strftime("%B %d, %Y")
+
+
+
 html_post_content = r'</body></html>'
 
 names = ['Rahul', 'Gaurav', 'Rama', 'Utkarsh', 'Govind', 'Akash', 'Anand']
@@ -100,9 +106,21 @@ def unit_profit_on_bulk_sale (bulk_purchase_price=0, bulk_sale_price = 0, units
     question = "{} units of {} were bought for Rs {} and sold for Rs {}.   Find the profit or loss per unit?".format (units, __get_plural(__get_item()), bulk_purchase_price, bulk_sale_price)
     return (question, answer)
 
+def aggregate_cost_on_unit_sale (unit_sale_price = 0, unit_profit = 0, units = 0):
+    if unit_sale_price == 0 or unit_profit == 0 or units == 0:
+        units = random.randint (12,19)
+        unit_profit = random.randint (4, 9)
+        unit_sale_price = unit_profit + random.randint (21,29)
+    item = __get_item()
+    unit_cost_price = unit_sale_price - unit_profit
+    aggregate_cost = unit_cost_price * units
+    question = "{units}  {items} were sold for Rs {unit_sale_price} each at a profit of Rs {unit_profit} per item. What was the total cost price for these {items}?"\
+                .format (units=units, items = __get_plural(item), unit_sale_price=unit_sale_price, unit_profit=unit_profit)
+    return (question, aggregate_cost)
+
 
 functions = [purchase_costs_input_costs_selling_price, cost_input_loss, selling_price_profit, bulk_purchase_with_unit_loss, bulk_purchase_with_unit_profit, \
-             unit_profit_on_bulk_sale]
+             unit_profit_on_bulk_sale, aggregate_cost_on_unit_sale]
 
 
 def main():
@@ -116,7 +134,8 @@ def main():
         question, answer = f()
         questions.append(question)
         answers.append(answer)
-    html_text = "<h1>Decimals & Percentages</h1>\n"
+    html_text = "<h1>Money</h1>\n"
+    html_text += today
     html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
     html_text += r'<ol>'
     for i in range(0, len(questions)):
diff --git a/class05/math/tests/test_money.py b/class05/math/tests/test_money.py
index d2275b1..88b328b 100644
--- a/class05/math/tests/test_money.py
+++ b/class05/math/tests/test_money.py
@@ -38,6 +38,10 @@ def test_unit_profit_on_bulk_sale (self):
         q, a = unit_profit_on_bulk_sale (162, 216, 18)
         self.assertEqual(3.0, a)
 
+    def test_aggregate_cost_on_unit_sale (self):
+        q, a = aggregate_cost_on_unit_sale (35, 7, 15)
+        self.assertEqual(420, a)
+
 
 if __name__ == '__main__':
     unittest.main()

From f5066b5d70910eb69aed6844062f20fa8ed1107c Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sat, 6 Feb 2016 14:27:32 +0530
Subject: [PATCH 22/39] temperature using lambda

---
 class05/math/money.py                  |  2 +-
 class05/math/temperature.py            | 98 ++++++++++++++++++++++++++
 class05/math/tests/test_temperature.py | 30 ++++++++
 3 files changed, 129 insertions(+), 1 deletion(-)
 create mode 100644 class05/math/temperature.py
 create mode 100644 class05/math/tests/test_temperature.py

diff --git a/class05/math/money.py b/class05/math/money.py
index a3863c4..b0c36f2 100644
--- a/class05/math/money.py
+++ b/class05/math/money.py
@@ -63,7 +63,7 @@ def cost_input_loss (cost_price=0, input_costs=0, loss=0):
         input_costs = random.randint (100, 150)
         loss = random.randint (200, 300)
     answer = cost_price + input_costs - loss
-    question = "{} were bought for Rs {}. Packing charges were Rs {}. Loss incurred was Rs {}. What was the selling price?".format (__get_plural(__get_item()), \
+    question = "{} were bought for Rs {}. Packing charges were Rs {}. Loss incurred was Rs {}. What was the selling price?".format (__get_plural(__get_item()).title(), \
                                         cost_price, input_costs, loss)
     return (question, answer)
 
diff --git a/class05/math/temperature.py b/class05/math/temperature.py
new file mode 100644
index 0000000..d3b06e1
--- /dev/null
+++ b/class05/math/temperature.py
@@ -0,0 +1,98 @@
+__author__ = 'Ajay'
+
+'''Generates questions on money'''
+'''Usage: python <this_file.py> > test.html''' #test.html can be opened in  a browser to view the fraction problems
+''' Output: Generates a html file, with the questions and answers'''
+# references : https://docs.python.org/2/library/decimal.html
+#              https://docs.python.org/2/library/fractions.html
+#              http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference
+
+import random
+import logging
+import uuid
+import decimal
+from decimal import ROUND_UP
+from fraction import printable_fraction, printable_fraction_from_fraction
+import datetime
+
+chapter = r'Temperature'
+
+questions = []
+answers = []
+
+style = r'<style>body{font-size:16;font-family:Verdana;}</style>'
+html_pre_context = r'<html> <head> <title> Home Work Problems - {} </title>' + r'<script type="text/x-mathjax-config">MathJax.Hub.Config({' + \
+  r'tex2jax: {' + r"inlineMath: [ ['$','$'], ['\\(','\\)'] ]" + \
+  r'}' + r'})'+ r'</script><script type="text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" ></script> ' +\
+  style + r'</head > <body> '.format (chapter)
+today = datetime.date.today()
+today = today.strftime("%B %d, %Y")
+
+
+
+html_post_content = r'</body></html>'
+
+
+def __get_random_temperature_in_fahrenheit ():
+    return random.randint (32, 212)
+
+def __get_random_temperature_in_celsius ():
+    return random.randint (1, 100)
+
+celsius = lambda fahrenheit : (fahrenheit - 32) * 5/9
+
+fahrenheit = lambda celsius: (9/5)* celsius + 32
+
+def celsius_from_fahrenheit (temperature = None ):
+    if temperature == None:
+        temperature = __get_random_temperature_in_fahrenheit()
+    answer = "{}{}C".format (round (celsius (temperature), 1), u'\N{DEGREE SIGN}')
+    question = "Convert {}{}F into Celsius.".format(temperature, u'\N{DEGREE SIGN}')
+    return (question, answer)
+
+def fahrenheit_from_celsius (temperature = None):
+    if temperature == None:
+        temperature = __get_random_temperature_in_celsius()
+    answer = "{}{}F".format (round (fahrenheit (temperature), 1), u'\N{DEGREE SIGN}')
+    question = "Convert {}{}C into Fahrenheit.".format(temperature, u'\N{DEGREE SIGN}')
+    return (question, answer)
+
+
+
+
+
+functions = [celsius_from_fahrenheit, fahrenheit_from_celsius]
+
+
+def main():
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y%m%d %I:%M:%S %p',
+                        filename='class.log', level=logging.INFO)
+    unique_id = uuid.uuid1(1)
+
+    for i in range (0, 10):
+        for i in range(0, len(functions)):
+            logging.info('Function : %s' % functions[i])
+            f = functions[i]
+            question, answer = f()
+            questions.append(question)
+            answers.append(answer)
+    html_text = "<h1>{}</h1>\n".format(chapter)
+    html_text += today
+    html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (questions[i])
+        html_text += html
+    html_text += r'</ol>'
+    html_text += r'<br/><hr>'
+    html_text += "<h2>Answer Key: {}</h2>\n".format(str(unique_id)[:8])
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (answers[i])
+        html_text += html
+    html_text += r'</ol>'
+    print ("{} {} {}".format(html_pre_context, html_text, html_post_content))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/class05/math/tests/test_temperature.py b/class05/math/tests/test_temperature.py
new file mode 100644
index 0000000..290f0c5
--- /dev/null
+++ b/class05/math/tests/test_temperature.py
@@ -0,0 +1,30 @@
+# ..\tests>python test_fraction.py
+
+import unittest
+from unittest import TestCase
+__author__ = 'Ajay'
+import sys
+from decimal import ROUND_HALF_UP, Decimal
+
+sys.path.append('..\\')
+from temperature import *
+
+
+class TestTemperature(TestCase):
+
+    def test_celsius_from_fahrenheit(self):
+        question, answer = celsius_from_fahrenheit (60)
+        self.assertEqual("{}{}C".format (15.6, u'\N{DEGREE SIGN}'), answer)
+        question, answer = celsius_from_fahrenheit (80)
+        self.assertEqual("{}{}C".format (26.7,u'\N{DEGREE SIGN}'), answer)
+
+    def test_fahrenheit_from_celsius (self):
+        q, a = fahrenheit_from_celsius (60)
+        self.assertEqual("140.0{}F".format (u'\N{DEGREE SIGN}'), a)
+        q, a = fahrenheit_from_celsius (80)
+        self.assertEqual("176.0{}F".format (u'\N{DEGREE SIGN}'), a)
+
+
+
+if __name__ == '__main__':
+    unittest.main()

From 5b2ccdd5557bada6ef671b80c0dfa5db94c11c24 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sat, 6 Feb 2016 17:56:42 +0530
Subject: [PATCH 23/39] added degree sign in unicode, before F and C

---
 class05/math/temperature.py            | 3 ---
 class05/math/tests/test_temperature.py | 1 -
 2 files changed, 4 deletions(-)

diff --git a/class05/math/temperature.py b/class05/math/temperature.py
index d3b06e1..ec4a75b 100644
--- a/class05/math/temperature.py
+++ b/class05/math/temperature.py
@@ -10,9 +10,6 @@
 import random
 import logging
 import uuid
-import decimal
-from decimal import ROUND_UP
-from fraction import printable_fraction, printable_fraction_from_fraction
 import datetime
 
 chapter = r'Temperature'
diff --git a/class05/math/tests/test_temperature.py b/class05/math/tests/test_temperature.py
index 290f0c5..c88401a 100644
--- a/class05/math/tests/test_temperature.py
+++ b/class05/math/tests/test_temperature.py
@@ -4,7 +4,6 @@
 from unittest import TestCase
 __author__ = 'Ajay'
 import sys
-from decimal import ROUND_HALF_UP, Decimal
 
 sys.path.append('..\\')
 from temperature import *

From dbf17bf83675344d0fc35a458a6a8ff6704b74d5 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sat, 6 Feb 2016 19:20:49 +0530
Subject: [PATCH 24/39] integer BODMAS

---
 ...simplification_of_numerical_expressions.py | 151 ++++++++++++++++++
 ...simplification_of_numerical_expressions.py |  23 +++
 2 files changed, 174 insertions(+)
 create mode 100644 class05/math/simplification_of_numerical_expressions.py
 create mode 100644 class05/math/tests/test_simplification_of_numerical_expressions.py

diff --git a/class05/math/simplification_of_numerical_expressions.py b/class05/math/simplification_of_numerical_expressions.py
new file mode 100644
index 0000000..caa1285
--- /dev/null
+++ b/class05/math/simplification_of_numerical_expressions.py
@@ -0,0 +1,151 @@
+__author__ = 'Ajay'
+
+'''Generates questions on money'''
+'''Usage: python <this_file.py> > test.html''' #test.html can be opened in  a browser to view the fraction problems
+''' Output: Generates a html file, with the questions and answers'''
+# references : https://docs.python.org/2/library/decimal.html
+#              https://docs.python.org/2/library/fractions.html
+#              http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference
+
+import random
+import logging
+import uuid
+import datetime
+import factors
+import re
+#from factors import _is_prime
+
+chapter = r'Simplification of Numerical Expressions'
+
+questions = []
+answers = []
+
+style = r'<style>body{font-size:16;font-family:Verdana;}</style>'
+html_pre_context = r'<html> <head> <title> Home Work Problems - {} </title>' + r'<script type="text/x-mathjax-config">MathJax.Hub.Config({' + \
+  r'tex2jax: {' + r"inlineMath: [ ['$','$'], ['\\(','\\)'] ]" + \
+  r'}' + r'})'+ r'</script><script type="text/javascript" src = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" ></script> ' +\
+  style + r'</head > <body> '.format (chapter)
+today = datetime.date.today()
+today = today.strftime("%B %d, %Y")
+
+html_post_content = r'</body></html>'
+
+division_sign = u'\N{DIVISION SIGN}'
+multiplication_sign = u'\N{MULTIPLICATION SIGN}'
+
+def __generate_random_numbers (min=2, max=25):
+    return random.randint (min, max)
+
+def __generate_operations (num_operations = 4): #num_operations = number of arithmetic operators present in the equation
+    operations = ["+", "-", "*", "/"]
+    ops_list = [] #the list of operations to be performed and the order in which they are to be performed
+    for i in range (0, num_operations):
+        if i > 0:
+            if ops_list[i-1] == "/":   #eliminates consecutive divisions
+                ops_list.append (operations[random.randint(0, len(operations)-2)])
+            else:
+                ops_list.append (operations[random.randint(0, len(operations)-1)])
+        else:
+            ops_list.append (operations[random.randint(0, len(operations)-1)])
+    return ops_list
+
+def __printable_expression (expression:str): #replaces "/" and "*" by the appropriate mathematical signs, using unicode
+    expression = re.sub ("/", division_sign, expression)
+    expression = re.sub ("\*", multiplication_sign, expression)
+    return expression
+
+
+def __factors(number=0):
+    if number <= 0:
+        number = random.randint(50, 500)
+    factors = []
+    n = 1
+    while (n <= number):
+      if (number % n == 0):
+        factors.append(n)
+        # factors.append (number / n)
+      n += 1
+    return (factors[1:])  # for unit testing
+
+def __generate_expression (numbers_list, ops_list):
+    if numbers_list == None or len (numbers_list) == 0 or ops_list == None or len (ops_list) == 0:
+        logging.info ("Invalid parameters passed to function.")
+        return False
+    expression = ""
+    for i in range (0, len (numbers_list)):
+        expression += "{}".format (numbers_list[i])
+        if i <= len (numbers_list) -2:
+            expression += " {} ".format (ops_list[i])
+    return expression
+
+def bodmas_integers (expression = None, num_operations = 5):
+    numbers_list = []
+    if expression == None:
+        ops_list = __generate_operations(num_operations)
+        for i in range (0, num_operations + 1):
+            if i == 0:
+                numbers_list.append(__generate_random_numbers(50, 100))
+            else:
+                if ops_list[i-1] == "/":
+
+                    factor_list = __factors (numbers_list[i-1])
+                    logging.info ("i : {}, numbers_list : {}, factor_list: {}".format (i, numbers_list,factor_list))
+                    divisor = factor_list[random.randint(0, len(factor_list)-1)]
+                    numbers_list.append(divisor)
+                else:
+                    numbers_list.append(__generate_random_numbers())
+        #Both numbers and operators are available.  Construct the mathematical expression
+        expression = __generate_expression (numbers_list, ops_list)
+
+    answer = eval (expression)
+    question = __printable_expression(expression)
+    return (question, answer)
+
+
+
+def bodmas_fractions (expression = None):
+    pass
+
+def bodmas_mixed_fractions (expression = None):
+    pass
+
+def bodmas_decimals (expression = None):
+    pass
+
+
+
+functions = [bodmas_integers]
+
+
+def main():
+    logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y%m%d %I:%M:%S %p',
+                        filename='class.log', level=logging.INFO)
+    unique_id = uuid.uuid1(1)
+
+    for i in range (0, 10):
+        for i in range(0, len(functions)):
+            logging.info('Function : %s' % functions[i])
+            f = functions[i]
+            question, answer = f()
+            questions.append(question)
+            answers.append(answer)
+    html_text = "<h1>{}</h1>\n".format(chapter)
+    html_text += today
+    html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (questions[i])
+        html_text += html
+    html_text += r'</ol>'
+    html_text += r'<br/><hr>'
+    html_text += "<h2>Answer Key: {}</h2>\n".format(str(unique_id)[:8])
+    html_text += r'<ol>'
+    for i in range(0, len(questions)):
+        html = "    <li> {} </li>\n".format (answers[i])
+        html_text += html
+    html_text += r'</ol>'
+    print ("{} {} {}".format(html_pre_context, html_text, html_post_content))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/class05/math/tests/test_simplification_of_numerical_expressions.py b/class05/math/tests/test_simplification_of_numerical_expressions.py
new file mode 100644
index 0000000..5e1cdc1
--- /dev/null
+++ b/class05/math/tests/test_simplification_of_numerical_expressions.py
@@ -0,0 +1,23 @@
+# ..\tests>python test_fraction.py
+
+import unittest
+from unittest import TestCase
+__author__ = 'Ajay'
+import sys
+
+sys.path.append('..\\')
+from simplification_of_numerical_expressions import *
+
+
+class TestSimplification(TestCase):
+
+    def test_bodmas_integers(self):
+        question, answer = bodmas_integers ("72 + 22 / 22 * 5 + 6 + 13")
+        self.assertEqual(96.0, answer)
+        question, answer = bodmas_integers ("92 - 15 * 15 - 6 / 2 * 14")
+        self.assertEqual(-175, answer)
+
+
+
+if __name__ == '__main__':
+    unittest.main()

From f08b52ff1d24e222d49f33875caee6ba85192633 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sat, 6 Feb 2016 21:58:33 +0530
Subject: [PATCH 25/39] changed unicode to html encoding, to eliminate decoding
 errors in Windows shell

---
 ...simplification_of_numerical_expressions.py | 27 ++++++++++++-------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/class05/math/simplification_of_numerical_expressions.py b/class05/math/simplification_of_numerical_expressions.py
index caa1285..dc0edfa 100644
--- a/class05/math/simplification_of_numerical_expressions.py
+++ b/class05/math/simplification_of_numerical_expressions.py
@@ -11,9 +11,8 @@
 import logging
 import uuid
 import datetime
-import factors
 import re
-#from factors import _is_prime
+from factors import is_prime
 
 chapter = r'Simplification of Numerical Expressions'
 
@@ -30,11 +29,14 @@
 
 html_post_content = r'</body></html>'
 
-division_sign = u'\N{DIVISION SIGN}'
-multiplication_sign = u'\N{MULTIPLICATION SIGN}'
+division_sign = '&#247;'#u'\N{DIVISION SIGN}'
+multiplication_sign = '&times;'#u'\N{MULTIPLICATION SIGN}'
 
 def __generate_random_numbers (min=2, max=25):
-    return random.randint (min, max)
+    number =  random.randint (min, max)
+    while is_prime(number):
+        number = random.randint (min, max)
+    return number
 
 def __generate_operations (num_operations = 4): #num_operations = number of arithmetic operators present in the equation
     operations = ["+", "-", "*", "/"]
@@ -65,7 +67,7 @@ def __factors(number=0):
         factors.append(n)
         # factors.append (number / n)
       n += 1
-    return (factors[1:])  # for unit testing
+    return (factors[1:-1])  # for unit testing
 
 def __generate_expression (numbers_list, ops_list):
     if numbers_list == None or len (numbers_list) == 0 or ops_list == None or len (ops_list) == 0:
@@ -85,6 +87,9 @@ def bodmas_integers (expression = None, num_operations = 5):
         for i in range (0, num_operations + 1):
             if i == 0:
                 numbers_list.append(__generate_random_numbers(50, 100))
+            elif   i < len (ops_list) and  ops_list[i] == "/" and ops_list[i]:#ensures that there are no prime numbers before a / sign. Else the divisors are either the number or 1.
+                numbers_list.append( __generate_random_numbers(50, 200))
+                #logging.info (number)
             else:
                 if ops_list[i-1] == "/":
 
@@ -122,13 +127,17 @@ def main():
                         filename='class.log', level=logging.INFO)
     unique_id = uuid.uuid1(1)
 
-    for i in range (0, 10):
+    num_problems = 0
+    while num_problems < 10:
         for i in range(0, len(functions)):
             logging.info('Function : %s' % functions[i])
             f = functions[i]
             question, answer = f()
-            questions.append(question)
-            answers.append(answer)
+            if answer > 0 and answer < 5000:
+                questions.append(question)
+                answers.append(answer)
+                num_problems += 1
+
     html_text = "<h1>{}</h1>\n".format(chapter)
     html_text += today
     html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])

From 0994bc2ba5d47ff4519953cc0c8696fe8650292b Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sat, 6 Feb 2016 23:39:24 +0530
Subject: [PATCH 26/39] bodmas for fractions - work in progress - eval () does
 not work for fractions

---
 class05/math/fraction.py                      |  5 +-
 ...simplification_of_numerical_expressions.py | 66 +++++++++++++++----
 ...simplification_of_numerical_expressions.py |  7 ++
 3 files changed, 65 insertions(+), 13 deletions(-)

diff --git a/class05/math/fraction.py b/class05/math/fraction.py
index 24990f2..060c298 100644
--- a/class05/math/fraction.py
+++ b/class05/math/fraction.py
@@ -25,7 +25,10 @@
 
 '''Generates a fraction ranging from 1...9/1..9'''
 def __generate_fraction ():
-    return (Fraction(random.randint(1,9),random.randint(2,9) ))
+    f = Fraction(random.randint(1,9),random.randint(2,9) )
+    while f.denominator == 1: #eliminates fractions with a denominator of 1fr
+        f = Fraction(random.randint(1,9),random.randint(2,9) )
+    return f
 
 def __generate_mixed_fraction ():
     frac = __generate_fraction()
diff --git a/class05/math/simplification_of_numerical_expressions.py b/class05/math/simplification_of_numerical_expressions.py
index dc0edfa..e4e4065 100644
--- a/class05/math/simplification_of_numerical_expressions.py
+++ b/class05/math/simplification_of_numerical_expressions.py
@@ -13,6 +13,8 @@
 import datetime
 import re
 from factors import is_prime
+from decimals import *
+from fraction import __generate_fraction
 
 chapter = r'Simplification of Numerical Expressions'
 
@@ -32,7 +34,7 @@
 division_sign = '&#247;'#u'\N{DIVISION SIGN}'
 multiplication_sign = '&times;'#u'\N{MULTIPLICATION SIGN}'
 
-def __generate_random_numbers (min=2, max=25):
+def __generate_random_number (min=2, max=25):
     number =  random.randint (min, max)
     while is_prime(number):
         number = random.randint (min, max)
@@ -86,10 +88,10 @@ def bodmas_integers (expression = None, num_operations = 5):
         ops_list = __generate_operations(num_operations)
         for i in range (0, num_operations + 1):
             if i == 0:
-                numbers_list.append(__generate_random_numbers(50, 100))
+                numbers_list.append(__generate_random_number(50, 100))
             elif   i < len (ops_list) and  ops_list[i] == "/" and ops_list[i]:#ensures that there are no prime numbers before a / sign. Else the divisors are either the number or 1.
-                numbers_list.append( __generate_random_numbers(50, 200))
-                #logging.info (number)
+                numbers_list.append( __generate_random_number(50, 200))
+
             else:
                 if ops_list[i-1] == "/":
 
@@ -98,28 +100,68 @@ def bodmas_integers (expression = None, num_operations = 5):
                     divisor = factor_list[random.randint(0, len(factor_list)-1)]
                     numbers_list.append(divisor)
                 else:
-                    numbers_list.append(__generate_random_numbers())
+                    numbers_list.append(__generate_random_number())
         #Both numbers and operators are available.  Construct the mathematical expression
         expression = __generate_expression (numbers_list, ops_list)
-
     answer = eval (expression)
     question = __printable_expression(expression)
     return (question, answer)
 
 
 
-def bodmas_fractions (expression = None):
-    pass
+def bodmas_fractions (expression = None, num_operations = 4):#TODO: Fix this..  eval does not work.  A parser is required.
+    numbers_list = []
+
+    if expression == None:
+        ops_list = __generate_operations(num_operations)
+        for i in range (0, num_operations + 1):
+            if i == 0:
+                numbers_list.append(__generate_fraction ())
+            else:
+                numbers_list.append(__generate_fraction ())
+        #Both numbers and operators are available.  Construct the mathematical expression
+        expression = __generate_expression (numbers_list, ops_list)
+    answer = eval (expression)
+    question = expression
+    return (question, answer)
+
 
 def bodmas_mixed_fractions (expression = None):
     pass
 
-def bodmas_decimals (expression = None):
-    pass
+def bodmas_decimals (expression = None, num_operations = 4):
+    numbers_list = []
+    multiplier = 1
+    if expression == None:
+        ops_list = __generate_operations(num_operations)
+        for i in range (0, num_operations + 1):
+            if i == 0:
+                numbers_list.append(generate_decimal (2, 99))
+            elif   i < len (ops_list) and  ops_list[i] == "/" and ops_list[i]:#ensures that there are no prime numbers before a / sign. Else the divisors are either the number or 1.
+                multiplier = random.randint (5,9)
+                numbers_list.append(generate_decimal (2, 99) * multiplier)
+            else:
+                if ops_list[i-1] == "/":
+                    orig = decimal.getcontext().prec
+                    decimal.getcontext().prec = 3
+                    divisor = numbers_list[i-1]/multiplier
+                    decimal.getcontext().prec = orig
+                    numbers_list.append(divisor)
+                else:
+                    numbers_list.append(generate_decimal (0, 9))
+        #Both numbers and operators are available.  Construct the mathematical expression
+        expression = __generate_expression (numbers_list, ops_list)
+    orig = decimal.getcontext().prec
+    decimal.getcontext().prec = 3
+    answer = round (eval (expression), 3)
+    decimal.getcontext().prec = orig
+    question = __printable_expression(expression)
+    return (question, answer)
+
 
 
 
-functions = [bodmas_integers]
+functions = [bodmas_integers, bodmas_decimals] #, bodmas_fractions]
 
 
 def main():
@@ -128,7 +170,7 @@ def main():
     unique_id = uuid.uuid1(1)
 
     num_problems = 0
-    while num_problems < 10:
+    while num_problems < 20:
         for i in range(0, len(functions)):
             logging.info('Function : %s' % functions[i])
             f = functions[i]
diff --git a/class05/math/tests/test_simplification_of_numerical_expressions.py b/class05/math/tests/test_simplification_of_numerical_expressions.py
index 5e1cdc1..f84ef25 100644
--- a/class05/math/tests/test_simplification_of_numerical_expressions.py
+++ b/class05/math/tests/test_simplification_of_numerical_expressions.py
@@ -17,6 +17,13 @@ def test_bodmas_integers(self):
         question, answer = bodmas_integers ("92 - 15 * 15 - 6 / 2 * 14")
         self.assertEqual(-175, answer)
 
+    def test_bodmas_decimals (self):
+        question, answer = bodmas_decimals ("0.14 * 11.90 / 1.70 * 0.7 - 0.2")
+        self.assertEqual(0.486, answer)
+        question, answer = bodmas_decimals ("0.43 + 0.2 * 0.4 + 0.6 * 0.2")
+        self.assertEqual(0.63, answer)
+        question, answer = bodmas_decimals ("2.9 + 0.7 * 1.60 / 0.32 - 0.9")
+        self.assertEqual(5.5, answer)
 
 
 if __name__ == '__main__':

From fab1329c96c055268cfb4f3809a3d4ed26a52a85 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sun, 7 Feb 2016 18:29:31 +0530
Subject: [PATCH 27/39] fractions and mixed fractions - BODMAS operations

---
 class05/math/fraction.py                      |   2 +-
 ...simplification_of_numerical_expressions.py | 129 +++++++++++++-----
 ...simplification_of_numerical_expressions.py |   8 ++
 3 files changed, 104 insertions(+), 35 deletions(-)

diff --git a/class05/math/fraction.py b/class05/math/fraction.py
index 060c298..9ef328a 100644
--- a/class05/math/fraction.py
+++ b/class05/math/fraction.py
@@ -26,7 +26,7 @@
 '''Generates a fraction ranging from 1...9/1..9'''
 def __generate_fraction ():
     f = Fraction(random.randint(1,9),random.randint(2,9) )
-    while f.denominator == 1: #eliminates fractions with a denominator of 1fr
+    while f.denominator == 1: #eliminates fractions with a denominator of 1frfr
         f = Fraction(random.randint(1,9),random.randint(2,9) )
     return f
 
diff --git a/class05/math/simplification_of_numerical_expressions.py b/class05/math/simplification_of_numerical_expressions.py
index e4e4065..a0a493b 100644
--- a/class05/math/simplification_of_numerical_expressions.py
+++ b/class05/math/simplification_of_numerical_expressions.py
@@ -14,7 +14,8 @@
 import re
 from factors import is_prime
 from decimals import *
-from fraction import __generate_fraction
+from fraction import __generate_fraction,__generate_mixed_fraction, printable_fraction_from_fraction, printable_mixed_fraction
+from fractions import Fraction
 
 chapter = r'Simplification of Numerical Expressions'
 
@@ -53,11 +54,36 @@ def __generate_operations (num_operations = 4): #num_operations = number of arit
             ops_list.append (operations[random.randint(0, len(operations)-1)])
     return ops_list
 
+def __generate_expression (numbers_list, ops_list):
+    if numbers_list == None or len (numbers_list) == 0 or ops_list == None or len (ops_list) == 0:
+        logging.info ("Invalid parameters passed to function.")
+        return False
+    expression = ""
+    for i in range (0, len (numbers_list)):
+        expression += "{}".format (numbers_list[i])
+        if i <= len (numbers_list) -2:
+            expression += " {} ".format (ops_list[i])
+    return expression
+
 def __printable_expression (expression:str): #replaces "/" and "*" by the appropriate mathematical signs, using unicode
     expression = re.sub ("/", division_sign, expression)
     expression = re.sub ("\*", multiplication_sign, expression)
     return expression
 
+def __printable_expression_fractions (fraction_list, ops_list):
+    if fraction_list == None or len (fraction_list) == 0 or ops_list == None or len (ops_list) == 0:
+        logging.info ("Invalid parameters passed to function.")
+        return False
+    expression = ""
+    for i in range (0, len (fraction_list)):
+        if fraction_list[i].numerator > fraction_list[i].denominator:
+            expression += "{}".format (printable_mixed_fraction(fraction_list[i]))
+        else:
+            expression += "{}".format (printable_fraction_from_fraction(fraction_list[i]))
+        if i <= len (fraction_list) -2:
+            expression += " {} ".format (ops_list[i])
+    return expression
+
 
 def __factors(number=0):
     if number <= 0:
@@ -71,16 +97,7 @@ def __factors(number=0):
       n += 1
     return (factors[1:-1])  # for unit testing
 
-def __generate_expression (numbers_list, ops_list):
-    if numbers_list == None or len (numbers_list) == 0 or ops_list == None or len (ops_list) == 0:
-        logging.info ("Invalid parameters passed to function.")
-        return False
-    expression = ""
-    for i in range (0, len (numbers_list)):
-        expression += "{}".format (numbers_list[i])
-        if i <= len (numbers_list) -2:
-            expression += " {} ".format (ops_list[i])
-    return expression
+
 
 def bodmas_integers (expression = None, num_operations = 5):
     numbers_list = []
@@ -107,28 +124,6 @@ def bodmas_integers (expression = None, num_operations = 5):
     question = __printable_expression(expression)
     return (question, answer)
 
-
-
-def bodmas_fractions (expression = None, num_operations = 4):#TODO: Fix this..  eval does not work.  A parser is required.
-    numbers_list = []
-
-    if expression == None:
-        ops_list = __generate_operations(num_operations)
-        for i in range (0, num_operations + 1):
-            if i == 0:
-                numbers_list.append(__generate_fraction ())
-            else:
-                numbers_list.append(__generate_fraction ())
-        #Both numbers and operators are available.  Construct the mathematical expression
-        expression = __generate_expression (numbers_list, ops_list)
-    answer = eval (expression)
-    question = expression
-    return (question, answer)
-
-
-def bodmas_mixed_fractions (expression = None):
-    pass
-
 def bodmas_decimals (expression = None, num_operations = 4):
     numbers_list = []
     multiplier = 1
@@ -159,9 +154,71 @@ def bodmas_decimals (expression = None, num_operations = 4):
     return (question, answer)
 
 
+def bodmas_fractions (expression = None, num_operations = 4):#TODO: expression passed as input is ignored.  Add support for inputs, passed as strings
+    numbers_list = []
+    if expression == None:
+        ops_list = __generate_operations(num_operations)
+        for i in range (0, num_operations + 1):
+            numbers_list.append(__generate_fraction ())
+        #Both numbers and operators are available.  Construct the mathematical expression
+        expression = __printable_expression(__printable_expression_fractions (numbers_list, ops_list))
+    answer = bodmas_fractions_solver(numbers_list, ops_list)
+    question = expression
+    return (question, answer)
+
+'''This function is similar to the built-in eval, but this provides the answer for fractions
+This function is called by the bodmas_fractions function.
+'''
+def bodmas_fractions_solver (fraction_list, operations_list):
+    if not operations_list or not fraction_list or len (operations_list) == 0 or len (fraction_list) == 0 or \
+        len (operations_list) + 1 != len(fraction_list):
+        return False
+    ans = Fraction ()
+    #pass 1, solve division problems
+    while "/" in operations_list:
+        pos = operations_list.index ("/")
+        ans = fraction_list[pos] / fraction_list[pos+1]
+        fraction_list[pos] = ans
+        operations_list.remove("/")
+        fraction_list.remove(fraction_list[pos+1])
+    while "*" in operations_list: #pass 2, all multiplication operations are done
+        pos = operations_list.index ("*")
+        ans = fraction_list[pos] * fraction_list[pos+1]
+        fraction_list[pos] = ans
+        operations_list.remove("*")
+        fraction_list.remove(fraction_list[pos+1])
+    while "+" in operations_list: #pass 3 for addition operations
+        pos = operations_list.index ("+")
+        ans = fraction_list[pos] + fraction_list[pos+1]
+        fraction_list[pos] = ans
+        operations_list.remove("+")
+        fraction_list.remove(fraction_list[pos+1])
+    while "-" in operations_list: #pass 4 for subtraction
+        pos = operations_list.index ("-")
+        ans = fraction_list[pos] - fraction_list[pos+1]
+        fraction_list[pos] = ans
+        operations_list.remove("-")
+        fraction_list.remove(fraction_list[pos+1])
+    return ans
+
+
+
+def bodmas_mixed_fractions (num_operations = 4):
+    numbers_list = []
+    expression = None
+    if expression == None:
+        ops_list = __generate_operations(num_operations)
+        for i in range (0, num_operations + 1):
+            numbers_list.append(__generate_mixed_fraction ())
+        #Both numbers and operators are available.  Construct the mathematical expression
+        expression = __printable_expression(__printable_expression_fractions (numbers_list, ops_list))
+    answer = bodmas_fractions_solver(numbers_list, ops_list)
+    question = expression
+    return (question, answer)
+
 
 
-functions = [bodmas_integers, bodmas_decimals] #, bodmas_fractions]
+functions = [bodmas_integers, bodmas_decimals, bodmas_fractions, bodmas_mixed_fractions]
 
 
 def main():
@@ -169,6 +226,10 @@ def main():
                         filename='class.log', level=logging.INFO)
     unique_id = uuid.uuid1(1)
 
+    f_list = [Fraction (200, 2),Fraction (1,4),Fraction (2,3),Fraction (1,3),Fraction (2,3)]
+    ops_list = ["/", "*", "+", "-"]
+    bodmas_fractions_solver(f_list, ops_list)
+
     num_problems = 0
     while num_problems < 20:
         for i in range(0, len(functions)):
diff --git a/class05/math/tests/test_simplification_of_numerical_expressions.py b/class05/math/tests/test_simplification_of_numerical_expressions.py
index f84ef25..f5937af 100644
--- a/class05/math/tests/test_simplification_of_numerical_expressions.py
+++ b/class05/math/tests/test_simplification_of_numerical_expressions.py
@@ -25,6 +25,14 @@ def test_bodmas_decimals (self):
         question, answer = bodmas_decimals ("2.9 + 0.7 * 1.60 / 0.32 - 0.9")
         self.assertEqual(5.5, answer)
 
+    def test__bodmas_fractions_solver (self):
+        a = bodmas_fractions_solver([Fraction (200, 2),Fraction (1,4),Fraction (2,3),Fraction (1,3),Fraction (2,3)], ["/", "*", "+", "-"])
+        self.assertEqual(Fraction (799, 3), a)
+        a = bodmas_fractions_solver([Fraction (2,3),Fraction (5,4),Fraction (2,3),Fraction (5, 12),Fraction (7,8)], ["*", "/", "+", "-"])
+        self.assertEqual(Fraction (19, 24), a)
+        a = bodmas_fractions_solver([Fraction (9,7),Fraction (5,3),Fraction (8,5),Fraction (7,3),Fraction (1,2)], ["/", "+", "/", "+"])
+        self.assertEqual(Fraction (137, 70), a)
+
 
 if __name__ == '__main__':
     unittest.main()

From 110944e1ac8d90a338f6c25e0f509fc61469fcbf Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sun, 7 Feb 2016 18:34:25 +0530
Subject: [PATCH 28/39] number of problems generated = 30

---
 class05/math/simplification_of_numerical_expressions.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/class05/math/simplification_of_numerical_expressions.py b/class05/math/simplification_of_numerical_expressions.py
index a0a493b..64608b2 100644
--- a/class05/math/simplification_of_numerical_expressions.py
+++ b/class05/math/simplification_of_numerical_expressions.py
@@ -203,7 +203,7 @@ def bodmas_fractions_solver (fraction_list, operations_list):
 
 
 
-def bodmas_mixed_fractions (num_operations = 4):
+def bodmas_mixed_fractions (num_operations = 3):
     numbers_list = []
     expression = None
     if expression == None:
@@ -231,7 +231,7 @@ def main():
     bodmas_fractions_solver(f_list, ops_list)
 
     num_problems = 0
-    while num_problems < 20:
+    while num_problems < 30:
         for i in range(0, len(functions)):
             logging.info('Function : %s' % functions[i])
             f = functions[i]

From f32685e7d5b9209bcdc6a163e05d587598f98372 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Mon, 7 Mar 2016 15:26:29 +0530
Subject: [PATCH 29/39] Corrected <h1> in fraction.py

---
 class05/math/fraction.py    |  2 +-
 class05/math/temperature.py |  2 +-
 setup.py                    | 12 ++++++++++++
 3 files changed, 14 insertions(+), 2 deletions(-)
 create mode 100644 setup.py

diff --git a/class05/math/fraction.py b/class05/math/fraction.py
index 9ef328a..6d7f1c5 100644
--- a/class05/math/fraction.py
+++ b/class05/math/fraction.py
@@ -197,7 +197,7 @@ def main():
         question, answer = f()
         questions.append(question)
         answers.append(answer)
-    html_text = "<h1>Decimals</h1>\n"
+    html_text = "<h1>Fractions</h1>\n"
     html_text += "<h2>Questions: {}</h2>\n".format(str(unique_id)[:8])
     html_text += r'<ol>'
     for i in range(0, len(questions)):
diff --git a/class05/math/temperature.py b/class05/math/temperature.py
index ec4a75b..412f4ca 100644
--- a/class05/math/temperature.py
+++ b/class05/math/temperature.py
@@ -66,7 +66,7 @@ def main():
                         filename='class.log', level=logging.INFO)
     unique_id = uuid.uuid1(1)
 
-    for i in range (0, 10):
+    for i in range (0, 4):
         for i in range(0, len(functions)):
             logging.info('Function : %s' % functions[i])
             f = functions[i]
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..d3c7f8e
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,12 @@
+from distutils.core import setup
+
+setup(
+    name='study',
+    version='0.1',
+    packages=['class05', 'class05.math'],
+    url='',
+    license='MIT License',
+    author='Ajay',
+    author_email='',
+    description='CBSE Class 5 Homework Generator'
+)

From c576d4216a815d4f5a70905c20c4c0a8dc92f021 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Mon, 7 Mar 2016 15:27:05 +0530
Subject: [PATCH 30/39] reduced the number of problems to be generated

---
 class05/math/simplification_of_numerical_expressions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/class05/math/simplification_of_numerical_expressions.py b/class05/math/simplification_of_numerical_expressions.py
index 64608b2..bb507ba 100644
--- a/class05/math/simplification_of_numerical_expressions.py
+++ b/class05/math/simplification_of_numerical_expressions.py
@@ -231,7 +231,7 @@ def main():
     bodmas_fractions_solver(f_list, ops_list)
 
     num_problems = 0
-    while num_problems < 30:
+    while num_problems < 20:
         for i in range(0, len(functions)):
             logging.info('Function : %s' % functions[i])
             f = functions[i]

From 348ca8a83b6071a60554e74cab143020da508571 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Wed, 11 May 2016 16:39:24 +0530
Subject: [PATCH 31/39] fixed _least_common_multiple, if there are more than 3
 numbers

---
 class05/math/factors.py            | 12 ++++++++++--
 class05/math/tests/test_factors.py |  9 +++++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/class05/math/factors.py b/class05/math/factors.py
index 0fda898..ddd982f 100644
--- a/class05/math/factors.py
+++ b/class05/math/factors.py
@@ -189,10 +189,18 @@ def _least_common_multiple(number_list=[]):
             number_list.append(random.randint(11, 50))
     greatest = max(number_list)
     while (True):
-        if (greatest % number_list[0] == 0) and (greatest % number_list[1] == 0) and (greatest % number_list[2] == 0):
+        divisible = True
+        for i in range (0, list_length):
+            if greatest % number_list[i] == 0:
+                divisible = divisible and True
+            else:
+                greatest += 1
+                divisible = False
+                break #out of for loop
+        if divisible == True:
             lcm = greatest
             break
-        greatest += 1
+
     return (number_list, lcm)
 
 
diff --git a/class05/math/tests/test_factors.py b/class05/math/tests/test_factors.py
index 4853ed0..acaeede 100644
--- a/class05/math/tests/test_factors.py
+++ b/class05/math/tests/test_factors.py
@@ -1,6 +1,10 @@
+import unittest
 from unittest import TestCase
+import sys
 
 __author__ = 'Ajay'
+
+sys.path.append ('..\\')
 from factors import *
 
 
@@ -26,6 +30,8 @@ def test_factors(self):
         self.assertEqual(1440, least_common_multiple([45,32,16]))
         self.assertEqual(5208, least_common_multiple([31,24,14]))
         self.assertEqual(46512, least_common_multiple([323,272,153]))
+        self.assertEqual(1260, least_common_multiple([4,5,7,9]))
+        self.assertEqual(26180, least_common_multiple([4,5,7,11,17]))
         self.assertEqual((1530, 34), lcm_and_hcf([306, 170, 170]))
         self.assertEqual((6930, 9), lcm_and_hcf([90, 126, 99]))
         self.assertEqual(12, pole_spacing([60,36,84]))
@@ -39,3 +45,6 @@ def test_factors(self):
         self.assertEqual((60, [5,4]), students_running_circles([12, 15]))
         self.assertEqual((7, [3,5,7] ),  journey_time_minimum_hours([21, 35, 49]))
         self.assertEqual((2, [3,4,5]),   journey_time_minimum_hours([6, 8, 10]))
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file

From b9211c61492b87323f3ac218ce748d00a0c59c36 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Sun, 22 May 2016 20:09:21 +0530
Subject: [PATCH 32/39] all_factors is being called twice, once directly and a
 second time via building_age, messing up the output.  Moved the detection of
 factors into _all_factors

---
 class05/math/factors.py | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/class05/math/factors.py b/class05/math/factors.py
index ddd982f..74701c7 100644
--- a/class05/math/factors.py
+++ b/class05/math/factors.py
@@ -80,11 +80,8 @@ def factors(number=0):
     return (factors)  # for unit testing
 
 
-def all_factors(number=0):
+def _all_factors(number=0):
     """Retrieves all the  prime factors of a number, even the duplicate prime factors"""
-    if (number <= 0):
-        number = random.randint(50, 999)
-    input = number
     factor_list = []
     if _is_prime(number):
         factor_list.append(number)
@@ -97,10 +94,16 @@ def all_factors(number=0):
                     number //= n
                     n = 1
             n = n + 1
+    return (factor_list)
+
+def all_factors (number = 0):
+    if (number <= 0):
+        number = random.randint(50, 999)
+    factor_list = _all_factors (number)
     question = "___"
     for i in range(0, len(factor_list) - 1):
         question = "{} X ___ ".format(question)
-    question = "{} = {}, where each number is a prime number".format(question, input)
+    question = "{} = {}, where each number is a prime number".format(question, number)
     print(question)
     answers.append(factor_list)
     return (factor_list)
@@ -260,7 +263,11 @@ def march_past (team_size=[]):
     if len (team_size) != 2 or 0 in team_size:
         people_per_row = random.randint(5,9)
         for i in range (0,2):
-            team_size.append(people_per_row * random.randint(4,8))
+            people = people_per_row * random.randint(4,8)
+            if i == 1: #ensure that both teams do not have the same number of people
+                while (people == team_size[0]):
+                    people = people_per_row * random.randint(4,8)
+            team_size.append(people)
     print ("Two gymnastic teams are marching at an event. There are {} members on one team and {} on the other"\
         .format (team_size[0], team_size[1]), "They are marching in rows of equal size that are as wide as possible.",\
            "How many people are in each row?")
@@ -281,8 +288,8 @@ def building_age (age_this_year=0):
             age_last_year = age_this_year - 1
 
     logging.info ("Age this year = {}".format(age_this_year))
-    factors_age_this_year = all_factors(age_this_year)
-    factors_age_last_year = all_factors (age_last_year)
+    factors_age_this_year = _all_factors(age_this_year)
+    factors_age_last_year = _all_factors (age_last_year)
     logging.info ("Factors: {} {}".format (factors_age_this_year, factors_age_last_year))
     number_list, lcm = _least_common_multiple([age_this_year, age_last_year])
     age_range = random.randint (5, 10)
@@ -383,6 +390,7 @@ def main():
     # random.seed (os.urandom(5))
     for i in range(0, len(functions)):
         logging.info('Function : %s' % functions[i])
+
         print ("{i}) ".format(i=i+1), end="")
         f = functions[i]
         f()

From 14f66641b2ac30c5de967c5d93ef0a904a06e94f Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Mon, 23 May 2016 10:30:10 +0530
Subject: [PATCH 33/39] class06

---
 class06/__init__.py      | 0
 class06/math/__init__.py | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 class06/__init__.py
 create mode 100644 class06/math/__init__.py

diff --git a/class06/__init__.py b/class06/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/class06/math/__init__.py b/class06/math/__init__.py
new file mode 100644
index 0000000..e69de29

From 932246963709846bb6343470b76e0d13eea2767d Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Mon, 20 Jun 2016 16:27:21 +0530
Subject: [PATCH 34/39] copied factors.py and unit tests from class05

---
 class06/math/factors.py            | 413 +++++++++++++++++++++++++++++
 class06/math/tests/test_factors.py |  50 ++++
 2 files changed, 463 insertions(+)
 create mode 100644 class06/math/factors.py
 create mode 100644 class06/math/tests/test_factors.py

diff --git a/class06/math/factors.py b/class06/math/factors.py
new file mode 100644
index 0000000..74701c7
--- /dev/null
+++ b/class06/math/factors.py
@@ -0,0 +1,413 @@
+__author__ = 'Ajay'
+'''factors.py: Generates fractions related mathematical problems'''
+'''python <filename.py> will print all the questions, followed by a list of answers'''
+
+import random
+import logging
+import os
+import uuid
+from fractions import gcd
+
+answers = []
+names = ['Rahul', 'Ganpat', 'Gaurav', 'Gautam','Girish']
+
+def _is_prime(number):
+    if number < 3 or number % 2 == 0:
+        return False
+    for i in range(2, number):
+        if number % i == 0:
+            return False
+    return True
+
+
+def is_prime(number):
+    '''Written for conducting unit tests only'''
+    return _is_prime(number)
+
+
+def nearest_primes():
+    number = random.randint(10, 200)
+    lower_prime = higher_prime = 0
+    for i in range(number - 1, 3, -1):
+        if (_is_prime(i) == True):
+            lower_prime = i
+            break
+    i = number + 1
+    while _is_prime(i) == False:
+        i += 1
+    higher_prime = i
+    answer = "Lower prime: {}, Higher prime: {}".format(lower_prime, higher_prime)
+    answers.append(answer)
+    print("The prime numbers that are just before and after {} are _____ and _____.".format(number))
+
+
+def list_primes():
+    number = random.randint(10, 200)
+    range_size = random.randint(4, 10)
+    answer = []
+    for i in range(number, number + range_size + 1):
+        if _is_prime(i) == True:
+            answer.append(i)
+    answers.append(answer)
+    print("The prime numbers between {} and {} are ________".format(number, number + range_size))
+
+
+def twin_primes():
+    first_prime = random.randint(2, 25)
+    while (_is_prime(first_prime) is False):
+        first_prime += 1
+    if (_is_prime(first_prime + 2) is True):
+        answer = "The numbers are twin primes."
+    else:
+        answer = "The numbers are not twin primes."
+    answers.append(answer)
+    print("{} and {} are twin primes.  Yes or No?".format(first_prime, first_prime + 2))
+
+
+def factors(number=0):
+    if number <= 0:
+        number = random.randint(50, 500)
+    factors = []
+    n = 1
+    while (n <= number):
+        if (_is_prime(n) == True or n == 2):
+            if (number % n == 0):
+                factors.append(n)
+                # factors.append (number / n)
+        n += 1
+    answers.append(factors)
+    print("The unique factors of {number} are _________________.".format(number=number))
+    return (factors)  # for unit testing
+
+
+def _all_factors(number=0):
+    """Retrieves all the  prime factors of a number, even the duplicate prime factors"""
+    factor_list = []
+    if _is_prime(number):
+        factor_list.append(number)
+    else:
+        n = 1
+        while (n <= number):
+            if (_is_prime(n) == True or n == 2):
+                if number % n == 0:
+                    factor_list.append(n)
+                    number //= n
+                    n = 1
+            n = n + 1
+    return (factor_list)
+
+def all_factors (number = 0):
+    if (number <= 0):
+        number = random.randint(50, 999)
+    factor_list = _all_factors (number)
+    question = "___"
+    for i in range(0, len(factor_list) - 1):
+        question = "{} X ___ ".format(question)
+    question = "{} = {}, where each number is a prime number".format(question, number)
+    print(question)
+    answers.append(factor_list)
+    return (factor_list)
+
+
+def consecutive_primes(number=0, num_primes=0):
+    if number <= 0 or num_primes <= 0:
+        number = random.randint(5, 15)
+        num_primes = random.randint(2, 3)
+    orig_number = number
+    prime_list = []
+    while len(prime_list) < num_primes:
+        if _is_prime(number):
+            prime_list.append(number)
+        number = number + 1
+    print(
+        "The prime factors of a number are {} consecutive primes.  The smallest of these primes is {}.  What are the factors?  What is the number?".format(
+            num_primes, prime_list[0]))
+    product = 1
+    for i in range(0, len(prime_list)):
+        product = product * prime_list[i]
+    answer = "Factors = {}. Product = {}".format(prime_list, product)
+    answers.append(answer)
+    return (answer)
+
+
+def multiples(number=0, number_of_multiples=0):
+    if (number <= 0) or (number_of_multiples <= 0):
+        number = random.randint(16, 200)
+        number_of_multiples = random.randint(4, 8)
+    multiple_list = []
+    for n in range(1, number_of_multiples + 1):
+        multiple_list.append(number * n)
+    answers.append(multiple_list)
+    print("The first {number_of_multiples} multiples of {number} are ____________".format(
+        number_of_multiples=number_of_multiples, number=number))
+    return (multiple_list)
+
+
+def _highest_common_factor(number_list=[]):
+    list_length = len(number_list)
+    if (len(number_list) <= 1):
+        list_length = random.randint(2, 3)
+        logging.info("list_length = {}.".format(list_length))
+        hcf = random.randint(5, 12)
+        for i in range(0, list_length):
+            logging.info("index i : {}".format(i))
+            number_list.append(hcf * random.randint(2, 25))
+        logging.info("Number_list = {}".format(number_list))
+    ordered_list = list(number_list)
+    ordered_list.sort()
+    logging.info("ordered_list = {}".format(ordered_list))
+    numerator, denominator = ordered_list.pop(list_length - 1), ordered_list.pop(list_length - 2)
+    num_iterations = len(number_list) - 1
+
+    while (num_iterations > 0):
+        while (numerator % denominator != 0):
+            numerator, denominator = denominator, numerator % denominator
+            logging.info("numerator = {}, denominator = {}, remainder = {}".format(numerator, denominator,
+                                                                                   numerator % denominator))
+        if (len(ordered_list) > 0):
+            numerator = ordered_list.pop()
+        num_iterations = num_iterations - 1
+    # print ("The HCF of {} is _____.".format (number_list))
+    #answers.append (denominator)
+    return (number_list, denominator)
+
+
+def highest_common_factor(number_list=[]):
+    number_list, hcf = _highest_common_factor(number_list)
+    print("The HCF of {} is ______.".format(number_list))
+    answers.append(hcf)
+    return (hcf)
+
+
+def _least_common_multiple(number_list=[]):
+    '''
+
+    :param number_list - finds the LCM of three numbers:
+    :return: the list of numbers and the LCM
+    '''
+    list_length = len(number_list)
+    if list_length <= 2:
+        list_length = 3
+        for i in range(3):
+            number_list.append(random.randint(11, 50))
+    greatest = max(number_list)
+    while (True):
+        divisible = True
+        for i in range (0, list_length):
+            if greatest % number_list[i] == 0:
+                divisible = divisible and True
+            else:
+                greatest += 1
+                divisible = False
+                break #out of for loop
+        if divisible == True:
+            lcm = greatest
+            break
+
+    return (number_list, lcm)
+
+
+def least_common_multiple(number_list=[]):
+    number_list, lcm = _least_common_multiple(number_list)
+    print("The LCM of {} is ____.".format(number_list))
+    answers.append(lcm)
+    return lcm
+
+
+def lcm_and_hcf(number_list=[]):
+    if (len(number_list) < 3):
+        hcf = random.randint(7, 20)
+        i = 0
+        while (i < 3):
+            number = random.randint(9, 25) * hcf
+            if (number not in number_list):
+                number_list.append(number)
+                i += 1
+
+    number_list, lcm = _least_common_multiple(number_list)
+    number_list, hcf = _highest_common_factor(number_list)
+    print("The LCM and HCF of {} are _____ and _______ respectively.".format(number_list))
+    answers.append([lcm, hcf])
+    return (lcm, hcf)
+
+def pole_spacing (triangle_lengths=[]):
+    if (len (triangle_lengths) < 3):
+        i = 0;
+        distance_between_poles = random.randint (5,12)
+        while i < 3:
+            triangle_lengths.append(random.randint(3,7) * distance_between_poles)
+            i += 1
+    triangle_lengths, distance_between_poles = _highest_common_factor(triangle_lengths)
+    print ("A triangular plot of land is being fenced.  The sides of the plot are {}m, {}m and {}m long."\
+           .format (triangle_lengths[0], triangle_lengths[1], triangle_lengths[2]),\
+            "What is the greatest whole number of meters apart the fence (poles) posts can be placed and equally spaced.")
+    answers.append ("{}m apart".format (distance_between_poles))
+    return (distance_between_poles)
+
+def stamp_distribution (stamp_count=[]):
+    if len(stamp_count) != 2:
+        number_of_members = random.randint (4, 9)
+        for i in range (0, 2):
+            stamp_count.append(number_of_members * random.randint(3, 8))
+    stamp_count, number_of_members = _highest_common_factor(stamp_count)
+    stamps_per_member_from_first_set = stamp_count[0]//number_of_members
+    stamps_per_member_from_second_set = stamp_count[1]//number_of_members
+    print ("Suppose a stamp club president equally distributes two different sets of stamps among club members.",\
+           "One set contains {} stamps and the other set contains {} stamps.".format (stamp_count[0], stamp_count[1]), \
+           "There are no stamps left undistributed.", "1. What is the greatest possible number of club members?", \
+           "2. How many stamps from each set will each person receive?")
+    answers.append ("1) {} members, 2) {} stamps from 1st set and {} stamps from 2nd set".format (number_of_members, stamps_per_member_from_first_set, stamps_per_member_from_second_set))
+    return (number_of_members, stamps_per_member_from_first_set, stamps_per_member_from_second_set)
+
+def march_past (team_size=[]):
+    if len (team_size) != 2 or 0 in team_size:
+        people_per_row = random.randint(5,9)
+        for i in range (0,2):
+            people = people_per_row * random.randint(4,8)
+            if i == 1: #ensure that both teams do not have the same number of people
+                while (people == team_size[0]):
+                    people = people_per_row * random.randint(4,8)
+            team_size.append(people)
+    print ("Two gymnastic teams are marching at an event. There are {} members on one team and {} on the other"\
+        .format (team_size[0], team_size[1]), "They are marching in rows of equal size that are as wide as possible.",\
+           "How many people are in each row?")
+    team_size, people_per_row = _highest_common_factor(team_size)
+    answers.append (people_per_row)
+    return people_per_row
+
+def building_age (age_this_year=0):
+    age_last_year = age_this_year - 1
+    if age_this_year == 0:
+        non_primes = [x for x in range (50, 70) if not _is_prime(x) ]
+        logging.info (non_primes)
+        age_this_year = non_primes[random.randint (0, len(non_primes) -1)]
+        age_last_year = age_this_year - 1
+
+        while _is_prime(age_last_year):
+            age_this_year = non_primes[random.randint (0, len(non_primes) -1)]
+            age_last_year = age_this_year - 1
+
+    logging.info ("Age this year = {}".format(age_this_year))
+    factors_age_this_year = _all_factors(age_this_year)
+    factors_age_last_year = _all_factors (age_last_year)
+    logging.info ("Factors: {} {}".format (factors_age_this_year, factors_age_last_year))
+    number_list, lcm = _least_common_multiple([age_this_year, age_last_year])
+    age_range = random.randint (5, 10)
+    #TODO: Complete this
+    print ("A building\'s age this year is a multiple of {}. Last year it was a multiple of {}.".format(factors_age_this_year[1], factors_age_last_year[1]),\
+           "It is less than {} years but more than {} years old.  What is the age of the building?".format (age_this_year + age_range, age_this_year - age_range))
+    answers.append (age_this_year)
+    return (age_this_year)
+
+
+def _generate_unique_random_numbers (start=0, end=100, count=5):
+    if (start >= end) or (count <= 1) or (count > (end - start)):
+        return ()
+    random_number_set = set()
+    while count > 0:
+        element = random.randint (start, end)
+        if element not in random_number_set:
+            random_number_set.add (element)
+            count -= 1
+    logging.info ("Set of random numbers: {}".format (random_number_set))
+    return sorted (random_number_set)
+
+def chocolate_distribution (chocolates_per_friend = [], extra_chocolates=-1):
+    person = names[random.randint(0,  len(names) -1)]
+    if len (chocolates_per_friend) <3:
+        chocolates_per_friend = list(_generate_unique_random_numbers(5, 10, 3))
+
+    logging.info ("Chocolates per friend {}".format (chocolates_per_friend))
+    if extra_chocolates < 0:
+        extra_chocolates = random.randint (4, 9)
+    print ("{person} has some chocolates and he gives each of his friends {choc1} or {choc2} or {choc3} chocolates.  He finds that each time"\
+        " {extra} chocolates are left over.  Find the minimum number of chocolates {person} had.   How many friends did he have?"\
+        .format (person=person,choc1=chocolates_per_friend[0], choc2=chocolates_per_friend[1], choc3=chocolates_per_friend[2],\
+                 extra=extra_chocolates))
+    chocs, lcm = _least_common_multiple(chocolates_per_friend)
+    num_friends = []
+    for i in range (len(chocolates_per_friend)):
+        num_friends.append(lcm // chocolates_per_friend[i])
+    answers.append ("Total chocolates : {}, number of friends: {}".format (lcm + extra_chocolates, num_friends))
+    return (lcm + extra_chocolates, chocolates_per_friend)
+
+
+def students_in_class (students_per_row=[]):
+    if len(students_per_row) < 4:
+        students_per_row = _generate_unique_random_numbers(5,18,4)
+    print ("Students in a class are made to stand in complete rows of {}, {}, {} or {} each.  What is the minimum number"\
+            " of students in that class?".format (students_per_row[0], students_per_row[1], students_per_row[2], students_per_row[3]))
+    students, lcm = _least_common_multiple(students_per_row)
+    answers.append(lcm)
+    return (lcm)
+
+def students_running_circles (circling_time=[]):
+    if len (circling_time) < 2:
+        circling_time = _generate_unique_random_numbers(7, 15, 2)
+    print ("Two boys run around a circular field. They can complete one circle in {} and {} seconds respectively.".format (circling_time[0], circling_time[1]),\
+            "If they start from a point together, find after what time will they be together again at the same point."\
+            "Also find how many rounds each of them will have completed by that time?")
+    lcm = (circling_time[0] * circling_time[1])//gcd(circling_time[0], circling_time[1])
+    rounds = []
+    for i in range (len(circling_time)):
+        rounds.append (lcm//circling_time[i])
+    answers.append("They meet at {} seconds.  They complete {} and {} rounds respectively.".format(lcm, rounds[0], rounds[1]))
+    return (lcm, rounds)
+
+
+def journey_time_minimum_hours (hours_per_person=[]):
+    if len(hours_per_person) < 3:
+        factor = random.randint (2,7)
+        for i in range (3, 8, 2):
+            hours_per_person.append (factor * i)
+    print ("To travel to Delhi, Meena requires a total of {} hours, Rajesh requires a total of {} hours and Priya requires {} hours.".format (hours_per_person[0], hours_per_person[1], hours_per_person[2]),\
+           "All the three, travel for an equal number of hours each day.  Find out 1) How many hours all the three spend ",\
+            "each day to travel and 2) How many days will it take each of them to travel to Delhi?")
+    hours, hcf = _highest_common_factor(hours_per_person)
+    days_per_person = []
+    for i in range (len (hours_per_person)):
+        days_per_person.append (hours_per_person[i]//hcf)
+    answers.append ("Hours per day: {}, Days per person : {}".format (hcf, days_per_person))
+    return (hcf, days_per_person)
+
+
+functions = [nearest_primes, list_primes, twin_primes, factors, multiples, all_factors, consecutive_primes, \
+             highest_common_factor, least_common_multiple, lcm_and_hcf, pole_spacing, stamp_distribution,\
+             march_past, building_age, chocolate_distribution, students_in_class, students_running_circles, journey_time_minimum_hours]
+
+
+def squat():
+    print("hello world")
+    for i in range(5):
+        yield (i ** 2)
+
+
+def main():
+    logging.basicConfig(format='%(asctime)s:%(levelname)s:%(funcName)s:%(message)s', datefmt='%Y%m%d %I:%M:%S %p',
+                        filename='class.log', level=logging.INFO)
+    unique_id = uuid.uuid1(1)
+    print("Question Paper # {}".format(str(unique_id)))
+    # random.seed (os.urandom(5))
+    for i in range(0, len(functions)):
+        logging.info('Function : %s' % functions[i])
+
+        print ("{i}) ".format(i=i+1), end="")
+        f = functions[i]
+        f()
+        logging.info ('Answer  : %s' % answers[i])
+
+    print ()
+    print("Answer Key # {}".format(str(unique_id)))
+    for i in range(0, len (functions)): #len(answers)):
+        print(i + 1, answers[i])
+        #primes = [ _is_prime(x) for x in range (100)]
+        #print (primes)
+        #for i in squat ():
+        #    print (i)
+
+        #for i in range (100, 500):
+        #   print (i, all_factors(i))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/class06/math/tests/test_factors.py b/class06/math/tests/test_factors.py
new file mode 100644
index 0000000..acaeede
--- /dev/null
+++ b/class06/math/tests/test_factors.py
@@ -0,0 +1,50 @@
+import unittest
+from unittest import TestCase
+import sys
+
+__author__ = 'Ajay'
+
+sys.path.append ('..\\')
+from factors import *
+
+
+class TestFactors(TestCase):
+    def test_factors(self):
+        self.assertEqual([673],   factors (673))
+        self.assertEqual([3,11,13], factors (429))
+        self.assertEqual([167, 334, 501, 668, 835], multiples (167, 5))
+        self.assertEqual([150, 300, 450, 600], multiples (150, 4))
+        self.assertEqual(False,  is_prime(6))
+        self.assertEqual(True,  is_prime(11))
+        self.assertEqual(False, is_prime(4))
+        self.assertEqual([2, 19, 23], all_factors(874))
+        self.assertEqual([2, 2, 103], all_factors(412))
+        self.assertEqual(("Factors = [17, 19, 23, 29]. Product = 215441"), consecutive_primes(17, 4))
+        self.assertEqual(("Factors = [11, 13]. Product = 143"), consecutive_primes(11, 2))
+        self.assertEqual(12, highest_common_factor([36, 48]))
+        self.assertEqual(6, highest_common_factor([24, 30, 90]))
+        self.assertEqual(1, highest_common_factor([13, 21, 17]))
+        self.assertEqual(4, highest_common_factor([72, 104, 92]))
+
+        self.assertEqual(4290, least_common_multiple([330, 65, 15]))
+        self.assertEqual(1440, least_common_multiple([45,32,16]))
+        self.assertEqual(5208, least_common_multiple([31,24,14]))
+        self.assertEqual(46512, least_common_multiple([323,272,153]))
+        self.assertEqual(1260, least_common_multiple([4,5,7,9]))
+        self.assertEqual(26180, least_common_multiple([4,5,7,11,17]))
+        self.assertEqual((1530, 34), lcm_and_hcf([306, 170, 170]))
+        self.assertEqual((6930, 9), lcm_and_hcf([90, 126, 99]))
+        self.assertEqual(12, pole_spacing([60,36,84]))
+        self.assertEqual((8,3,2), stamp_distribution([24,16]))
+        self.assertEqual((6,3,5), stamp_distribution([18,30]))
+        self.assertEqual(8, march_past([32, 40]))
+        self.assertEqual (50, building_age(50))
+        self.assertEqual((123, [6,8,10]), chocolate_distribution ([6, 8, 10], 3))
+        self.assertEqual(36,  students_in_class([6, 9, 12, 18]))
+        self.assertEqual((120, [4,3]), students_running_circles([30, 40]))
+        self.assertEqual((60, [5,4]), students_running_circles([12, 15]))
+        self.assertEqual((7, [3,5,7] ),  journey_time_minimum_hours([21, 35, 49]))
+        self.assertEqual((2, [3,4,5]),   journey_time_minimum_hours([6, 8, 10]))
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file

From d79940f2fbd1fd84c0486136293449e297fc214f Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Tue, 21 Jun 2016 09:19:48 +0530
Subject: [PATCH 35/39] check-in

---
 class06/math/factors.py | 51 +++++++++++++++++++----------------------
 1 file changed, 23 insertions(+), 28 deletions(-)

diff --git a/class06/math/factors.py b/class06/math/factors.py
index 74701c7..f7b9e65 100644
--- a/class06/math/factors.py
+++ b/class06/math/factors.py
@@ -7,6 +7,10 @@
 import os
 import uuid
 from fractions import gcd
+import sys
+
+sys.path.append ('..\\..\\class05\math')
+from factors import _highest_common_factor
 
 answers = []
 names = ['Rahul', 'Ganpat', 'Gaurav', 'Gautam','Girish']
@@ -143,33 +147,6 @@ def multiples(number=0, number_of_multiples=0):
     return (multiple_list)
 
 
-def _highest_common_factor(number_list=[]):
-    list_length = len(number_list)
-    if (len(number_list) <= 1):
-        list_length = random.randint(2, 3)
-        logging.info("list_length = {}.".format(list_length))
-        hcf = random.randint(5, 12)
-        for i in range(0, list_length):
-            logging.info("index i : {}".format(i))
-            number_list.append(hcf * random.randint(2, 25))
-        logging.info("Number_list = {}".format(number_list))
-    ordered_list = list(number_list)
-    ordered_list.sort()
-    logging.info("ordered_list = {}".format(ordered_list))
-    numerator, denominator = ordered_list.pop(list_length - 1), ordered_list.pop(list_length - 2)
-    num_iterations = len(number_list) - 1
-
-    while (num_iterations > 0):
-        while (numerator % denominator != 0):
-            numerator, denominator = denominator, numerator % denominator
-            logging.info("numerator = {}, denominator = {}, remainder = {}".format(numerator, denominator,
-                                                                                   numerator % denominator))
-        if (len(ordered_list) > 0):
-            numerator = ordered_list.pop()
-        num_iterations = num_iterations - 1
-    # print ("The HCF of {} is _____.".format (number_list))
-    #answers.append (denominator)
-    return (number_list, denominator)
 
 
 def highest_common_factor(number_list=[]):
@@ -370,10 +347,28 @@ def journey_time_minimum_hours (hours_per_person=[]):
     answers.append ("Hours per day: {}, Days per person : {}".format (hcf, days_per_person))
     return (hcf, days_per_person)
 
+def containers_hcf (capacity=[]):
+    container_list = ["tubs", "tankers", "water tanks", "oil-ships"]
+    if (len (capacity) != 2):
+        capacity = []
+        capacity.append (random.randint (100,999))
+        capacity.append (random.randint (100,999))
+        _,hcf = _highest_common_factor([capacity[0], capacity[1]])
+        while (capacity[0] == capacity[1] or hcf == 1):
+            capacity[0] = random.randint(100,999)
+            _,hcf = _highest_common_factor([capacity[0], capacity[1]])
+    container = container_list[random.randint(0, len(container_list)-1)]
+    print ("Two {} contain {} liters and {} liters of liquid respectively.  Find the maximum capacity of a container which can measure the liquid of both tanks when used".format(container, capacity[0], capacity[1]),\
+    " an exact number of times.")
+    _,answer = _highest_common_factor([capacity[0], capacity[1]])
+    answers.append (answer)
+    return (answer)
+
+
 
 functions = [nearest_primes, list_primes, twin_primes, factors, multiples, all_factors, consecutive_primes, \
              highest_common_factor, least_common_multiple, lcm_and_hcf, pole_spacing, stamp_distribution,\
-             march_past, building_age, chocolate_distribution, students_in_class, students_running_circles, journey_time_minimum_hours]
+             march_past, building_age, chocolate_distribution, students_in_class, students_running_circles, journey_time_minimum_hours, containers_hcf]
 
 
 def squat():

From f4649d4b1099f01698458b85c39011e15662493e Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Tue, 21 Jun 2016 10:29:02 +0530
Subject: [PATCH 36/39] uses functions from class05\math\factors.py

---
 class06/math/factors.py   | 408 --------------------------------------
 class06/math/factors06.py |  79 ++++++++
 2 files changed, 79 insertions(+), 408 deletions(-)
 delete mode 100644 class06/math/factors.py
 create mode 100644 class06/math/factors06.py

diff --git a/class06/math/factors.py b/class06/math/factors.py
deleted file mode 100644
index f7b9e65..0000000
--- a/class06/math/factors.py
+++ /dev/null
@@ -1,408 +0,0 @@
-__author__ = 'Ajay'
-'''factors.py: Generates fractions related mathematical problems'''
-'''python <filename.py> will print all the questions, followed by a list of answers'''
-
-import random
-import logging
-import os
-import uuid
-from fractions import gcd
-import sys
-
-sys.path.append ('..\\..\\class05\math')
-from factors import _highest_common_factor
-
-answers = []
-names = ['Rahul', 'Ganpat', 'Gaurav', 'Gautam','Girish']
-
-def _is_prime(number):
-    if number < 3 or number % 2 == 0:
-        return False
-    for i in range(2, number):
-        if number % i == 0:
-            return False
-    return True
-
-
-def is_prime(number):
-    '''Written for conducting unit tests only'''
-    return _is_prime(number)
-
-
-def nearest_primes():
-    number = random.randint(10, 200)
-    lower_prime = higher_prime = 0
-    for i in range(number - 1, 3, -1):
-        if (_is_prime(i) == True):
-            lower_prime = i
-            break
-    i = number + 1
-    while _is_prime(i) == False:
-        i += 1
-    higher_prime = i
-    answer = "Lower prime: {}, Higher prime: {}".format(lower_prime, higher_prime)
-    answers.append(answer)
-    print("The prime numbers that are just before and after {} are _____ and _____.".format(number))
-
-
-def list_primes():
-    number = random.randint(10, 200)
-    range_size = random.randint(4, 10)
-    answer = []
-    for i in range(number, number + range_size + 1):
-        if _is_prime(i) == True:
-            answer.append(i)
-    answers.append(answer)
-    print("The prime numbers between {} and {} are ________".format(number, number + range_size))
-
-
-def twin_primes():
-    first_prime = random.randint(2, 25)
-    while (_is_prime(first_prime) is False):
-        first_prime += 1
-    if (_is_prime(first_prime + 2) is True):
-        answer = "The numbers are twin primes."
-    else:
-        answer = "The numbers are not twin primes."
-    answers.append(answer)
-    print("{} and {} are twin primes.  Yes or No?".format(first_prime, first_prime + 2))
-
-
-def factors(number=0):
-    if number <= 0:
-        number = random.randint(50, 500)
-    factors = []
-    n = 1
-    while (n <= number):
-        if (_is_prime(n) == True or n == 2):
-            if (number % n == 0):
-                factors.append(n)
-                # factors.append (number / n)
-        n += 1
-    answers.append(factors)
-    print("The unique factors of {number} are _________________.".format(number=number))
-    return (factors)  # for unit testing
-
-
-def _all_factors(number=0):
-    """Retrieves all the  prime factors of a number, even the duplicate prime factors"""
-    factor_list = []
-    if _is_prime(number):
-        factor_list.append(number)
-    else:
-        n = 1
-        while (n <= number):
-            if (_is_prime(n) == True or n == 2):
-                if number % n == 0:
-                    factor_list.append(n)
-                    number //= n
-                    n = 1
-            n = n + 1
-    return (factor_list)
-
-def all_factors (number = 0):
-    if (number <= 0):
-        number = random.randint(50, 999)
-    factor_list = _all_factors (number)
-    question = "___"
-    for i in range(0, len(factor_list) - 1):
-        question = "{} X ___ ".format(question)
-    question = "{} = {}, where each number is a prime number".format(question, number)
-    print(question)
-    answers.append(factor_list)
-    return (factor_list)
-
-
-def consecutive_primes(number=0, num_primes=0):
-    if number <= 0 or num_primes <= 0:
-        number = random.randint(5, 15)
-        num_primes = random.randint(2, 3)
-    orig_number = number
-    prime_list = []
-    while len(prime_list) < num_primes:
-        if _is_prime(number):
-            prime_list.append(number)
-        number = number + 1
-    print(
-        "The prime factors of a number are {} consecutive primes.  The smallest of these primes is {}.  What are the factors?  What is the number?".format(
-            num_primes, prime_list[0]))
-    product = 1
-    for i in range(0, len(prime_list)):
-        product = product * prime_list[i]
-    answer = "Factors = {}. Product = {}".format(prime_list, product)
-    answers.append(answer)
-    return (answer)
-
-
-def multiples(number=0, number_of_multiples=0):
-    if (number <= 0) or (number_of_multiples <= 0):
-        number = random.randint(16, 200)
-        number_of_multiples = random.randint(4, 8)
-    multiple_list = []
-    for n in range(1, number_of_multiples + 1):
-        multiple_list.append(number * n)
-    answers.append(multiple_list)
-    print("The first {number_of_multiples} multiples of {number} are ____________".format(
-        number_of_multiples=number_of_multiples, number=number))
-    return (multiple_list)
-
-
-
-
-def highest_common_factor(number_list=[]):
-    number_list, hcf = _highest_common_factor(number_list)
-    print("The HCF of {} is ______.".format(number_list))
-    answers.append(hcf)
-    return (hcf)
-
-
-def _least_common_multiple(number_list=[]):
-    '''
-
-    :param number_list - finds the LCM of three numbers:
-    :return: the list of numbers and the LCM
-    '''
-    list_length = len(number_list)
-    if list_length <= 2:
-        list_length = 3
-        for i in range(3):
-            number_list.append(random.randint(11, 50))
-    greatest = max(number_list)
-    while (True):
-        divisible = True
-        for i in range (0, list_length):
-            if greatest % number_list[i] == 0:
-                divisible = divisible and True
-            else:
-                greatest += 1
-                divisible = False
-                break #out of for loop
-        if divisible == True:
-            lcm = greatest
-            break
-
-    return (number_list, lcm)
-
-
-def least_common_multiple(number_list=[]):
-    number_list, lcm = _least_common_multiple(number_list)
-    print("The LCM of {} is ____.".format(number_list))
-    answers.append(lcm)
-    return lcm
-
-
-def lcm_and_hcf(number_list=[]):
-    if (len(number_list) < 3):
-        hcf = random.randint(7, 20)
-        i = 0
-        while (i < 3):
-            number = random.randint(9, 25) * hcf
-            if (number not in number_list):
-                number_list.append(number)
-                i += 1
-
-    number_list, lcm = _least_common_multiple(number_list)
-    number_list, hcf = _highest_common_factor(number_list)
-    print("The LCM and HCF of {} are _____ and _______ respectively.".format(number_list))
-    answers.append([lcm, hcf])
-    return (lcm, hcf)
-
-def pole_spacing (triangle_lengths=[]):
-    if (len (triangle_lengths) < 3):
-        i = 0;
-        distance_between_poles = random.randint (5,12)
-        while i < 3:
-            triangle_lengths.append(random.randint(3,7) * distance_between_poles)
-            i += 1
-    triangle_lengths, distance_between_poles = _highest_common_factor(triangle_lengths)
-    print ("A triangular plot of land is being fenced.  The sides of the plot are {}m, {}m and {}m long."\
-           .format (triangle_lengths[0], triangle_lengths[1], triangle_lengths[2]),\
-            "What is the greatest whole number of meters apart the fence (poles) posts can be placed and equally spaced.")
-    answers.append ("{}m apart".format (distance_between_poles))
-    return (distance_between_poles)
-
-def stamp_distribution (stamp_count=[]):
-    if len(stamp_count) != 2:
-        number_of_members = random.randint (4, 9)
-        for i in range (0, 2):
-            stamp_count.append(number_of_members * random.randint(3, 8))
-    stamp_count, number_of_members = _highest_common_factor(stamp_count)
-    stamps_per_member_from_first_set = stamp_count[0]//number_of_members
-    stamps_per_member_from_second_set = stamp_count[1]//number_of_members
-    print ("Suppose a stamp club president equally distributes two different sets of stamps among club members.",\
-           "One set contains {} stamps and the other set contains {} stamps.".format (stamp_count[0], stamp_count[1]), \
-           "There are no stamps left undistributed.", "1. What is the greatest possible number of club members?", \
-           "2. How many stamps from each set will each person receive?")
-    answers.append ("1) {} members, 2) {} stamps from 1st set and {} stamps from 2nd set".format (number_of_members, stamps_per_member_from_first_set, stamps_per_member_from_second_set))
-    return (number_of_members, stamps_per_member_from_first_set, stamps_per_member_from_second_set)
-
-def march_past (team_size=[]):
-    if len (team_size) != 2 or 0 in team_size:
-        people_per_row = random.randint(5,9)
-        for i in range (0,2):
-            people = people_per_row * random.randint(4,8)
-            if i == 1: #ensure that both teams do not have the same number of people
-                while (people == team_size[0]):
-                    people = people_per_row * random.randint(4,8)
-            team_size.append(people)
-    print ("Two gymnastic teams are marching at an event. There are {} members on one team and {} on the other"\
-        .format (team_size[0], team_size[1]), "They are marching in rows of equal size that are as wide as possible.",\
-           "How many people are in each row?")
-    team_size, people_per_row = _highest_common_factor(team_size)
-    answers.append (people_per_row)
-    return people_per_row
-
-def building_age (age_this_year=0):
-    age_last_year = age_this_year - 1
-    if age_this_year == 0:
-        non_primes = [x for x in range (50, 70) if not _is_prime(x) ]
-        logging.info (non_primes)
-        age_this_year = non_primes[random.randint (0, len(non_primes) -1)]
-        age_last_year = age_this_year - 1
-
-        while _is_prime(age_last_year):
-            age_this_year = non_primes[random.randint (0, len(non_primes) -1)]
-            age_last_year = age_this_year - 1
-
-    logging.info ("Age this year = {}".format(age_this_year))
-    factors_age_this_year = _all_factors(age_this_year)
-    factors_age_last_year = _all_factors (age_last_year)
-    logging.info ("Factors: {} {}".format (factors_age_this_year, factors_age_last_year))
-    number_list, lcm = _least_common_multiple([age_this_year, age_last_year])
-    age_range = random.randint (5, 10)
-    #TODO: Complete this
-    print ("A building\'s age this year is a multiple of {}. Last year it was a multiple of {}.".format(factors_age_this_year[1], factors_age_last_year[1]),\
-           "It is less than {} years but more than {} years old.  What is the age of the building?".format (age_this_year + age_range, age_this_year - age_range))
-    answers.append (age_this_year)
-    return (age_this_year)
-
-
-def _generate_unique_random_numbers (start=0, end=100, count=5):
-    if (start >= end) or (count <= 1) or (count > (end - start)):
-        return ()
-    random_number_set = set()
-    while count > 0:
-        element = random.randint (start, end)
-        if element not in random_number_set:
-            random_number_set.add (element)
-            count -= 1
-    logging.info ("Set of random numbers: {}".format (random_number_set))
-    return sorted (random_number_set)
-
-def chocolate_distribution (chocolates_per_friend = [], extra_chocolates=-1):
-    person = names[random.randint(0,  len(names) -1)]
-    if len (chocolates_per_friend) <3:
-        chocolates_per_friend = list(_generate_unique_random_numbers(5, 10, 3))
-
-    logging.info ("Chocolates per friend {}".format (chocolates_per_friend))
-    if extra_chocolates < 0:
-        extra_chocolates = random.randint (4, 9)
-    print ("{person} has some chocolates and he gives each of his friends {choc1} or {choc2} or {choc3} chocolates.  He finds that each time"\
-        " {extra} chocolates are left over.  Find the minimum number of chocolates {person} had.   How many friends did he have?"\
-        .format (person=person,choc1=chocolates_per_friend[0], choc2=chocolates_per_friend[1], choc3=chocolates_per_friend[2],\
-                 extra=extra_chocolates))
-    chocs, lcm = _least_common_multiple(chocolates_per_friend)
-    num_friends = []
-    for i in range (len(chocolates_per_friend)):
-        num_friends.append(lcm // chocolates_per_friend[i])
-    answers.append ("Total chocolates : {}, number of friends: {}".format (lcm + extra_chocolates, num_friends))
-    return (lcm + extra_chocolates, chocolates_per_friend)
-
-
-def students_in_class (students_per_row=[]):
-    if len(students_per_row) < 4:
-        students_per_row = _generate_unique_random_numbers(5,18,4)
-    print ("Students in a class are made to stand in complete rows of {}, {}, {} or {} each.  What is the minimum number"\
-            " of students in that class?".format (students_per_row[0], students_per_row[1], students_per_row[2], students_per_row[3]))
-    students, lcm = _least_common_multiple(students_per_row)
-    answers.append(lcm)
-    return (lcm)
-
-def students_running_circles (circling_time=[]):
-    if len (circling_time) < 2:
-        circling_time = _generate_unique_random_numbers(7, 15, 2)
-    print ("Two boys run around a circular field. They can complete one circle in {} and {} seconds respectively.".format (circling_time[0], circling_time[1]),\
-            "If they start from a point together, find after what time will they be together again at the same point."\
-            "Also find how many rounds each of them will have completed by that time?")
-    lcm = (circling_time[0] * circling_time[1])//gcd(circling_time[0], circling_time[1])
-    rounds = []
-    for i in range (len(circling_time)):
-        rounds.append (lcm//circling_time[i])
-    answers.append("They meet at {} seconds.  They complete {} and {} rounds respectively.".format(lcm, rounds[0], rounds[1]))
-    return (lcm, rounds)
-
-
-def journey_time_minimum_hours (hours_per_person=[]):
-    if len(hours_per_person) < 3:
-        factor = random.randint (2,7)
-        for i in range (3, 8, 2):
-            hours_per_person.append (factor * i)
-    print ("To travel to Delhi, Meena requires a total of {} hours, Rajesh requires a total of {} hours and Priya requires {} hours.".format (hours_per_person[0], hours_per_person[1], hours_per_person[2]),\
-           "All the three, travel for an equal number of hours each day.  Find out 1) How many hours all the three spend ",\
-            "each day to travel and 2) How many days will it take each of them to travel to Delhi?")
-    hours, hcf = _highest_common_factor(hours_per_person)
-    days_per_person = []
-    for i in range (len (hours_per_person)):
-        days_per_person.append (hours_per_person[i]//hcf)
-    answers.append ("Hours per day: {}, Days per person : {}".format (hcf, days_per_person))
-    return (hcf, days_per_person)
-
-def containers_hcf (capacity=[]):
-    container_list = ["tubs", "tankers", "water tanks", "oil-ships"]
-    if (len (capacity) != 2):
-        capacity = []
-        capacity.append (random.randint (100,999))
-        capacity.append (random.randint (100,999))
-        _,hcf = _highest_common_factor([capacity[0], capacity[1]])
-        while (capacity[0] == capacity[1] or hcf == 1):
-            capacity[0] = random.randint(100,999)
-            _,hcf = _highest_common_factor([capacity[0], capacity[1]])
-    container = container_list[random.randint(0, len(container_list)-1)]
-    print ("Two {} contain {} liters and {} liters of liquid respectively.  Find the maximum capacity of a container which can measure the liquid of both tanks when used".format(container, capacity[0], capacity[1]),\
-    " an exact number of times.")
-    _,answer = _highest_common_factor([capacity[0], capacity[1]])
-    answers.append (answer)
-    return (answer)
-
-
-
-functions = [nearest_primes, list_primes, twin_primes, factors, multiples, all_factors, consecutive_primes, \
-             highest_common_factor, least_common_multiple, lcm_and_hcf, pole_spacing, stamp_distribution,\
-             march_past, building_age, chocolate_distribution, students_in_class, students_running_circles, journey_time_minimum_hours, containers_hcf]
-
-
-def squat():
-    print("hello world")
-    for i in range(5):
-        yield (i ** 2)
-
-
-def main():
-    logging.basicConfig(format='%(asctime)s:%(levelname)s:%(funcName)s:%(message)s', datefmt='%Y%m%d %I:%M:%S %p',
-                        filename='class.log', level=logging.INFO)
-    unique_id = uuid.uuid1(1)
-    print("Question Paper # {}".format(str(unique_id)))
-    # random.seed (os.urandom(5))
-    for i in range(0, len(functions)):
-        logging.info('Function : %s' % functions[i])
-
-        print ("{i}) ".format(i=i+1), end="")
-        f = functions[i]
-        f()
-        logging.info ('Answer  : %s' % answers[i])
-
-    print ()
-    print("Answer Key # {}".format(str(unique_id)))
-    for i in range(0, len (functions)): #len(answers)):
-        print(i + 1, answers[i])
-        #primes = [ _is_prime(x) for x in range (100)]
-        #print (primes)
-        #for i in squat ():
-        #    print (i)
-
-        #for i in range (100, 500):
-        #   print (i, all_factors(i))
-
-
-if __name__ == "__main__":
-    main()
diff --git a/class06/math/factors06.py b/class06/math/factors06.py
new file mode 100644
index 0000000..8fdd8d8
--- /dev/null
+++ b/class06/math/factors06.py
@@ -0,0 +1,79 @@
+__author__ = 'Ajay'
+'''factors.py: Generates fractions related mathematical problems'''
+'''python <filename.py> will print all the questions, followed by a list of answers'''
+
+import random
+import logging
+import os
+import uuid
+from fractions import gcd
+import sys
+
+sys.path.append ('..\\..\\')
+from  class05.math.factors import _is_prime, _highest_common_factor, _least_common_multiple, _generate_unique_random_numbers  #all private functions
+from class05.math.factors import *  #public functions
+
+
+answers = []
+names = ['Rahul', 'Ganpat', 'Gaurav', 'Gautam','Girish']
+
+
+def containers_hcf (capacity=[]):
+    container_list = ["tubs", "tankers", "water tanks", "oil-ships"]
+    if (len (capacity) != 2):
+        capacity = []
+        capacity.append (random.randint (100,999))
+        capacity.append (random.randint (100,999))
+        _,hcf = _highest_common_factor([capacity[0], capacity[1]])
+        while (capacity[0] == capacity[1] or hcf == 1):
+            capacity[0] = random.randint(100,999)
+            _,hcf = _highest_common_factor([capacity[0], capacity[1]])
+    container = container_list[random.randint(0, len(container_list)-1)]
+    print ("Two {} contain {} liters and {} liters of liquid respectively.  Find the maximum capacity of a container which can measure the liquid of both tanks when used".format(container, capacity[0], capacity[1]),\
+    " an exact number of times.")
+    _,answer = _highest_common_factor([capacity[0], capacity[1]])
+    answers.append (answer)
+    return (answer)
+
+
+
+functions = [nearest_primes, list_primes, twin_primes, factors, multiples, all_factors, consecutive_primes, \
+             highest_common_factor, least_common_multiple, lcm_and_hcf, pole_spacing, stamp_distribution,\
+             march_past, building_age, chocolate_distribution, students_in_class, students_running_circles, journey_time_minimum_hours, containers_hcf]
+
+
+def squat():
+    print("hello world")
+    for i in range(5):
+        yield (i ** 2)
+
+
+def main():
+    logging.basicConfig(format='%(asctime)s:%(levelname)s:%(funcName)s:%(message)s', datefmt='%Y%m%d %I:%M:%S %p',
+                        filename='class.log', level=logging.INFO)
+    unique_id = uuid.uuid1(1)
+    print("Question Paper # {}".format(str(unique_id)))
+    # random.seed (os.urandom(5))
+    for i in range(0, len(functions)):
+        logging.info('Function : %s' % functions[i])
+
+        print ("{i}) ".format(i=i+1), end="")
+        f = functions[i]
+        f()
+        #logging.info ('Answer  : %s' % answers[i])
+
+    print ()
+    print("Answer Key # {}".format(str(unique_id)))
+    for i in range(0, len (functions)): #len(answers)):
+        print(i + 1, answers[i])
+        #primes = [ _is_prime(x) for x in range (100)]
+        #print (primes)
+        #for i in squat ():
+        #    print (i)
+
+        #for i in range (100, 500):
+        #   print (i, all_factors(i))
+
+
+if __name__ == "__main__":
+    main()

From 8ab9dec91ae6bffa9b6b13d16a7deaff450258be Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Tue, 21 Jun 2016 22:54:13 +0530
Subject: [PATCH 37/39] Fixed paths for running unit tests for factors06

---
 class06/math/factors06.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/class06/math/factors06.py b/class06/math/factors06.py
index 8fdd8d8..cc70d2b 100644
--- a/class06/math/factors06.py
+++ b/class06/math/factors06.py
@@ -10,11 +10,10 @@
 import sys
 
 sys.path.append ('..\\..\\')
-from  class05.math.factors import _is_prime, _highest_common_factor, _least_common_multiple, _generate_unique_random_numbers  #all private functions
+from class05.math.factors import _is_prime, _highest_common_factor, _least_common_multiple, _generate_unique_random_numbers, answers  #all private functions
 from class05.math.factors import *  #public functions
 
 
-answers = []
 names = ['Rahul', 'Ganpat', 'Gaurav', 'Gautam','Girish']
 
 
@@ -22,11 +21,12 @@ def containers_hcf (capacity=[]):
     container_list = ["tubs", "tankers", "water tanks", "oil-ships"]
     if (len (capacity) != 2):
         capacity = []
-        capacity.append (random.randint (100,999))
-        capacity.append (random.randint (100,999))
-        _,hcf = _highest_common_factor([capacity[0], capacity[1]])
+        hcf = random.randint (12,29)
+        capacity.append (hcf * random.randint (20, 40))
+        capacity.append (hcf * random.randint (20, 40))
+        #_,hcf = _highest_common_factor([capacity[0], capacity[1]])
         while (capacity[0] == capacity[1] or hcf == 1):
-            capacity[0] = random.randint(100,999)
+            capacity[0] = random.randint(20, 40)
             _,hcf = _highest_common_factor([capacity[0], capacity[1]])
     container = container_list[random.randint(0, len(container_list)-1)]
     print ("Two {} contain {} liters and {} liters of liquid respectively.  Find the maximum capacity of a container which can measure the liquid of both tanks when used".format(container, capacity[0], capacity[1]),\

From 6e2da33693255192c3c71afb9e6a48be0494fe1e Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Tue, 21 Jun 2016 22:57:50 +0530
Subject: [PATCH 38/39] Renamed file

---
 class06/math/tests/{test_factors.py => test_factors06.py} | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
 rename class06/math/tests/{test_factors.py => test_factors06.py} (86%)

diff --git a/class06/math/tests/test_factors.py b/class06/math/tests/test_factors06.py
similarity index 86%
rename from class06/math/tests/test_factors.py
rename to class06/math/tests/test_factors06.py
index acaeede..8f07d78 100644
--- a/class06/math/tests/test_factors.py
+++ b/class06/math/tests/test_factors06.py
@@ -3,9 +3,9 @@
 import sys
 
 __author__ = 'Ajay'
-
-sys.path.append ('..\\')
-from factors import *
+sys.path.append ('..\\..\\')  #path, if this tests are executed as python tests/test_factors.py
+sys.path.append ('..\\..\\..\\') # path, if these tests are executed from tests directory as python test_factors.py
+from class06.math.factors06 import *
 
 
 class TestFactors(TestCase):
@@ -45,6 +45,8 @@ def test_factors(self):
         self.assertEqual((60, [5,4]), students_running_circles([12, 15]))
         self.assertEqual((7, [3,5,7] ),  journey_time_minimum_hours([21, 35, 49]))
         self.assertEqual((2, [3,4,5]),   journey_time_minimum_hours([6, 8, 10]))
+        self.assertEqual(2, containers_hcf([38, 1160]))
+        self.assertEqual(16, containers_hcf([144, 176]))
 
 if __name__ == '__main__':
     unittest.main()
\ No newline at end of file

From c423855f6766edf895989d43c9a0449ca0563691 Mon Sep 17 00:00:00 2001
From: Ajay <writeajay@gmail.com>
Date: Tue, 21 Jun 2016 23:25:17 +0530
Subject: [PATCH 39/39] WIP: Convert output to HTML

---
 class05/math/factors.py   | 12 +++++++++---
 class06/math/factors06.py |  9 +++++++--
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/class05/math/factors.py b/class05/math/factors.py
index 74701c7..ceb3a99 100644
--- a/class05/math/factors.py
+++ b/class05/math/factors.py
@@ -38,7 +38,9 @@ def nearest_primes():
     higher_prime = i
     answer = "Lower prime: {}, Higher prime: {}".format(lower_prime, higher_prime)
     answers.append(answer)
-    print("The prime numbers that are just before and after {} are _____ and _____.".format(number))
+    question = "The prime numbers that are just before and after {} are _____ and _____.".format(number)
+    print (question)
+    return (question, answer)
 
 
 def list_primes():
@@ -49,7 +51,9 @@ def list_primes():
         if _is_prime(i) == True:
             answer.append(i)
     answers.append(answer)
-    print("The prime numbers between {} and {} are ________".format(number, number + range_size))
+    question = "The prime numbers between {} and {} are ________".format(number, number + range_size)
+    print (question)
+    return (question, answer)
 
 
 def twin_primes():
@@ -61,7 +65,9 @@ def twin_primes():
     else:
         answer = "The numbers are not twin primes."
     answers.append(answer)
-    print("{} and {} are twin primes.  Yes or No?".format(first_prime, first_prime + 2))
+    question = "{} and {} are twin primes.  Yes or No?".format(first_prime, first_prime + 2)
+    print (question)
+    return (question, answer)
 
 
 def factors(number=0):
diff --git a/class06/math/factors06.py b/class06/math/factors06.py
index cc70d2b..ba0e58b 100644
--- a/class06/math/factors06.py
+++ b/class06/math/factors06.py
@@ -52,6 +52,9 @@ def main():
     logging.basicConfig(format='%(asctime)s:%(levelname)s:%(funcName)s:%(message)s', datefmt='%Y%m%d %I:%M:%S %p',
                         filename='class.log', level=logging.INFO)
     unique_id = uuid.uuid1(1)
+    html_text = "<h1>Fractions</h1>\n"
+    html_text += "<h2>Question Paper # {}</h2>\n".format(str(unique_id))
+    html_text += r'<ol>'
     print("Question Paper # {}".format(str(unique_id)))
     # random.seed (os.urandom(5))
     for i in range(0, len(functions)):
@@ -59,9 +62,11 @@ def main():
 
         print ("{i}) ".format(i=i+1), end="")
         f = functions[i]
+        html_text += " <li>"
         f()
-        #logging.info ('Answer  : %s' % answers[i])
-
+        html_text += " </li>\n"
+        logging.info ('Answer  : %s' % answers[i])
+    html_text += r'</ol>'
     print ()
     print("Answer Key # {}".format(str(unique_id)))
     for i in range(0, len (functions)): #len(answers)):