## Population Density Rectangular City Calculator and eTCL Slot Calculator Demo Example

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

## Introduction

gold Here is some eTCL starter code for calculating the number of inhabitants ancient cities. using a rectangular formula. The impetus for these calculations was checking population density in some excavation reports and modern replicas. Most of the testcases involve replicas or models, using assumptions and rules of thumb.

Formula for population of rectangular city was similar to probability of two dimensional distribution density in x and y. The population density function was f(z) = A1*f(x,y)*dx*dy. A1*f(x,y) was population density per unit area and dx*dy was area. The population density A1*f(x,y) was the product of exp(-k1*x) and exp(-k2*y), where A1 is the maximum population density in the center of the countryside or city. The constants -k2 and -k2 were exponential decay constants. Here the f(x) and f(y) components were treated with same exponential decay constant (-.1), but the calculator constants can be changed internally in the program to different constants for exp(-k1*x) and exp(-k2*y). Different decay constants in x and y dimensions may appear where a city is backed up or extended along a coast, river, or road.

The eTCL calculator implemented formula correctly if constant A1 was supplied. A1 was the maximum expected density in inhabitants per square kilometer (ints/sq km), whether in the center of the countryside or city. The model was that the rate (ints/sq km) was maximum at city center and declined exponentially with distance from city center. The "6 for 6" rule for subsistance farmers in countryside was family of 6 inhabitants for 6 hectares. The "6 for 6" rule converted to 6 ints / 6 h. * (100 h / (1 sq km)), 100 ints per sq km. Various references cite ancient cities at 100 inhabitants per square hectare to medieval cities at 300 inhabitants per square hectare. Converting, ancient and medieval cities ranged from 10000 ints/sq km to 30000 ints/sq km. Calculator was primarily written for ancient and medieval cities. The research will have to gather some testcases for modern cities to see if calculator is useful for modern cities.

In planning any software, it is advisable to gather a number of testcases to check the results of the program. Additional significant figures are used to check the eTCL calculator, not to infer the accuracy of inputs and product reports.

### Pseudocode and Equations

```  f(z) = A1*f(x,y)*dx*dy, where f( )= density and dx*dy= area
F(z) = double integral < A1*f(x,y)*dx*dy>
F(z) = double integral < A1*f(x,y)*dx*dy> from x(-inf,+inf) and y(-inf,+inf)
F(z) = 4*double integral < A1*f(x,y)*dx*dy> in positive quadrant x(0,x1) and y(0,+y1)
F(z) = 4*A1*double integral < (exp(-K1*x))*(exp(-K2*y))*dx*dy> in positive quadrant x(0,x1) and y(0,+y1)
F(z) = 4*A1*{1/K1)*(1/K2)*(1.-exp(-K1*x1))*( 1.-exp(-K1*y1)
liters = [* volume_in_cubic_cm .001]
price? = raw materials + labor  +  profit
price? = raw materials + heat process
price? = raw materials + labor
average price per unit  = revenue  / units sold```

### 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

table 1printed in tcl wiki format
quantity value comment, if any
testcase number:1
12.46 :length km
12.46 :width km
300.0 :base constant
46575.480 : possible term1
0.3302 :possible term2
155.2 :city area square km
15383.495 : population number of inhabitants
99.0875 : population density ints per sq km

### References:

• Statistical distributions for experimentalists by Christian Walck
• MT580 Mathematics for Statistics,Jenny A. Baglivo,2006
• StatLec1-5
• DelphiForFun.org, Gary Darby
• Applications of the Double Integral

## Appendix Code

### appendix TCL programs and scripts

```        # pretty print from autoindent and ased editor
# Population density rectangular city calculator
# written on Windows XP on eTCL
# working under TCL version 8.5.6 and eTCL 1.0.1
# gold on TCL WIKI, 10oct2014
package require Tk
namespace path {::tcl::mathop ::tcl::mathfunc}
frame .frame -relief flat -bg aquamarine4
pack .frame -side top -fill y -anchor center
set names {{} {length km:} }
lappend names {width km:}
lappend names {base constant: }
lappend names {possible term1 :}
lappend names {possible term2 :}
lappend names {answers: city area square km: }
lappend names {population number of inhabitants : }
lappend names {population density ints per sq km :}
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 Population Density Rectangular City
from TCL WIKI,
written on eTCL "
tk_messageBox -title "About" -message \$msg }
proc calculate {     } {
global side1 side2 side3 side4 side5
global side6 side7 side8
global cityareasqkm population
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 sidex [* \$side1 1. ]
set sidey [* \$side2 1. ]
set cityareasqkm [* \$sidex \$sidey 1. ]
set excoef1 [* \$sidex -1. .2 .5 ]
set excoef2 [* \$sidey -1. .1 .5 ]
set term_x [- 1. [exp  \$excoef1 ]]
set term_y [- 1. [exp  \$excoef2 ]]
set side5 [* \$term_x \$term_y ]
set basecoeff [* \$side3 1. ]
set quadrant_x [* \$sidex .5 ]
set quadrant_y [* \$sidey .5 ]
set population [* 4. \$basecoeff \$term_x \$term_y ]
set population [* 4. \$basecoeff \$quadrant_x \$quadrant_y ]
set side4 [* 4. \$basecoeff \$quadrant_x \$quadrant_y ]
set population [* \$side4 \$side5 ]
set side6 \$cityareasqkm
set side7 \$population
set side8 [/ \$population \$cityareasqkm ]
}
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 cityareasqkm population
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 :|length km|   |&"
puts "&| \$side2 :|width km| |& "
puts "&| \$side3 :|base constant| |& "
puts "&| \$side4 :| possible term1 |  |&"
puts "&|\$side5 :|possible term2 |  |&"
puts "&| \$cityareasqkm :|city area square km |  |&"
puts "&| \$population :| population number of inhabitants|  |&"
puts "&| \$side8  :| population density ints per sq km|  |&"
}
frame .buttons -bg aquamarine4
::ttk::button .calculator -text "Solve" -command { calculate   }
::ttk::button .test2 -text "Testcase1" -command {clearx;fillup 12.46 12.46 300.0 2E6  0.34 155.0 1.55E4 100.}
::ttk::button .test3 -text "Testcase2" -command {clearx;fillup 64.0 32.0 10000.0 7.9E5   0.618  790. 4.8E6 6181.0 }
::ttk::button .test4 -text "Testcase3" -command {clearx;fillup 128.00 64.0 10000.0 3.16E7   0.862 3162.0  2.7E7 8627.0 }
::ttk::button .clearallx -text clear -command {clearx }
::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 . "Population Density Rectangular City 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   |&"  ```