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 and date in your comment with the same courtesy that I will give you. Aside from your courtesy, your wiki MONIKER and date as a signature and minimal good faith of any internet post are the rules of this TCL-WIKI. Its very hard to reply reasonably without some background of the correspondent on his WIKI bio page. Thanks, gold 12Dec2018

- Babylonian Brothers Inheritance Problems Algorithm and TCL demo example calculator, numerical analysis
- Pseudocode Section
- Appendix Code
- Console program for testing concept
- Hidden Comments Section

gold Here are some TCL calculations on brothers inheritance problems algorithm in calculator shell. The initial console program below was used to check the false position concept and generate testcases before loading the calculator shell.

In the cuneiform math problems and coefficient lists on clay tablets, there are coefficient numbers which were used in determining the amount of materials and the daily work rates of the workers. In most cases, the math problem is how the coefficient was used in estimating materials, work rates, and math problems. One difficulty is determining the effective magnitude or power of the number coefficient in the base 60 notation. In cuneiform, numbers in base 60 are written using a relative notation. For example, 20 could represent either 20*3600,20,20/60, 20/3600, or even 1/20. The basic dimensions and final tallies were presented in the cuneiform accounts on clay tablets, but some calculations, some units, and some problem answers (aw shucks!) were left off the tablet. Successive or iterated math solutions are called algorithms and the Babylonian methods are some of the earliest algorithms documented circa 1600 BCE. The TCL procedures are descendants of this idea. The Babylonians did not use algebra notation, decimal notation, or modern units, so the reader will have to bear some anachronisms in the TCL code. At least one approach for the modern reader and using modern terminology is to develop the implied algebraic equations and decimal equivalents from the cuneiform numbers. Then the TCL calculator can be run over a number of testcases to validate the algebraic equations.

The TCL calculator used Babylonian single false position methods for the brother inheritance problem, but that is probably not the only method the Babylonians could use. The Babylonians did not use algebra notation, so the reader will have to bear some anachronisms in the TCL pseudocode. Generally, the brothers inherit land or silver pieces in arithmetic progression with the eldest brother receiving the greatest share and the youngest brother the least. In the extant problems, the number (n) of brothers range from 3 to 10 brothers. Each brother received an integral fraction of his next elder in a stair step fashion. The nominal fraction was 1/<integer number of brothers>. The share of the younger brothers would be x-x/n or x*(1-1/n) in succession. Integer fractions such as <1/6,1/7,1/11> were presented as decrements in the extant problems. The normal solution was presented from elder brother to youngest brother and lowest amount, down the staircase. However, there are some brother inheritance solutions that are presented youngest to elder brother, up the staircase. In some cases, the beginning or setup of the problem is available, without a worked method of solution. Not all problems have sufficient information or initial conditions to solve the problem, however, the analysis has a bag of assumptions from similar problems. The most consistent error check should be that the sum of the brother shares should equal the original bequest.

The TCL calculator computes a false share for each brother, sums the false shares, and rescales the false shares for the solution. Since the Babylonian problem is set up for integer fractions, the initial false share for elder brother is set to be factored by 1/n. Allowing for multiplication by 1/n or dividing n times for the number (n) of the brothers, the initial false share is set to n**n in the eTCL code (for the eldest brother). From an initial false share of n**n, the share x*(1-1/n) for successive brothers is calculated in an iterative solution. The stored shares are summed and the scale factor used for the false shares is real_estate over the sum of false shares.

Algebraic peg points for the brother shares and solution can be developed. The ratio of brother n-1 over n is < x*(1-1/n)*(1-1/n) > / <x*(1-1/n)> . The share of brother n-1 is ratio < x*(1-1/n)*(1-1/n) > / <x*(1-1/n)> times the share of brother n. The average of brother n-1 and n is << x*(1-1/n)*(1-1/n) > * <x*(1-1/n)> > / 2. The average of two brothers shares reduces to (1-1/n)/2. The average share for all brothers is real_estate / number of brothers, which should be in order of magnitude with the elder shares.

For the initial testcase of 5 brothers, some approximate formulas were developed. The average share for all 5 brothers was 60/5 or 12. The exact fraction for younger brother5 was <expr (1.-1./5.)*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)> or 0.40960. The share of younger brother5 was elder brother1 times 0.409 was 7.2802 ( for youngest brother5). The average share between eldest and youngest is (17.85+7.3)/2 or 12.575. Within an order of magnitude , the average share between eldest and youngest approximates the average share for all 5 brothers. By observation, the average share for all 5 brothers equaled int (average share between eldest and youngest brother ). The ratios for real_estate/ number_brothers approximated (brother1 + brother5) /2. Rearranging terms, brother1 approximated 2*(real_estate/ number_brothers ) - brother5. Rearranging terms, brother5 approximated 2*(real_estate/ number_brothers ) - brother1.

There are some rules of thumb that can put outer boundaries on the brother inheritance solutions. The average for all the brothers is real_estate over number of brothers, average = <expr real_estate/ n>. The elder brother1 share approximates the average plus (1/2)* average. The younger brother_n share approximates the average minus (1/2)* average. The distance between brothers is variable on the number line, but a rough approximation for a constant distance or step between brothers is average over (n-1), <expr (real_estate/ n)/(n-1)> . An example is the testcase of 5 brothers receiving estate of 60 silver pieces by the fifth, modern notation of factor (1+1/5). The average for the 5 brothers testcase is <expr real_estate/ n>, <expr 60./5.>, or 12 silver pieces. The elder brother1 share approximates <expr average + (1/2)*average>, <expr 12+6>, 18 silver pieces. The younger brother_5 share approximates <expr average - (1/2)*average>, <expr 12-6>, 6 silver pieces. The approximate solution 6...18 puts upper and lower bounds on the textbook solution of 7.3...17.8. A constant step or slot distance between the 5 brothers would be <expr (real_estate / n)/(n-1)>, <expr (60/ 5)/(4)>, <expr (12/4>, 3. The descending 5 steps would be 18,18-3,18-3-3,18-3-3-3,18-3-3-3-3 or a sequence of 18,15,12,9,6. The stair steps of the constant step sequence 18,15,12,9,6 are within +-2 units of the textbook solution 17.8,14.2,11.4,9.1,7.3. The distances or slots between the 5 brothers were the sequence 3.6,2.8,2.3,1.8. If the elder brothers slot is known, a log solution is also possible. The natural log for (1-1/5) or 0.8 would be <log 0.8> or -0.2231. Multiplying the elder brothers step (3.6) by successive powers of exp(-.2231) should reconstitute the textbook sequence as <expr 3.6*exp(-.2231*b)> for b = 0,1,2,3 as step distances for 3.6,2.88,2.3,1.84 silver pieces. Going up the staircase from the youngest brother, the step distances are <expr 1.84*exp(+.2231*c)> for c = 0,1,2,3. These rules of thumb can put some outer boundaries on the brothers inheritance problems. Given the Babylonian roundoff of significant base_60 figures, error propagation, and obscuration on the tablets, there is bound to be some slop on the tablet solutions.

In Mathematical Cuneiform Texts, Neuberger outlined a brother inheritance problem for 5 brothers. The solution was given as a geometric series of numbers <1 4 2 8 3 14 4 16 5 20?>. The <1 2 3 4 5> are the line numbers on the tablet and omitting the line numbers, the solution was given without calculations as < 4 8 14 16 20?> with a common factor of 4 by inspection. The steps of the brother shares are constant of 4, so no decrement of the form (1+1/n) is necessary. The total inheritance is <expr 4+8+12 +16 +20?> or 60. Dividing the sequence < 4 8 14 16 20?> by the common factor 4 gives < 4 8 14 16 20?> /4 or < 1 2 3 4 5?>, which are the line numbers! Not sure the Babylonians used the line numbers to generate this problem, but the coincident numbers are suggestive. Lets look at several methods of solution for the inheritance sequence < 4 8 14 16 20?> , including those using algebra notation or not known available to the Babylonians (algebra,SFP,DFB, and building series method). For an algebra solution, 1x+2x+3x+4x+5x=60, 15*x=60, x=60/15 or 4. Algebraic series would be 1*4,2*4,3*4,4*4,5*4,=60. For the single false position with an initial guess of fp=3, 15*3=45 , SFP solution=(fx/fx(fp))*fp, (60/45)*3=(4/3)*3=4. A modern algebraic expression for double false position is solution = (e2*f1-e1*f2)/(e2-e1), with the errors as e1&e2 and the false positions as f1&f2 . For the double false position with an initial guess of f1=3 and f2=6, error e1= 15*3-60=-15, error e2=15*7-60=45, DFP solution = (e2*f1-e1*f2)/(e2-e1), (45*3)-(-15*7 )/ (45--15), DFP solution = 240/60=4. The expression expr (45*3)-(-15*7 )/ (45--15) is pastable into the eTCL console. The building series method from youngest brother up the scale is share of youngest brother equals 4 (given in problem) and difference between brothers shares is that of youngest brother (4). Initial shares are built as 4, 4+4, 4+4+4 and continue until the total shares reach 60. The available problem text defined with the youngest brother suggests that the building series method was intended for the 5 brothers. The main differences from this problem and some other inheritance problems is that the series starts or is defined with the youngest brother and that the brother shares have a constant differences (of 4), rather than decrements.

Prpfessor Friberg has reported an interesting math problem on IM 31210 #3, which has three partners sharing an uncertain amount of beer. In the text the glyphs are ki-si-ri, which is transliterated as kisiru. The Akkadian equivalent terms is sikaru “beer” or siras <BEER>. Using linguistic agglutination or extension, the ki term is linked as sprouted grain, so ki-si-ri may mean something like <sprouted grain strained beer >. The total capacity of containers(s) or jars for sharing is uncertain, it possible that the one ban <ten bowls of grain> or a larger jar are meant. A lesser possibility is that the Sumerians brewed beer or beer mash in the larger jars of 25,28,and 30 silas. Usually 300 sila of grain was valued at 1 silver piece, so the value of the product was possibly 2/60 silver piece. But the total amount of 1 ban or ten bowls do not seem to match the 7 and double 7 statements in the algorithm. The middle of the algorithm has statements "you take 7", the beer of one partner or sum of two partners is twice your beer (7), and later, you keep 14 in your mind. The Babylonian mathematicians did not use symbolic algebra, but most modern linguists try to force the tablet arguments into simultaneous equations. The seven and multiple of 7 seem to be striking against the normal Babylonian number with factors of < 2 3 5 >. There is an intuition that multiples of 7 have something to do with a weekly ration of beer for the three partners. With the middle statements, it is believed that gaming with the middle statements in the math problem could get closer to a solution.

Professor Friberg has reported an interesting math problem on IM 31210 #3, which has three partners sharing an uncertain amount of beer. Although amount is uncertain, the TCL program seems to be working correctly, if not all the method on tablet understood here. A companion problem seemed to convert " 1 ban-bi" into 60 units for solving the math problem. Kind of hokey math but the statements on the clay may lead to a starting series like this. The given of the first share is seven. The second share would twice seven would be < expr { 2*7} > or 14. For a constant increase to the third share, the third share should equal < expr { 14.*(14./7) } > or 28. The total shares would be < expr { 7+14+28.) } > or 49. Here we started with first smallest share as 7. This may be considered an alternate solution, but perhaps not a unique or only solution.

Using proportions and gaming, the conventional solution from the TCL calculator might be modified or adapted to unusual features or missing calculations on a clay tablet. The clay tablet MS 1844 in the Schoyen collection has some brother inheritance calculations from about 1900 BCE, as discussed by Joran Friberg in Remarkable Collection of Babylonian Mathematical Texts. The amount of the initial inheritance is either uncertain or not given correctly on the tablet. The calculations showed 7 brothers receiving shares of 1/6 increments starting with the younger brother inheriting 2 silver pieces and going up the staircase. While the eTCL calculator normally goes down the staircase, starting with the elder brother and decrements of (1+1/6). The analysis can generate a trial solution and game the total inheritance, until the 2 silver pieces fall out for the youngest brother. Loading 60 silver, 7 brothers, and (1-1/6) decrement in the eTCL calculator gives a conventional trial solution with 4.645435 silver pieces for the younger brother. Loading 30 silver, 7 brothers, and (1-1/6) decrement in the eTCL calculator gives a conventional trial solution with 2.3227 silver pieces. Loading 25.7 silver, 7 brothers, and (1-1/6) decrement in the eTCL calculator gives a conventional trial solution with 1.989 silver pieces. Using proportions as an alternate method on the unknown total inheritance, 60/unk = 4.645/2, unk= <expr (60*2)/4.645>, total inheritance = 25.8342 silver pieces.

There are some interesting checks or fudging tactics on the brother inheritance problems. The TCL calculator is using the Babylonian False Share Algorithm to solve the Brothers Inheritance problems, but that does not mean the False Share Algorithm is the only possible math solution. Especially for odd number sets of brothers, the middle brother receives close to the average share. For example, 5 brothers share an inheritance of 60 shekels at 1-1/5. From the hand calculations, the average share is expr <60./5> or 12. From the TCL calculator solution, the average share is <expr (17.84+ 14.27+ 11.42+ 9.13+7.31) /5. > or <60./5> or rounded 12. The middle brother or third brother receives 11.42 from the calculator, fairly close to 12. Assuming the middle share, one can multiply 1+1/5 or 6/5 for the fourth brother at < expr (6./5)*12 > for 14.39. The eldest brother would receive < expr 12.* (6./5) * (6./5) > or 17.27. The second brother should received less one fifth than the middle brother or < expr 12.* (4./5) >, 9.6. The fifth brother should receive a factor (4./5)*(4./5) less than the middle brother or < expr 12.* (4./5)*(4./5) >, 7.68. With rounding in base_60 to whole shekels, this approximation gets pretty close to the available tablet solutions. In fact, some of the Babylonian math problems for brothers inheritance do not show their work or the answers. So a cynic might wonder if this short cut might be used rather that the full Babylonian False Position method, which does take a lot more calculations. But for the design and checking of the TCL calculator, the important point is that there is a check or fudge that the hand calculations can use more quickly in alternate calculations.

There is one key statement in the TCL code that sets the decrement or increment: set decrement </ 1. $integer_denominator2 >. Particularly whether that increment is positive or negative. So one can adapt the from an arithmetic sequence for the brothers to a geometric sequence or more complex formula. The linguists have found a number of geometry problems that are an set or sequence of geometric figures like triangles, squares, circles, and trapezoids that grow in size. The reported growth sequence over one set of triangles was <1 3 5 7 11 >. This is an arithmetic sequence since there is a common difference between each term. In this case, adding 2 to the previous term in the sequence gives the next term. The ratio sequence in triangle growth would be < 3/1 5/3 7/5 11/7 >. These math problems would be quite a daring challenge for the Babylonian Base_60 system of regular numbers that contain factors of 2,3, and 5. Note that the growth sequence were prime numbers and ratios of prime numbers. In some cases, the geometric growth problems are written as brothers or soldiers receiving plots of land that increase or decrease in size.

Aside from multiple operators for addition and multiplication, the Babylonian mathematicians used the Arakarum math operation. Essentially in reciprocal and algorithm operations, Arakarum means take a take reciprocal of a number N and multiply by another factor usually integer 2, 3, or some other factor, < 2./N1 >. The Arakarum is a combined term of ara for raise or multiply and karum which means factor. In the older texts, the phrases usually was Arakarum 2, Arakarum 3, and Arakarum N1 in the texts. Some example values in modern notation are < 2./N1 >, < 3./N1 >, & < 5./N1 >. But for most cuneiform texts, the factor number in the Arakarum operation was either dropped for abbreviation, assumed to be 2 , or assumed known from context.

For the Arakarum operation, multiplication is associative in that < (1/N1) * 2 = 2* (1/N1) >. So there are instances where the reciprocal is taken first and then multiplied by the factor as well as instances where the factor is applied first and then the reciprocal is taken. Sometimes the Arakarum operation was off the math tablet, so the order of multiplication and reciprocation is not known.

The Babylonian number system used regular numbers with factors of < 2,3,5 >, so multiplication by two would assure the number was changed to an even number. Not sure about the entire number line, but multiplication by some factor would ensure the new number was a factorable number and especially not a prime number. In some of the Babylonian market rate algorithms, the appearance of the Arakarum math operation is striking because there seems no purpose to the modern reader. In most instances, the Arakarum math operation is either factored back out in the line of calculations or else not reported in the answer. Whether caused by a tablet copyist error, line dropped, or scribal mistake, sometimes the Arakarum factor of 2 and other factors was sometimes introduced and not removed.

There are a number of "scratch" tablets with three or four columns of numbers which highlight the Arakarum operation. While the Arakarum operation is a mid stage in most Brothers Inheritance problems, believe that additional study on the Arakarum operation may furnish some insights into Babylonian number theory.

It is difficult to judge the impact of these historic Brothers Inheritance problems on later mathematicians, but Al-Khuwarizmi has about a third of his algebra work on Islamic inheritance problems. Some of the Brothers Inheritance problems involving land or striped triangles have a similar appearance to the numerical integration using trapezoidal strips or formulas. In a few cases, the Brothers Inheritance problems are asking for the total amount of land or inheritance rather than computing individual shares or the constant increase. Although not all the work problems have swank sketches or graphs, the set up of the some problems including piece wise sections suggest elements of modern numerical integration.

# using pseudocode # possible problem instances, 3 to 10 brothers initialize algorithm_result = 1. nominal fraction was 1/<integer number of brothers> eldest share is n**n, so factorable n times in Babylonian integer math share of the younger brothers would be x-x/n or x*(1-1/n) in succession. ??? code [expr xxx*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)], ?.32768? scale factor = real_estate over the sum of false shares check algorithm 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? [expr (1.-1./5.)*(1.-1./5.)*(1.-1./5.)*(1.-1./5.)] =0.40960 elder brother1 * 0.409 = 7.2802 ( youngest brother5) average share for all 5 brothers = 60/5 = 12 average share between eldest and youngest is (17.85+7.3)/2 or 12.575 theorem that average share for all 5 brothers = int (average share between eldest and youngest ) within order of magnitude , average share between eldest and youngest ~~ average share for all 5 brothers real_estate/ number_brothers ~~~ (brother1 + brother5) /2 brother1 ~~ 2*(real_estate/ number_brothers ) - brother5 brother5 ~~ 2*(real_estate/ number_brothers ) - brother1

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).

table 1 | printed in | tcl wiki format |
---|---|---|

quantity | value | comment, if any |

1: | testcase_number | |

60.0 : | initial real estate | |

5.0 : | number of brothers | |

5.0 : | less fraction 1/b (usually number of brothers) | |

17.848 : | answers: elder brother | |

14.278 : | 2nd brother | |

11.423 : | 3ird brother | |

9.138 : | 4th brother | |

7.310 : | 5th brother |

brother brother1 inherits 500.0 false shares but real shares are 17.848 brother brother2 inherits 400.0 false shares but real shares are 14.278 brother brother3 inherits 320.0 false shares but real shares are 11.423 brother brother4 inherits 256.0 false shares but real shares are 9.138 brother brother5 inherits 204.800 false shares but real shares are 7.310 sum of false shares is 1680.8 scale factor for false shares is 0.0356 real estate or inheritance is 60. average for n brothers is real_estate/ brothers 12.0 upper bound is average + .5*average 18.0 lower bound is average - .5*average 6.0 bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 3.0 Ref. similar to YBC9856 5 brothers receive 60 shekels. #originally published by Neugebauer and Sachs in MCT possible Neugebauer solution 4,8,12,16,20 with constant delta.

2: | testcase_number |

120.0 : | initial real estate |

5.0 : | number of brothers |

5.0 : | less fraction 1/b (usually number of brothers) |

35.697 : | answers: elder brother |

28.557 : | 2nd brother |

22.846 : | 3ird brother |

18.277 : | 4th brother |

14.621 : | 5th brother |

3: | testcase_number |

3600.0 : | initial real estate |

5.0 : | number of brothers |

5.0 : | less fraction 1/b (usually number of brothers) |

1070.918 : | answers: elder brother |

856.734 : | 2nd brother |

685.387 : | 3ird brother |

548.310 : | 4th brother |

438.648 : | 5th brother |

table 4 | printed in | tcl wiki format |
---|---|---|

quantity | value | comment, if any |

4: | testcase_number | |

60.0 : | initial real estate | |

4.0 : | number of brothers | |

7.0 : | less fraction 1/b (usually number of brothers) | |

18.624 : | answers: elder brother | |

15.963 : | 2nd brother | |

13.683 : | 3ird brother | |

11.728 : | 4th brother | |

0. : | 5th brother | |

15.0 : | for check, average_all_brothers | |

22.5 : | for check, upper_bound | |

7.5 : | for check, lower_bound | |

5.0 : | for check, bound_constant_step, if no 1/n less | |

22.5 17.5 12.5 7.5 : | for check, list bound_if_constant_steps, if no 1/n less | |

706.905 : | total false position | |

60.0: | for check, total_false_position * sf =? initial real_estate | |

18.624 15.963 13.683 11.728 : | list of scaled brother shares |

4 brothers receive 60? at fraction (1-1/7) elder brother has 7*3 for false share. brother brother4 inherits 294.0 (elder brother) brother brother3 inherits 252.0 brother brother2 inherits 216.0 brother brother1 inherits 185.142 (youngest brother) sum of false shares is 1105.836 scale factor for false shares is 0.0332 elder brother's share is (7**3)*(36.8 / 1105.836) answer = 11.414 younger brother's share is last*(36.8 / 1105.836) answer = 5.281 # hand calculations follow (good) [expr (1.-1./7.)*(1.-1./7.)*(1.-1./7.)]= 0.6297 youngest brother4 = [expr 0.6297* 11.433]= 7.1993 1st brother[expr (5.*60+43.)*(2./60.)] = 11.433 2nd brother=[expr (4.*60+54.)*(2./60.)]= 9.8 3ird brother=[expr (4.*60+12.)*(2./60.)]=8.4 4th brother=[expr (3.*60+36.)*(2./60.)]= 7.2 [expr 11.43+9.8+8.4+7.2] = 36.830 Ref. MS1844, 1d, Joran Friberg, difficulty with inheritance amount

4b: | check on different changed amount of 36.8 silver pieces, ref. Friberg |
---|---|

11.422 : | answers: elder brother |

9.791 : | 2nd brother |

8.392 : | 3ird brother |

7.193 : | 4th brother |

table 5 | printed in | tcl wiki format |
---|---|---|

quantity | value | comment, if any |

5: | testcase_number | |

100.0 : | initial real estate | |

10.0 : | number of brothers | |

10.0 : | less fraction 1/b (usually number of brothers) | |

15.353 : | answers: elder brother | |

13.818 : | 2nd brother | |

12.436 : | 3ird brother | |

11.192 : | 4th brother | |

10.0733 : | 5th brother | |

10.0 : | for check, average_all_brothers | |

15.0 : | for check, upper_bound | |

5.0 : | for check, lower_bound | |

1.111 : | for check, bound_constant_step, if no 1/n less | |

15.0 13.888 12.777 11.666 10.555 9.444 8.333 7.222 6.111 5.0 : | for check, list bound_if_constant_steps, if no 1/n less | |

58618940391.0 : | total false position | |

100.0: | for check, total_false_position * sf =? initial real_estate | |

15.353 13.818 12.436 11.192 10.07337 9.066 8.159 7.343 6.609 5.9482 : | list of scaled brother shares | |

overflow table entries | overflow brothers, esp for N > 5 | |

15.353 : | 1 nth brother | |

13.818 : | 2 nth brother | |

12.436 : | 3 nth brother | |

11.192 : | 4 nth brother | |

10.073 : | 5 nth brother | |

9.066 : | 6 nth brother | |

8.159 : | 7 nth brother | |

7.343 : | 8 nth brother | |

6.609 : | 9 nth brother | |

5.9482 : | 10 nth brother |

10 brothers receive 100? at fraction (1-1/10)? brother brother1 inherits 562.5 false shares but real shares are 15.353 brother brother2 inherits 506.25 false shares but real shares are 13.818 brother brother3 inherits 455.625 false shares but real shares are 12.436 brother brother4 inherits 410.0625 false shares but real shares are 11.1926 brother brother5 inherits 369.056 false shares but real shares are 10.0733 brother brother6 inherits 332.150 false shares but real shares are 9.066 brother brother7 inherits 298.935 false shares but real shares are 8.159 brother brother8 inherits 269.042 false shares but real shares are 7.343 brother brother9 inherits 242.137 false shares but real shares are 6.609 brother brother10 inherits 217.924 false shares but real shares are 5.948 sum of false shares is 3663.683 scale factor for false shares is 0.0272 real estate or inheritance is 100. average for n brothers is real_estate/ brothers 10.0 upper bound is average + .5*average 15.0 lower bound is average - .5*average 5.0 bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 1.111 elder brother's share is (10**3)*(100. / 5861.894) 17.059 younger brother's share is last*(100. / 5861.894) 5.948 # hand calculations follow (good) average = 120/10 = 12 [expr (1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)*(1.-1./10.)]= 0.38742 = factor for youngest brother. 8th brother cited as 8 silver pieces 8th brother calculated as 430.46*0.01705 or 7.3 silver pieces as computer solution stands above. elder brother1 approximates [expr 2*(100./10.)-3.] or 17, order of magnitude This problem has factor 1+1/n omitted or obscured, Another problem cited factor of eleventh part or algebraic 1+1/11. Maybe this factor should be 11 instead of 10. Note that the 1+1/n factor may be set at a prime number, even when there are 4 brothers, the factor is seventh or 1+1/7. #Refs. YBC9856, problem 1, Melville YBC 9856, Muroi, #originally published by Neugebauer and Sachs in MCT [15:99-100]. #Refs. similar in STR362, published by Neugebauer in MKT I [14: 239-243].

table 6 | printed in | tcl wiki format |
---|---|---|

quantity | value | comment, if any |

6: | testcase_number | |

72.0 : | initial real estate | |

4.0 : | number of brothers | |

6.0 : | less fraction 1/b (usually number of brothers) | |

23.177 : | answers: elder brother | |

19.314 : | 2nd brother | |

16.095 : | 3ird brother | |

13.412 : | 4th brother | |

0. : | 5th brother | |

18.0 : | for check, average_all_brothers | |

27.0 : | for check, upper_bound | |

9.0 : | for check, lower_bound | |

6.0 : | for check, bound_constant_step, if no 1/n less | |

27.0 21.0 15.0 9.0 : | for check, list bound_if_constant_steps, if no 1/n less | |

662.716 : | total false position | |

72.0: | for check, total_false_position * sf =? initial real_estate | |

23.177 19.314 16.095 13.412 : | list of scaled brother shares |

4 brothers receive 72? at fraction (1-1/6)? This problem has the inheritance omitted or obscured. However, almost certain number inheritance is 1 mina (60 bucks) and some 1/6 fraction multiple, like 66 or 72 silver pieces. Solution is not repeat not given. brother brother1 inherits 192.0 false shares but real shares are 26.331 brother brother2 inherits 144.0 false shares but real shares are 19.748 brother brother3 inherits 108.0 false shares but real shares are 14.811 brother brother4 inherits 81.0 false shares but real shares are 11.108 sum of false shares is 525.0 scale factor for false shares is 0.137 real estate or inheritance is 72. average for n brothers is real_estate/ brothers 18.0 upper bound is average + .5*average 27.0 lower bound is average - .5*average 9.0 bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 6.0 # hand calculations follow (good) average = 72/4 = 18 silver pieces [expr (1.-1./6.)*(1.-1./6.)*(1.-1./6.)] or fraction 0.5787037 for youngest brother elder brother1 approximates [expr 2*(72./4.)-3.] or 33 silver pieces, order of magnitude younger brother4 approximates [expr 33*.5787] or 19.097 silver pieces, order of magnitude Ref. MS2830, problem 1c, Joran Friberg

table 7 | printed in | tcl wiki format |
---|---|---|

quantity | value | comment, if any |

7: | testcase_number | |

1440.0 : | initial real estate | |

7.0 : | number of brothers | |

7.0 : | less fraction 1/b (usually number of brothers) | |

311.648 : | answers: elder brother | |

267.127 : | 2nd brother | |

228.966 : | 3ird brother | |

196.257 : | 4th brother | |

168.220 : | 5th brother | |

205.714 : | for check, average_all_brothers | |

308.571 : | for check, upper_bound | |

102.857 : | for check, lower_bound | |

34.285 : | for check, bound_constant_step, if no 1/n less | |

308.571 274.285 240.0 205.714 171.428 137.142 102.857 : | for check, list bound_if_constant_steps, if no 1/n less | |

3261642.0 : | total false position | |

1440.0: | for check, total_false_position * sf =? initial real_estate | |

311.648 267.127 228.966 196.257 168.220 144.188 123.590 : | list of scaled brother shares | |

overflow table entries | overflow brothers, esp for N > 5 | |

311.648 : | 1 nth brother | |

267.127 : | 2 nth brother | |

228.966 : | 3 nth brother | |

196.257 : | 4 nth brother | |

168.220 : | 5 nth brother | |

144.188 : | 6 nth brother | |

123.590 : | 7 nth brother |

7 brothers receive 1440? at fraction (1-1/7)? Solution is not repeat not given. brother brother1 inherits 14406.0 false shares but real shares are 311.648 brother brother2 inherits 12348.0 false shares but real shares are 267.127 brother brother3 inherits 10584.0 false shares but real shares are 228.966 brother brother4 inherits 9072.0 false shares but real shares are 196.257 brother brother5 inherits 7776.0 false shares but real shares are 168.220 brother brother6 inherits 6665.142 false shares but real shares are 144.188 brother brother7 inherits 5712.979 false shares but real shares are 123.590 sum of false shares is 66564.122 scale factor for false shares is 0.0216 real estate or inheritance is 1440. average for n brothers is real_estate/ brothers 205.714 upper bound is average + .5*average 308.571 lower bound is average - .5*average 102.857 bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 34.285 # hand calculations follow (good) average = [expr 1440./7]= 205.714 silver pieces [expr (1.-1./7.)*(1.-1./7.)*(1.-1./7.)*(1.-1./7.)*(1.-1./7.)*(1.-1./7.)]= 0.3965 youngest brother7 ~~ [expr 0.3965 * 310.7]= 123.215 silver pieces, order of magnitude elder brother1 approximates 310.7 silver pieces, order of magnitude Ref. MS1844, corrected problem 1, Joran Friberg

table 8 | printed in | tcl wiki format |
---|---|---|

quantity | value | comment, if any |

8: | testcase_number | |

61.0 : | initial real estate | |

4.0 : | number of brothers | |

11.0 : | less fraction 1/b (usually number of brothers) | |

17.494 : | answers: elder brother | |

15.903 : | 2nd brother | |

14.458 : | 3ird brother | |

13.143 : | 4th brother | |

0. : | 5th brother | |

15.25 : | for check, average_all_brothers | |

22.875 : | for check, upper_bound | |

7.625 : | for check, lower_bound | |

5.083 : | for check, bound_constant_step, if no 1/n less | |

22.875 17.791 12.708 7.625 : | for check, list bound_if_constant_steps, if no 1/n less | |

811.485 : | total false position | |

60.999: | for check, total_false_position * sf =? initial real_estate | |

17.494 15.903 14.458 13.143 : | list of scaled brother shares |

4 brothers receive 61 at fraction (1-1/11)? Solution is not repeat not given. brother brother1 inherits 232.727 false shares but real shares are 17.494 brother brother2 inherits 211.570 false shares but real shares are 15.903 brother brother3 inherits 192.336 false shares but real shares are 14.458 brother brother4 inherits 174.851 false shares but real shares are 13.143 sum of false shares is 811.485 scale factor for false shares is 0.0751 real estate or inheritance is 61. average for n brothers is real_estate/ brothers 15.25 upper bound is average + .5*average 22.875 lower bound is average - .5*average 7.625 bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 5.0833 Ref. MS2830, problem 1e, Joran Friberg

table 9 | Babylonian Method of False Shares | printed in tcl format |
---|---|---|

quantity | value | comment, if any |

9: | testcase_number | |

60.0 : | initial and total estate (usually 60 shekels or 1 unit) | |

5.0 : | number of brothers | |

5.0 : | share of 5th brother equals increment and increasing up staircase | |

12. : | average per brother | expr {60/5.} = 12 |

12. | rule of thumb, middle brother has average share. | check on answer? |

X+X+X+X+X | elder brother | expr {5*4} = 20 |

X+X+X+X | 2nd brother | expr {4*4} = 16 |

X+X+X | 3ird brother | expr {3*4} =12 |

X+X | 4th brother | expr {2*4} = 8 |

X | 5th brother | expr {1*4} = 4 |

>>>>> total number of false shares <<<<< | ||

15X | solution, 5th brother = 4, etc | X=expr { 60/15.} or 4 |

1 4 2 8 3 12 4 16 5 20 | Babylonian answer with no work shown on tablet |

Note: a. Reference. YBC 9856, originally published by Neugebauer and Sachs in , Also Sequences and Series in Old Babylonian Mathematics, Duncan J. Melville b. Babylonian Brothers Inheritance problems. Each brother receives a different value of false shares. The total number of false shares is scaled from the original total estate or treasure. In the early problems, each share had a constant increment or decrement from the preceding share. More complex problems in Brothers Inheritance have different and non constant increments for some brothers, representing additional simultaneous equations to be solved.

table 10 | Babylonian Method of False Shares | printed in tcl format |
---|---|---|

quantity | value | comment, if any |

10: | testcase_number | |

100.0 : | initial and total estate (usually 60 shekels or 1 unit) | |

10.0 : | number of brothers | |

6.0 : | share of 8th brother and increasing up staircase | |

10. : | average per brother | expr {100/10.} = 10 |

10. | rule of thumb, middle brother has average share. | check on answer? |

X+X+X+X+X+X+X+X+X+X | elder brother | < expr { 10*1.818 } >= 18.18, rounded to 19 |

X+X+X+X+X+X+X+X+X | 2nd brother | < expr { 9*1.818 } > =16.3, rounded to 17 |

X+X+X+X+X+X+X+X | 3ird brother | < expr { 8*1.818 } > =14.5, rounded to 15 |

X+X+X+X+X+X+X | 4th brother | < expr { 7*1.818 } > = 12.726, rounded to 13 |

X+X+X+X+X+X | 5th brother | < expr { 6*1.818 } > = 10.9, rounded to 11 |

X+X+X+X+X : | 6 nth brother | < expr { 5*1.818 > = 9.09, rounded to 10 |

X+X+X+X : | 7 nth brother | < expr { 4*1.818 } > = 7.272, rounded to 8 |

X+X+X : | 8 nth brother | < expr {3*1.818= 5.454 > , rounded to 6 |

X+X : | 9 nth brother | < expr {2*1.818= 3.636 > , rounded to 4 |

X : | 10 nth brother | < expr {1*1.818= 1.818 > , rounded to 2 |

>>>>> total number of false shares <<<<< | ||

55X | solution, 10th brother = 1.818, etc | X=expr { 100/55.} or 1.818 |

Note: Reference. Str 362, published by Neugebauer in MKT, Also Sequences and Series in Old Babylonian Mathematics, Duncan J. Melville, also New Mathematical Cuneiform Texts, by Jöran Friberg & Farouk N.H. Al-Rawi. My solution used decimal fractions, but is slightly off the tablet & textbook solution for some unaccounted reason.

table 11 | printed in | tcl format |
---|---|---|

quantity | value | comment, if any |

11: | testcase_number | |

49.0 : | initial and total estate (usually 60 shekels or 1 unit) | |

3.0 : | number of brothers | |

2.0 : | next share factor (usually 1-1/b, or else 1-1/c, or else 1+1/c) | |

28.0 : | answers: elder brother | |

14.0 : | 2nd brother | |

7.0 : | 3ird brother | |

0. : | 4th brother | |

0. : | 5th brother | |

16.333333333333332 : | for check, average_all_brothers | |

24.5 : | for check, upper_bound | |

8.1666666666666661 : | for check, lower_bound | |

8.1666666666666661 : | for check, bound_constant_step, if no 1/n less | |

24.5 16.333333333333336 8.1666666666666679 : | for check, list bound_if_constant_steps, if no 1/n less | |

23.625 : | total false position | |

49.0: | for check, total_false_position * sf =? initial real_estate | |

28.0 14.0 7.0 : | list of scaled brother shares |

Notes: Professor Friberg has reported an interesting math problem on IM 31210 #3, which has three partners sharing an uncertain amount of beer. Although amount is uncertain, the TCL program seems to be working correctly, if not all the method on tablet understood here. A companion problem seemed to convert " 1 ban-bi" into 60 units for solving the math problem. Here we started with first smallest share as 7. This may be considered an alternate solution, but perhaps not a unique or only solution.

- 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
- The Algebra of Inheritance: A Rehabilitation of Al-Khuwarizmi,
- Solomon Gandz Source: Osiris, Vol. 5 (1938), pp. 319-391
- A Note to Kazuo Muroi, Inheritance Problems in
- Susa Mathematical Text No. 26, Jens Hoyrupt
- Mathematical Cuneiform Texts, Neugebauer and Sachs
- Extraction of Cube Roots in Babylonian Mathematics, Kazuo Muroi, Centaurus Volume 31, issue 3, 1988
- Babylonian Mathematical Texts II-III Author(s): A. Sachs Source: Journal of Cuneiform Studies, Vol. 6, No. 4
- (1952), pp. 151-156 Published by: The American Schools of Oriental Research
- Computing the Cube Root, Ken Turkowski, Apple Computer Technical Report #KT-32 10 February 1998
- Approximating Square Roots and Cube Roots , Ali Ibrahim Hussenom, 2014/11/04
- Aryabhata’s Root Extraction Methods, Abhishek Parakh , Louisiana State University, Aug 31st 2006
- Another Method for Extracting Cube Roots, Brian J. Shelburne,
- Dept of Math and Computer, Science Wittenberg University
- Jeanette C. Fincke* and Mathieu Ossendrijver* BM 46550 – a Late Babylonian Mathematical Tablet with
- Computations of Reciprocal Numbers,Zeitschrift für Assyriologie 2016; 106(2): 185–197
- Interpretation of reverse algorithms in several mesopotamian texts, Christine Proust
- A Geometric Algorithm with Solutions to Quadratic Equations
- in a Sumerian Juridical Document from Ur III Umma
- Joran Friberg, Chalmers University of Technology, Gothenburg, Sweden
- google search engine <Trapezoid area bisection>
- Wikipedia search engine <Trapezoid area >
- mathworld.wolfram.com, Trapezoid and right trapezoid
- Mathematical Treasure: Old Babylonian Area Calculation, uses ancient method
- Frank J. Swetz , Pennsylvania State University
- Wikipedia, see temple of Edfu, area method used as late as 200 BC in Egypt.
- 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
- www.britannica.com, topic, mathematics trapezoid
- Sumerian Equivalency Values, Ratios, and the Law of Proportions with Demo Example Calculator
- Babylonian Sexagesimal Notation for Math on Clay Tablets in Console Example
- Babylonians Tracked Jupiter With Advanced Tools: Trapezoids, Michael Greshko, news.nationalgeographic.com
- Geometry in Babylonian Astronomy, Cluster of Excellence Topology, Humboldt University of Berlin
- Mathieu Ossendrijver: „Ancient Babylonian astronomers calculated Jupiter’s position
- from the area under a time-velocity graph“, in: Science, January 29, 2016.
- Late Babylonian Field Plans in the British Museum, books.google.com/books
- Karen Rhea Nemet-Nejat
- Late Babylonian Surface Mensuration Author(s): Marvin A. Powell Source: jstor
- translation: trapezoid in two babylonian astronomical cuneiform
- texts for jupiter (act 813 & act 817) from the seleucid era , 310 BC -75 AD
- Otto Neugebauer, Astronomical Cuneiform Texts, 3 Vols.
- Lund Humphreys, London, 1955:405,430-31.
- DeSegnac, MS 3908 A RE-CONSTRUCTION, D.A.R. DeSegnac
- A draft for an essay
- DeSegnac, MENTAL COMPUTING OF THREE ARCHAIC
- MESOPOTAMIAN PUZZLES W 20044, 35, W 20044, 20 & W 20214, essay draft
- DeSegnac, HARMONY OF NUMBERS I and II, D.A.R. DeSegnac, A draft for an essay

# pretty print from autoindent and ased editor # Babylonian Brothers Inheritance Problems Algorithm calculator # written on Windows XP on eTCL # working under TCL version 8.5.6 and 1.0.1 # gold on TCL WIKI, 25jan2017 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 {{} { initial estate :} } lappend names { number of brothers (b) :} lappend names { next brother etc, his elder share less fraction (usually 1/b ) : } lappend names { answers: elder brother : } lappend names { 2nd brother :} lappend names { 3ird brother : } lappend names { 4th brother : } lappend names { 5th brother :} 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 Babylonian Brothers Inheritance Problems 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 global real_scaled_results number_of_brothers check_if_constant_steps global average_all_brothers upper_bound lower_bound bound_constant_step global total_false_position scale_factor 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 real_estate $side1 set number_of_brothers $side2 set integer_denominator2 $side3 # initialize placeholder answer set result 1. set side4 0. set side5 0. set side6 0. set side7 0. set side8 0. #set brothers $number_of_brothers set decrement [/ 1. $integer_denominator2 ] set inheritance [** $number_of_brothers $number_of_brothers] set keeper [int [- $number_of_brothers 1] ] set keeperlist {} set i [int $number_of_brothers ] set total_false_position 0. while {$i>0} { set inheritance [- $inheritance [* $inheritance $decrement]] if { $inheritance < 0 } { break } #set side$keeper $inheritance set keeperlist [ lappend keeperlist $inheritance ] set total_false_position [+ $total_false_position $inheritance ] incr i -1 } set scale_factor [/ $real_estate $total_false_position ] set counter 4 set real_scaled_results {} foreach item $keeperlist { lappend real_scaled_results [* $item $scale_factor ] set side$counter [* $item $scale_factor ] incr counter if { [- $counter 4 ] > $number_of_brothers } {break} } # begin bounds and error checks set average_all_brothers [expr $real_estate/ $number_of_brothers ] set upper_bound [+ $average_all_brothers [* 0.5 $average_all_brothers]] set lower_bound [- $average_all_brothers [* 0.5 $average_all_brothers]] set bound_constant_step [expr ($real_estate/ $number_of_brothers)/ ($number_of_brothers-1.) ] set check_if_constant_steps {} set counter5 0 foreach item $keeperlist {lappend check_if_constant_steps [- $upper_bound [* $counter5 $bound_constant_step ]] incr counter5 } } 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 global real_scaled_results number_of_brothers check_if_constant_steps global average_all_brothers upper_bound lower_bound bound_constant_step global total_false_position scale_factor console show; puts "%|table $testcase_number|printed in| tcl wiki format|% " puts "&| quantity| value| comment, if any|& " puts "&| $testcase_number:|testcase_number | |& " puts "&| $side1 :|initial real estate | |&" puts "&| $side2 :|number of brothers | |& " puts "&| $side3 :|less fraction 1/b (usually number of brothers) | |& " puts "&| $side4 :|answers: elder brother | |&" puts "&| $side5 :|2nd brother | |&" puts "&| $side6 :|3ird brother | |&" puts "&| $side7 :|4th brother | |&" puts "&| $side8 :|5th brother | |&" puts "&| $average_all_brothers :|for check, average_all_brothers | |&" puts "&| $upper_bound :|for check, upper_bound | |&" puts "&| $lower_bound :|for check, lower_bound | |&" puts "&| $bound_constant_step :|for check, bound_constant_step, if no 1/n less | |&" puts "&| $check_if_constant_steps :|for check, list bound_if_constant_steps, if no 1/n less | |&" puts "&| $total_false_position :|total false position | |&" puts "&| [* $total_false_position $scale_factor]:|for check, total_false_position * sf =? initial real_estate | |&" puts "&| $real_scaled_results :|list of scaled brother shares | |&" # begin following for overflow brothers, esp for brothers N > 5 set counter 1 if {$number_of_brothers > 5 } {puts "&| overflow table entries |overflow brothers, esp for N > 5 | |&"} foreach item $real_scaled_results { if {$number_of_brothers < 6 } {break} puts "&| $item :|$counter nth brother | |&" incr counter 1 if { $counter > $number_of_brothers } {break}} # end overflow section } frame .buttons -bg aquamarine4 ::ttk::button .calculator -text "Solve" -command { calculate } ::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 60. 5. 5.0 17. 14. 11. 9. 7.0} ::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 120. 5.0 5.0 35. 28. 22. 18. 14.0 } ::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 3600. 5.0 5.0 1070. 856. 685. 548. 438.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 . "Babylonian Brothers Inheritance Problems Algorithm"

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 |&"

# pretty print from autoindent and ased editor # initial console program, Babylonian Brothers false shares # written on Windows XP on eTCL # working under TCL version 8.5.6 and eTCL 1.0.1 # gold on TCL WIKI, 10feb2017 package require Tk package require math::numtheory namespace path {::tcl::mathop ::tcl::mathfunc math::numtheory } set tcl_precision 17 console show set brothers 10 set i 10 set decrement [/ 1. $brothers ] set inheritance [expr 5**4] set false_sum 0 set real_estate 100. # can not have scale factor without solving deck once while {$i>0} { set inheritance [- $inheritance [* $inheritance $decrement]] if { $inheritance < 0 } { break } set side$i $inheritance set false_sum [+ $false_sum $inheritance] incr i -1 } set brothers 10 set i 10 set g 1 set decrement [/ 1. $brothers ] set inheritance [expr 5**4] #set false_sum 0 set real_estate 100. set scale_factor [expr $real_estate / $false_sum ] set false_sum 0 # begin second solution with solved scale factor for output while {$i>0} { set inheritance [- $inheritance [* $inheritance $decrement]] if { $inheritance < 0 } { break } puts "brother brother$g inherits $inheritance false shares but real shares are [expr $scale_factor*$inheritance ] " set side$i $inheritance set false_sum [+ $false_sum $inheritance] incr i -1 incr g 1 } puts " sum of false shares is $false_sum " puts " scale factor for false shares is [expr $real_estate / $false_sum ]" puts " real estate or inheritance is $real_estate " puts " average for n brothers is real_estate/ brothers [expr $real_estate/ $brothers ] " puts " upper bound is average + .5*average [expr ($real_estate/ $brothers) + (.5*$real_estate/ $brothers) ]" puts " lower bound is average - .5*average [expr ($real_estate/ $brothers) - (.5*$real_estate/ $brothers) ]" puts " bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is [expr ($real_estate/ $brothers)/ ($brothers-1.) ]"

output for false shares

brother brother1 inherits 562.5 false shares but real shares are 15.353 brother brother2 inherits 506.25 false shares but real shares are 13.818 brother brother3 inherits 455.625 false shares but real shares are 12.436 brother brother4 inherits 410.0625 false shares but real shares are 11.192 brother brother5 inherits 369.056 false shares but real shares are 10.073 brother brother6 inherits 332.150 false shares but real shares are 9.066 brother brother7 inherits 298.935 false shares but real shares are 8.159 brother brother8 inherits 269.042 false shares but real shares are 7.343 brother brother9 inherits 242.137 false shares but real shares are 6.609 brother brother10 inherits 217.924 false shares but real shares are 5.948 sum of false shares is 3663.683 scale factor for false shares is 0.0272 real estate or inheritance is 100. average for n brothers is real_estate/ brothers 10.0 upper bound is average + .5*average 15.0 lower bound is average - .5*average 5.0 bound:: constant distance or slot (real_estate/ brothers)/(brothers-1.) is 1.111

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

Category Numerical Analysis | Category Toys | Category Calculator | Category Mathematics | Category Example | Toys and Games | Category Games | Category Application | Category GUI |