Version 24 of Ancient Egyptian Double False Position Algorithm, and example eTCL demo calculator, numerical analysis

Ancient Egyptian Double False Position Algorithm and eTCL demo example calculator, numerical analysis

This page is under development. Comments are welcome, but please load any comments in the comments section at the bottom of the page. Please include your wiki MONIKER in your comment with the same courtesy that I will give you. Its very hard to reply intelligibly without some background of the correspondent. Thanks,gold

• Ancient Egyptian Double False Position Algorithm and eTCL demo example calculator, numerical analysis
• Pseudocode Section
  • Testcases Section
    • Testcase 1
    • Testcase 2
    • Testcase 3
  • Screenshots Section
    • figure 1.
  • References:
• Appendix Code
  • appendix TCL programs and scripts
  • Pushbutton Operation
• Comments Section

gold Here is some eTCL starter code for ancient Egyptian double false position algorithm in calculator shell.

For purpose of historical discussion, the single and double false position methods will be lumped together, since the early authors and texts do not separate the terms or have some ambiguity. The rule of single false position is implied in the Ahmes Papyrus, 1650 BCE. On some Babylonian tablets like YBC4652 from 1500 BCE, there are corrected or rescaled false positions for the weight riddle problems. In some double position problems, negative numbers crop up. The Sunzi work in China cites the method of excess and deficit, circa 400 CE. The Chinese report some problems as double excess or double deficit, so there may have been differences the way some false position problems were set up, ref. Nine Chapters Mathematics (in extant copy circa 250 AD). Qusta ibn-Luqa of Baghdad (860 CE) discussed the double false position method in his work. In 1202 CE, Fibonacci wrote the Liber Abaci with some DFP problems. Clavius published some DFP discussion in the Epitome Arithmeticae Practicae in 1583 CE. In the USA, the textbook of Nicolas Pike (1788) presented the DFP rules fairly well, but later school textbooks with more on algebra dropped the issue. At least in Europe, the methods of double false position include early records and notation of negative numbers.

The Ancient Egyptians did not use algebra, but modern algebraic expressions can be developed for the Egyptian methods. The chosen false positions can be set as (3/5)*side_distance and (4/5)*side_distance, as used in the eTCL calculator. The false positions can be loaded in the product and two errors can be developed from initial goal minus product. Set error1 or e1 as (product-fx(f1)) and e2 as (product-fx(f2)). A modern algebraic expression for double false position is solution1 = (e2*f1-e1*f2)/(e2-e1), with the errors as e1&e2 and the false positions as f1&f2 . Using later notation for negative numbers (1600 CE) and multply nom and denom of expression by -1, variant solution2 = (e1*f2-e2*f1)/(e1-e2). Problems and variant solution2 may have been set up to avoid using or loading negative numbers, if e1>e2 or (e1*f2)>(e2*f1) in solution1.

Using modern Algebraic terminology, false position methods are used for one or more linear equations. For solving one linear equation with a single false position, find the number such that c1*x=c2 or fx(x)=c2 in other notation. Single false position would be solution3/f1 = fx/fx(b1), solution3 = (fx/fx(b1)) * f1 . For example 5*x=25 with fx=25 and 3 as the guess, solution3 = (fx/fx(b1)) * f1, solution3 = (25/15)* 3 , reduction (5/3)*3, solution3 = 5. For solution of two false positions with respective errors (e1&e2), the equations by definition are e1=(f1-fx) and e2 = (f2-fx) and as fractions 1= (f1-fx)/e1 and 1= (f2-fx)/e2. Subsituting for 1, (f1-fx)/e1 = (f2-fx)/e2. Using rule of three and Cramer's rule for cross products, (f1-fx)/e1 = (f2-fx)/e2, (e1*(f2-fx))=(e2*(f1-fx)), e1*f2-e1*fx = e2*x1-fx*e2, fx*e2-e1*fx=e2*f1-e1*f2, fx*(e2-e1)=e2*f1-e1*f2, solution fx= (e2*f1-e1*f2)/(e2-e1).

For examples of double false position, 5*x=25 with fx=25 and 3&4 as the guesses, e1=(f1-fx), e1= 5*f1-25, e1=5*3-25,e1 = -10 and e2=(f2-fx), e2=5*4-25, e2 = -5. The solution fx= (e2*f1-e1*f2)/(e2-e1), fx=( -5*3)-(-10*4) / (-15--40),fx= 25/ 5, solution fx = 5. For another example 6*x=36 with fx=36 and 3&4 as the guesses, e1=(f1-fx), e1= 6*f1-36, e1=6*3-36,e1 = -18 and e2=(f2-fx), e2=6*4-36, e2 = -12. The solution fx= (e2*f1-e1*f2)/(e2-e1), fx=( -12*3)-(-18*4) / (-12--18),fx= 36/ 6, solution fx = 6. Using the algebraic equivalent expressions in the Babylonian weight riddle problems, an expression like x-x/7 or x*(1-(1/7)) are still simple multiples of the unknown x.

In the eTCL calculator, two false positions are supplied as guesses as false_position_1 <int <* $side_length >/ 4. 5. >>> and false_position_2 <int <* $side_length >/ 3. 5. >>> . Using the calculation methods, the two false positions produce numbers that fall short or long of the correct answer and the respective differences and errors are used to compute the final solution. A modern algebraic expression for double false position is (e2*f1-e1*f2)/(e2-e1), with the errors as e and the false positions as f. Some aspects of the double false position algorithm are similar to proportions and rule of three, as noted by many authors. The result is provided as </ $difference_cross_products $difference_error >. Note that brackets are set as <&> to avoid triggering wiki linkage.

Pseudocode Section

       # using pseudocode 
       # possible problem instances,  
      initialize algorithm_result = 1.
      set false1 [expr guess * 3/5]
      set false1 [expr guess * 4/5]
      calculate f(false1) and f(false2)
      error1 = product -f1
      error2 = product -f2
      [expr (e2*f1-e1*f2)/(e2-e1)]
      check algorithm 
      f(solution) =? initial product
      check_sum = a+b+c+d+e = original real estate
      set answers and printout with resulting values 
      pseudocode: need test cases > small,medium, giant 
      pseudocode: need testcases within range of expected operation.
      pseudocode: are there any cases too small or large to be solved?

Testcases Section

In planning any software, it is advisable to gather a number of testcases to check the results of the program. The math for the testcases can be checked by pasting statements in the TCL console. Aside from the TCL calculator display, when one presses the report button on the calculator, one will have console show access to the capacity functions (subroutines).

Testcase 1

Testcase 2

Testcase 3

Screenshots Section

figure 1.

References:

• A Remarkable Collection of Babylonian Mathematical Texts, Joran Friberg,
• Chalmers University of Technology, Gothenburg, Sweden
• (major work on Babylonian inheritance problems)
• Muroi, Kazuo (1988). Inheritance problems of Babylonian mathematics.
• Historia Scientiarum , 34, 11-19
• Chabert, J. "Methods of False Position." Ch. 3 in A History of Algorithms: From the Pebble to the Microchip. , 1999.
• John Hannah , False position in Leonardo of Pisa's Liber Abbaci,Historia Mathematica Volume 34 issue 3 2007
• Eugene C. Boman,False Position, Double False Position and Cramer's Rule, College Mathematics Journal
• Howard Eves ,On the practicality of the rule of false position, Mathematics Teacher Volume 51
• Joy B. Easton, the rule of double false position, Mathematics Teacher Volume 60
• Vera Sanford, the rule of false position, Mathematics Teacher Volume 44 issue 5 1951
• Karine Chemla, Reflections on the World-wide History of the Rule of False Double Position, or: How a Loop Was Closed
• Thomas G. Edwards -- Using the Ancient Method of False Position to Find Solutions, Mathematics Teaching in the Middle School Volume 14 issue 4 2008
• Oneliner's Pie in the Sky
• One Liners
• Category Algorithm
• Babylonian Number Series and eTCL demo example calculator
• Brahmagupta Area of Cyclic Quadrilateral and eTCL demo example calculator
• Gauss Approximate Number of Primes and eTCL demo example calculator
• Land surveying in ancient Mesopotamia, M. A. R. Cooper
• Sumerian Approximate Area Quadrilateral and eTCL Slot Calculator Demo Example , numerical analysis
• Thomas G. Edwards, Using the Ancient Method of False Position to Find Solutions
• Joy B. Easton, rule of double false position
• Vera Sanford, rule of false position

Appendix Code

appendix TCL programs and scripts

        # pretty print from autoindent and ased editor
        # Ancient Egyptian Double False Position Algorithm Calculator
        # written on Windows XP on eTCL
        # working under TCL version 8.5.6 and eTCL 1.0.1
        # gold on TCL WIKI, 15feb2017
        package require Tk
        package require math::numtheory
        namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory }
        set tcl_precision 17
        frame .frame -relief flat -bg aquamarine4
        pack .frame -side top -fill y -anchor center
        set names {{} {factor   :} }
        lappend names {side length :}
        lappend names {product: }
        lappend names {answers: false position 1: }
        lappend names {false position 2:}
        lappend names {difference_error : }
        lappend names {difference_cross_products : }
        lappend names {solution result:} 
        foreach i {1 2 3 4 5 6 7 8} {
            label .frame.label$i -text [lindex $names $i] -anchor e
            entry .frame.entry$i -width 35 -textvariable side$i
            grid .frame.label$i .frame.entry$i -sticky ew -pady 2 -padx 1 }
        proc about {} {
            set msg "Calculator for Ancient Egyptian Double False Position Algorithm 
            from TCL WIKI,
            written on eTCL "
            tk_messageBox -title "About" -message $msg } 
       proc calculate {     } {
            global answer2
            global side1 side2 side3 side4 side5
            global side6 side7 side8 
            global testcase_number
            incr testcase_number 
            set side1 [* $side1 1. ]
            set side2 [* $side2 1. ]
            set side3 [* $side3 1. ]
            set side4 [* $side4 1. ]
            set side5 [* $side5 1. ]
            set side6 [* $side6 1. ]
            set side7 [* $side7 1. ]
            set side8 [* $side8 1. ]
            set factor $side1
            set side_length $side2
            set product $side3
            # initialize false positions
            set false_position_1  9.
            set false_position_2  10.
            # reset false positions
            set false_position_1  [int [* $side_length [/ 4. 5. ]]]
            set false_position_2  [int [* $side_length [/ 3. 5. ]]]
            set false_result_1 [- [* $false_position_1  $factor ] $side_length]
            set false_result_2 [- [* $false_position_2  $factor ] $side_length]
            set error_1 [- $product $false_result_1]
            set error_2 [- $product $false_result_2]
            set difference_error [- $error_2 $error_1 ]
  set difference_cross_products [- [* $false_position_1 $error_2 ] [* $false_position_2 $error_1 ] ]
            set result [/ $difference_cross_products $difference_error ]
            set side4 $false_position_1
            set side5 $false_position_2
            set side6 $difference_error  
            set side7 $difference_cross_products 
            set side8 $result 
                    }
        proc fillup {aa bb cc dd ee ff gg hh} {
            .frame.entry1 insert 0 "$aa"
            .frame.entry2 insert 0 "$bb"
            .frame.entry3 insert 0 "$cc"
            .frame.entry4 insert 0 "$dd"
            .frame.entry5 insert 0 "$ee"
            .frame.entry6 insert 0 "$ff" 
            .frame.entry7 insert 0 "$gg"
            .frame.entry8 insert 0 "$hh" 
             }
        proc clearx {} {
            foreach i {1 2 3 4 5 6 7 8 } {
                .frame.entry$i delete 0 end } }
        proc reportx {} {
            global side1 side2 side3 side4 side5
            global side6 side7 side8
            global testcase_number
            console show;
            puts "%|table $testcase_number|printed in| tcl wiki format|% "
            puts "&| quantity| value| comment, if any|& "
            puts "&| $testcase_number:|testcase_number | |&"
            puts "&| $side1 :|factor|   |&"
            puts "&| $side2 :|side length    | |& "  
            puts "&| $side3 :|product | |& "
            puts "&| $side4 :|answers: false position 1 | |&"
            puts "&| $side5 :|false position 2 | |&"
            puts "&| $side6 :|difference_error |  |&"
            puts "&| $side7 :|difference_cross_products |  |&"
            puts "&| $side8 :|solution result|  |&" 
            }
        frame .buttons -bg aquamarine4
        ::ttk::button .calculator -text "Solve" -command { calculate   }
        ::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 4.0 12.  28.0 9.0  7.0  8.0  80.0 10.0}
        ::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 5.0 10.0 30.0 8.0  6.0  10.  80.0  8.0} 
        ::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 6.0 12.  36.0 9.0  7.0  12.0 96.0  8.0 }
        ::ttk::button .clearallx -text clear -command {clearx }
        ::ttk::button .about -text about -command {about}
        ::ttk::button .cons -text report -command { reportx }
        ::ttk::button .exit -text exit -command {exit}
        pack .calculator  -in .buttons -side top -padx 10 -pady 5
        pack  .clearallx .cons .about .exit .test4 .test3 .test2   -side bottom -in .buttons
        grid .frame .buttons -sticky ns -pady {0 10}
               . configure -background aquamarine4 -highlightcolor brown -relief raised -border 30
        wm title . "Ancient Egyptian Double False Position Algorithm Calculator"     

Pushbutton Operation

For the push buttons, the recommended procedure is push testcase and fill frame, change first three entries etc, push solve, and then push report. Report allows copy and paste from console.

For testcases in a computer session, the eTCL calculator increments a new testcase number internally, eg. TC(1), TC(2) , TC(3) , TC(N). The testcase number is internal to the calculator and will not be printed until the report button is pushed for the current result numbers. The current result numbers will be cleared on the next solve button. The command { calculate; reportx } or { calculate ; reportx; clearx } can be added or changed to report automatically. Another wrinkle would be to print out the current text, delimiters, and numbers in a TCL wiki style table as

  puts " %| testcase $testcase_number | value| units |comment |%"
  puts " &| volume| $volume| cubic meters |based on length $side1 and width $side2   |&"  

gold This page is copyrighted under the TCL/TK license terms, this license .

Comments Section