One Line Proc Follow up V7

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 20Feb2024

• • Title: One Line Proc Follow up V7
  • Preface
  • Not a Replacement for TCL Core
  • Brief History of One Line Programs
  • Simple One Line Hello Procedure
  • Random One Line Procedure
  • Factorial One Line Procedure
  • Tool Control Language TCL is a powerful and versatile computer language
  • Start with a working TCL math template or TCL math subroutine to modify code
  • Ways to Improve Efficiency of the TCL code
  • Implement Timing Efficiency in ones TCL code
  • Note. User X-Non >>> One of my scripts is taking a long time?
  • Timerate Command Implements Timing Efficiency in ones TCL code
  • Useful Feedback on Code Readability
  • Quick Start on Pseudocode
  • Pseudocode solution on For-Each Loop for TCL
  • Pseudocode solution for a do-while loop in Tcl
  • Pseudocode solution for a for loop in Tcl
  • Algorithm is a list of instruction or outline for accomplishing task.
  • Proportion Rules as basis of Algorithms
  • Pseudocode Checklist for Pseudocode Development from Proportion Rules
  • Pseudocode Checklist for Pseudocode Development from Proportion Rules
• Pseudocode Section for Babylonian trailing edge algorithm
  • Modify discrete events on tugboats_tester3
• Pseudocode Section on Text Adventure
• Session from trial console script
• Sample commands from King
• Pseudocode for Example Commands from King
• Pseudocode for Endgame
  • Pseudocode on Deisel Train Journey
  • Vaporware or MockUp for Pseudocode Article *
  • Figure 1g. One Line Procedures Follow-up mock up flowchart for train project
  • Figure 2. Text Adventure Game Screenshot 1
  • Random Dice and other Related Randoms
  • Still Proof Reading Here
• Pseudocode Section for Kahan summation algorithm
  • Still Proof Reading Here
  • Trial Abbreviation of Decalogue and Counting to 12 Rules
  • Approach to One Line Procedures
  • References:
  • Extra Credit on One Line Procedures
  • More on One Line Procedures
  • Refs on One Line Procedures
  • Conversion unit formulas in one line TCL procs
  • Screenshots Section
    • figure 1t. Dragon Counting Dice Game V4, second vaporware screenshot
    • figure 1r. Dragon Counting Dice Game V4, various flowcharts
  • figure Babylonian Combined Market Rates Concepts
  • figure Babylonian Combined Market Rates Concepts
  • figure Babylonian Combined Market Rates Concepts
• Hidden Comments Section

Title: One Line Proc Follow up V7

Preface

gold Update 2/29/2024 Here is an extension of TCL article on One Line Procedures written for Wikipedia. Trying to boil down some gratis advice given to me over 15 years of TCL Wiki membership. This page is intended to progress from simple questions to complex questions to more difficult issues. Socrates held that wisdom was not current knowledge, but asking the right questions.

gold Update 2/29/2024. The author is retired engineer on Windows 10 and no longer has proofing access to Unix machines. Unix is respected after use of so many decades in engineering, but my wings are lost. I did find a useful online IDE, jdoodle. I can paste from a text file, edit, and run an output using this online IDE.

Not a Replacement for TCL Core

This page on developing pseudocode examples and one line procedures is not a replacement for the current Tcl core and Tcllib, which is much improved since Tcl version 4, and other <faster> language constructs. math ops, Tcllib routines, and other compiled routines can reduce the cost of big-data tasks by about 1/3. The time savings of the core are not always obvious on small quantities of data, like 4 or 5 numbers. Performance of one-line programs may suffer degradation due to lengthy recursion calls, and may be limited by constraints on recursion. Dependence on math operator notation, helper procedures, math check examples, degradation due to lengthy recursion calls, and special library functions should be noted in the comment lines.

Brief History of One Line Programs

1. The concept of a one-line program originated in the 1960s with the APL programming language, which was known for its concise syntax and powerful mathematical operators.

2. In the 1970s, single line commands and programs became more common with the advent of home computers and the BASIC programming language.

3. Computer magazines published typesetting programs in many dialects of BASIC and often featured columns dedicated to impressive short and one-line programs.

4. The term "one-liner" also appears in the 1977 book The AWK Programming Language, which explains the AWK programming language and attributes the birth of the one-line paradigm to the authors' day-to-day work on early Unix machines.

5. The strict understanding of a single-line program was expanded in 1985 when the IOCCC introduced the Best One Liner category for C, which is a compiled language.

6. One-liners and single line programs are often used to demonstrate the differential expressive power of programming languages and to showcase programming abilities, sometimes in contests for the most effective single line program.

Simple One Line Hello Procedure

======= # One Line Procedure proc greetings {} { puts "Hello World!"} greetings

----
This is a basic example of a one liner procedure in TCL. The procedure definition is done on a single line, and it simply prints out the message "Hello World!" when called.
----
***Random One Line Procedure***
----

# One Line Procedure proc random_number {} { expr {rand() * 100}} puts random_number

----
This one liner procedure generates a random number between 0 and 100 and prints it out. The [random] number is generated using the [rand] function and multiplied by 100.
----
***Factorial One Line Procedure***
----

# One Line Procedure for Factorial proc factorial n { expr {$n == 0 ? 1 : $n * factorial [expr {$n - 1}]}} puts [factorial 5 # answer = 120

----
This one line procedure calculates the factorial of a given number. It uses a recursive approach to calculate the factorial, starting with the given number and multiplying it by the factorial of the number minus 1 until it reaches 0. This procedure is recursion limited. 
----
----
***Simple One Line  Hello Procedure***
----
=======
# One Line Procedure
proc greetings {} {  puts "Hello World!"}
greetings

This is a basic example of a one line procedure in TCL. The procedure definition is done on a single line, and it simply prints out the message "Hello World!" when called.

Random One Line Procedure

# One Line Procedure
proc random_number {} {  expr {rand() * 100}}
puts [random_number]

This one line procedure generates a random number between 0 and 100 and prints it out. The random number is generated using the rand function and multiplied by 100.

Factorial One Line Procedure

# One Line  Procedure for Factorial
proc factorial n {  expr {$n == 0 ? 1 : $n * [factorial [expr {$n - 1}]]}}
puts [factorial 5]
# answer = 120

This one line procedure calculates the factorial of a given number. It uses a recursive approach to calculate the factorial, starting with the given number and multiplying it by the factorial of the number minus 1 until it reaches 0. This procedure is recursion limited.

Tool Control Language TCL is a powerful and versatile computer language

gold Update 2/29/2024. Received useful and constructive feedback from offsite, thanks to @Ava______. Some text rephrasing to apply as general advice to most TCL programs.

The Tool Control Language (TCL) is a programming language used in automation, especially in industrial automation and manufacturing. It is designed to control various tools, machines, and processes, allowing for precise and efficient execution of tasks. TCL is based on the IEC 61131 standard, which is an international standard for programming languages used in industrial automation. It is a high-level, text-based language that provides a clear and concise way to describe actions and sequences, making it easier for automation engineers to develop and maintain control programs. TCL can be used to program a wide range of devices and systems, including PLCs (Programmable Logic Controllers), robots, CNC machines, and other industrial equipment. By using TCL, manufacturers can optimize their production processes, reduce human error, and improve overall efficiency and productivity. Some key features of TCL include:

1. Structured programming: TCL supports structured programming concepts, such as IF-THEN-ELSE statements, FOR, Foreach, and WHILE loops, and functions, which enable the creation of modular and reusable code.

2. Data types: TCL supports various data types, including integers, floats, strings, and arrays, allowing for the manipulation and storage of different types of data.

3. Input/Output operations: TCL provides functions for reading and writing data from/to various sources, such as sensors, actuators, and data storage devices.

4. Timers and counters: TCL includes functions for creating timers and counters, which can be used to control the timing of actions and sequences.

5. User-defined functions: TCL allows users to create their own functions, which can be used to encapsulate and reuse common code sequences.

Overall, TCL is a powerful and versatile language for controlling industrial tools and processes, making it an essential tool for automation engineers and manufacturers.

Start with a working TCL math template or TCL math subroutine to modify code

gold 2/29/2024. Received useful and constructive feedback from offsite, thanks to @Ava______. Some text rephrasing to apply as general advice to most TCL programs.

To start with a working TCL math template from TCCLIB and modify it for a new purpose, follow these 6 steps:

1. Choose a TCL math template or TCL math subroutine, for example in the TCLLIB library: Find a suitable TCL math template that closely matches the functionality you want to achieve. You can find various templates online or in TCL programming books and resources.

2. Understand the template: Carefully read and understand the template's code, comments, and structure. This will help you identify the parts of the code that you need to modify to create your new purpose.

3. Identify the necessary modifications: Determine the specific changes you need to make to the template to achieve your desired functionality. This may include modifying input parameters, changing calculations, or altering the output format.

4. Modify the template code: Begin modifying the template code, following the guidelines provided by the TCL programming language. Make sure to update any comments or documentation to reflect the new purpose of the subroutine.

5. Test the new TCL subroutine: After making the necessary modifications, test the new TCL subroutine in a console program to ensure it functions as expected. This will help you identify and fix any errors or issues before integrating the subroutine into a graphical user interface (GUI).

6. Load the new TCL subroutine into a GUI: Once the new TCL subroutine has been tested and verified, you can load it into a GUI program that supports TCL scripting. Make sure to follow the GUI's documentation and guidelines for integrating TCL subroutines.

By following these steps, one can successfully start with a working TCL math template, modify it for a new purpose, and then load the new subroutine into a GUI program for further use.

Ways to Improve Efficiency of the TCL code

gold 2/29/2024. Received useful and constructive feedback from offsite, thanks to @Ava______. Some text rephrasing to apply as general advice to most TCL programs.

Here are some ideas to improve the efficiency of your TCL code:

1. Optimize some procedures by reducing their computational complexity. Instead of using the rand function, you can use a faster random number generator like mt_rand 0. Links Note: Refers to RandMT, Mersenne Twister, & random. Now this is of interest.

2. Implement memoization to avoid redundant calculations. For example, you can store the results of procedure calls in variables and reuse them when necessary. Note: check possible garble or Spelling on memoization?

@Ava____ >>> Memoization is a technique used in computer science to improve the efficiency of a program by storing the results of expensive function calls and returning the cached result when the same inputs occur again. This avoids redundant calculations and speeds up the program. To implement memoization in your TCL code, you can create a dictionary (hash table) to store the results.

3. Use the foreach loop more efficiently. Instead of iterating over a range of numbers, you can use the lrange command to generate a list of numbers and iterate over that list. SP may mean lrange?

4. Simplify the conditionals in the some procedures by using logical operators and reducing the number of if statements.

5. Consider breaking down the code into smaller, more manageable procedures and functions to improve readability and maintainability.

6. Use TCLs built-in profiling tools to identify performance bottlenecks and optimize the code accordingly.

7. Improve efficiency during code development using the time commands and clock commands. Addendum. gold

8. Brace your expressions. For Example, set aa expr {$aa+$ee} will reduce execution time by a factor of 100. Really. GWM Addendum. gold

9. Check with the precompiled code in the TCL core and TCLLIB libraries >> first <<, then homebrew your one liners programs and scripts in TCL << second >>. TCl is a big umbrella and maybe ones problem is already solved in the TCL core and TCLLIB libraries. Addendum. gold

10. Finally, consider using a more modern version of TCL that has better performance and additional features. As of the time of this writing, TCL8.6 is several years old, and the latest version is 8.6.12___ or ask Dr. Google.

Notes. gold Thanks to GWM

GWM one - brace your expressions. set aa expr {$aa+$ee} - reduces execution time by a factor of 100. Really. Thanks to GWM

Implement Timing Efficiency in ones TCL code

gold Update 2/29/2024. Based on useful Twixt and other Wiki References, special thanks to Donal Fellows. Several articles on Wiki discuss improving efficiency during code development using the time commands, timerate, and clock commands. Some text rephrasing to apply as general advice to most TCL programs.

1. Measure Time: Time Command To measure the time that some selected code has taken, one can use the time or clock command. The time command will run its script argument and return a description of how long the script took, in milliseconds.

2. Time and Clock commands: Time Command in Detail The time command is useful for general monitoring and can be used to run scripts repeatedly, which can help in performance analysis work. The clock command, on the other hand, allows one to measure the time of various events and operations in a computer program.

3. Clock Command and How It Works. The clock command lets one measure the time of various events and operations in a computer program. This command can be used to calculate the time difference between two points in the program, which can be helpful when you need to optimize the program's performance.

4. Pseudocode. Pseudocode is a text-based representation of a computer program's algorithm. Pseudocode uses natural language and structural conventions to describe the logic and flow of the program, without being tied to a specific programming language or syntax.

5. Tool Control Language (TCL). TCL is a scripting language that is designed to control and automate various tools and applications. Tool Control Language (TCL) is used in a wide range of industries, including software development, system administration, and robotics.

6. Computer Code Languages like TCL. Computer code languages are used to create programs for computers and other devices. There are many different programming languages, each with its own syntax, features, and capabilities. Some popular programming languages include Python, Java, C++, Tool Control Language TCL, and JavaScript.

7. Separating paragraphs with "----". To separate paragraphs in ones Wiki documentation or instructions, you can use "----" as a visual separator. This helps to clearly define different sections and makes it easier to follow the content on the TCL Wiki pages.

Note. Numbered steps. By following these numbered steps and using the suggested titles for each paragraph, you can provide a clear and detailed explanation of computer applications, pseudocode solutions, Tool Control Language (TCL), and other related computer code languages.

Note. User X-Non >>> One of my scripts is taking a long time?

gold Answer. Suggest upgrade to latest TCL version 8.6___, at least. I will compile some references in a bit for you. Program subject is unknown here, suggest check if invoking TCLLIB in subject areas will save about 1/3 time on average. See list of TCLLIB sections on Wiki. Printing output or puts takes a lot of computer time; avoid puts until very end of program or do not use puts at all in draft decks.

gold I have collected some tips on faster code for you. I have not seen your code. But Reposted Tips from AMG & GWM & Wiki and Continuing Reposted Tips on Wiki may be of help. One would almost have to do a time analysis of individual subroutines and individual lines to find the "core hogs" with the time command. It is sometimes advantageous to write the TCL script into smaller subroutine chunks and organized and structured code subsections for easier detection of "core hogs". A "core hog" in a heap of straw code and "spaghetti code" is more difficult to find, from experience here.

Notes.

GWM one - brace your expressions. set aa expr {$aa+$ee} - reduces execution time by a factor of 100. Really. Thanks to GWM

Timerate Command Implements Timing Efficiency in ones TCL code

gold Update 3/2/2024. Based on useful Twixt and other Wiki References, special thanks to Donal Fellows. Several articles on Wiki discuss improving efficiency during code development using the time commands, timerate and clock commands, ref in TCL V8.6.14 docs [L1 ] . Some text rephrasing to apply as general advice to most TCL programs. Received useful content and constructive feedback from offsite, also thanks to @Ava______. Some text rephrasing to apply as general advice to most TCL programs.

1. Timerate Command in TCL and its Applications. The Timerate command is a built-in TCL command that performs calibrated performance measurement of a Tcl command or script. The Timerate command can be used to measure the elapsed time of a script or command and helps in understanding how well a script or command is performing. This information can be used to detect bottlenecks and fine-tune application performance.

2. Performance Measurement and Bottleneck Detection. By using the Timerate command, developers can measure the performance of their scripts and commands, helping them identify areas where their application may be underperforming. This information can be used to optimize their code and improve overall application performance.

3. Fine-Tuning Application Performance. Once bottlenecks have been identified, developers can use the Timerate command to fine-tune their code and improve the overall performance of their application. This may involve rewriting certain sections of code, optimizing algorithms, or making other changes to improve performance.

4. Timerate Command Forms and Usage. The Timerate command can be used in two forms: with and without the time parameter. The first form measures the time elapsed until a specified interval passes, while the second form measures the time elapsed until a specified number of iterations are completed.

5. Interaction with the Operating System and Time Measurement. When using the Timerate command, it is important to consider the interaction between the script or command and the operating system. The cost of any interaction with the OS is included in the time measurement, which can impact the overall performance of the script or command.

6. Timerate Command and Max-count Parameter. The max-count parameter can be used to impose a further restriction on the evaluation of a script or command. This parameter sets a maximum number of iterations to evaluate the script or command. If the specified count of iterations is reached before the time elapses, the evaluation will stop.

7. Conclusion and Future Improvements. In conclusion, the Timerate command is a valuable tool for developers looking to measure the performance of their scripts and commands. By identifying bottlenecks and fine-tuning their code, developers can improve the overall performance of their applications. Future improvements to the Timerate command may include better time measurement accuracy and more advanced performance analysis capabilities.

Useful Feedback on Code Readability

gold 2/29/2024. Received useful and constructive feedback from offsite, thanks to @Ava______. Some text rephrasing to apply as general advice to most TCL programs.

To improve the readability of the TCL code, consider the following suggestions:

1. Use meaningful variable names: Instead of using single letter variable names like 'i', j, m, 'msg', and 'proc', use more descriptive names that help convey the purpose of the variable. This will make the code more readable and easier to understand.

2. Break down complex procedures into smaller procedures, smaller tasks, and functions: Some codes have a single large procedure which performs multiple tasks. It would be better to break down a large procedure into smaller, more manageable functions and procedures that perform specific tasks. This will make the code easier to maintain and debug.

3. Use comments to explain the code: Adding comments to explain what each section of code does can greatly improve the readability and maintainability of the code. Use comments to explain the purpose of the code, any assumptions made, and any caveats or limitations.

4. Use consistent indentation and formatting: Ensure that the code is consistently indented and formatted. This will make it easier to read and understand the flow of the code. Use a consistent style guide for indentation, spacing, and line breaks.

5. Use meaningful error handling: Add error handling to the code to handle unexpected inputs or situations. Use descriptive error messages to help users understand what went wrong and how to fix it.

6. Use version control: Use a version control system like Git to keep track of changes to the code. This will make it easier to collaborate on the code and to roll back to previous versions if necessary.

7. Identify the main TCL version used, dates, and other TCL library dependencies in header comments.

Quick Start on Pseudocode

1. Convert the tasks lists into a formal design that can be used as the basis for coding. Break each task into smaller subtasks or sub-subtasks, and then convert each of these detailed elements into lines of pseudocode. Each pseudocode line will represent one "action."

Pseudocode Example:

    START
    GET user input
    IF user input is valid
        CALL process user input
        DISPLAY processed user input
    ELSE
        DISPLAY invalid input message
    END IF
    END

2. Capitalize initial keywords: The keywords in the pseudocode should be written in all capital letters, as they begin the statement and give special meaning to the operation. READ, WRITE, IF, WHILE, and UNTIL are examples of keywords that should be written in all capital letters.

    START
    GET user input
    IF user input is valid
        CALL process user input
        DISPLAY processed user input
    ELSE
        DISPLAY invalid input message
    END IF
    END

3. Use indentation to show hierarchy: Indentation helps indicate the "boundaries" of the structure within the pseudocode. Sequence structures do not require indentation, but loop or selection structures must indicate which statements are executed within the structure.

    START
        GET user input
        IF user input is valid
            CALL process user input
            DISPLAY processed user input
        ELSE
            DISPLAY invalid input message
        END IF
    END

4. End multiline structures: Structures, such as loops or selections, should be ended to provide clarity. Indentation helps indicate the beginning and end of these structures.

    START
        GET user input
        IF user input is valid
            CALL process user input
            DISPLAY processed user input
        ELSE
            DISPLAY invalid input message
        END IF
    END

5. Keep statements language-independent: This rule does not mean that pseudocode should be written in a specific language; it means that the pseudocode should be designed in a way that is free of special requirements or capabilities unique to specific programming languages. This ensures that the pseudocode can be translated into any programming language.

gold Update 2/29/2024. Note. The term "language independent statements" has caused debate in either a positive or negative light. There has been some heartburn over the meaning of the phrase " language independent statements". Notice the hyphen is zapped here. The term "language independent" as defined here refers to statements in "natural language" that has no known dependencies on the classic computer programming compilers and interpreters. I say classic programming languages, because there were experimental "natural language programs" used in the 1960's. Some well meaning students are taking "language independent statements" to mean not using a human language at all. Well, getting down into the weeds, that is possible in the math and graphic methods and solutions. There are a number of trials that show crows, squirrels, frogs, and rats solving problems with no involvement of human languages. And subject to interpretation, some of the language independent statements and algorithms were chipped on stone and clay tablets in Sumer Ur III, current Iraq.

Pseudocode is a method of describing the steps in an algorithm or other computed process written in plain "natural" language. Pseudocode does not rely on any particular implementation of a computer programming language In other words, the ugly math is off the table and kept out of sight. There are examples of pseudocode solutions for translating into the TCL script, but use includes possible exercises for translating into other computer languages such as Python or C++.

gold Update 3/1/2024. Not to give any free ideas away on gui development. When I first encountered TCL, I found out that some software engineers were developing prototype guis or prototype vaporwares in TCL for the graphics solution. Then for increased computation speed on the Sparc workstations, the software engineers were cross-compiling or rather translating the prototype gui in TCL into a C or C++ program on the Sparc workstations.

6. Pseudocode Solutions: Pseudocode is a way of expressing algorithms in a simple and easy-to-understand manner. It's a tool that can help one design and plan the computer programs before one writes the actual code. When you're working with pseudocode, you can break down your problem into smaller steps and write them in plain language. This can make your code easier to read and understand, both for onesself and for others who may need to work with it in the future.

7. Tool Control Languages (TCL): TCL is a scripting language that was designed for controlling applications and automating tasks. It's often used in conjunction with other programming languages, such as C++ or Java, to create more powerful and flexible applications. TCL is a good choice for projects that require a high degree of interactivity or user input, as it provides a simple and intuitive way to create interfaces and handle user interactions.

8. Computer Code Languages: There are many different computer code languages available, each with its own strengths and weaknesses. Some common languages include Python, Java, C++, Tool Control Language TCL, and JavaScript. When choosing a language for the project, you should consider factors such as the complexity of your program, the platform you'll be using, and the skills and experience of your development team. By choosing the right language, one can make your development process from Pseudocode, as more efficient and ensure that the program is well-suited to its intended purpose.

9. Titles and Outline of Problems in Pseudocode: To make ones writing more organized and easier to read, one should use titles to break up ones text into sections. Each title should be concise and descriptive, consisting of 1, 2, 3, or 4 words that summarize the content of the section. This will help ones readers to quickly find the information they need and understand the overall structure of your writing and Pseudocode.

10. Numbered Points: To make ones writing more engaging and easy to follow, one should use numbered points to break down complex ideas into smaller, more manageable pieces. Each point should be clearly labeled with a number and should provide a brief explanation of a specific concept or idea. By using numbered points, one can help ones readers to understand the key points of ones writing and to retain the information more effectively.

Pseudocode solution on For-Each Loop for TCL

for each item in the collection:
    perform an action on that item
end for each 

Pseudocode solution for a do-while loop in Tcl

do:
    perform an action
    check a condition
while the condition is true

Pseudocode solution for a for loop in Tcl

for each item in the collection:
    perform an action on that item
end for each

Algorithm is a list of instruction or outline for accomplishing task.

gold 3/3/2024.Under edit. Received useful and constructive feedback from offsite, thanks to @Ava______. Some text rephrasing to apply as general advice to most TCL programs. I am a visually oriented person myself, so I tend to explore or emphasize graphical solutions on the TCL Wiki. This page has various examples of the four representation forms of algorithms. An algorithm may be in form of list of instructions, flowcharts, pseudocode, or graphical instructions for solution.

1. Algorithm Basics:

An algorithm is a recipe or step-by-step list of instructions for completing a task. However, these instructions may not be detailed enough for a computer to execute accurately. Particularly, English and other natural languages have some degree of ambiguity.

2. Instruction Lists for Details:

Programs implement algorithms through detailed instruction lists or natural language outlines. These lists provide the necessary precision for computers to follow and execute the tasks effectively. Typically, an instruction list follows the top down order, but not always. Also, instructions list may be segmented or forked for different aspects of the assigned problem.

3. Flowcharts for Visualization:

Flowcharts are graphical representations of algorithms that help visualize the sequence of steps and decision points in a process. Flowcharts aid in understanding and optimizing the algorithm's logic flow.

4. Pseudocode for Clarity: Pseudocode is a description of a computer program or algorithm using a mixture of natural language and programming language syntax. Pseudocode helps in clarifying the logic before actual coding.

Pseudocode is a method of describing the steps in an algorithm or other computed process written in plain "natural" language. Pseudocode does not rely on any particular implementation of a computer programming language. In other words, the ugly math is off the table and kept out of sight. There are examples of pseudocode solutions for translating into the TCL script, but use includes possible exercises for translating into other computer languages such as Python or C++.

5. Graphical Instructions for a visual representation : Graphical instructions provide a visual representation of solutions, making complex algorithms easier to understand and implement. They enhance the user experience and simplify the execution of tasks.

Note. If you have a list, detailed schedule, phone call list, or day journal of daily problems, pretty close to pseudocode.

Note. Received twixt on Pseudocode from Poor Yorick on offline, thanks Poor Yorick. Believe I can revamp to a gist in High School English.

Poor Yorick quoted. TCL syntax is easily the most like pseudo-code. Commands trump functions for readability and for expressing lower-level operations more typical of assembly code. At the same time, high-level algorithms are also very easy to read. The uniformity of the syntax allows the user to focus on the steps rather than on language artifacts. I would even say that the "expr" keyword for mathematical operations is an advantage, because it clearly delineates the math parts of the program from the algorithmic parts. Fewer symbols are overloaded, and words like "set" are used in their place. This is another win for pseudo-code. More than any other syntax, TCL spans the divide between functional and imperative styles.

gold 3/3/2024. Note. Reorganized.

1. TCL Syntax Similarity:

TCL syntax closely resembles pseudocode. TCL syntax prioritizes commands over functions for readability and expressing lower-level operations akin to assembly code.

2. High lever algorithms. TCL syntax makes high-level algorithms easy to comprehend.

3. Focus on Readability: The uniformity of TCL syntax allows users to concentrate on the algorithmic steps rather than language intricacies.

4. The use of keywords like "expr" for mathematical operations and "reg" for text manipulations enhances clarity and separates math from algorithms.

5. Pseudocode Advantages: TCL's use of clear keywords like "set" instead of overloaded symbols contributes to its pseudocode like nature, making TCL programming more accessible and readable for users.

6. Bridge to Programming styles. TCL bridges functional and imperative programming styles effectively.

7. Functional and Imperative. Programming Functional programming computes an expression, while imperative programming is a sequence of instructions modifying memory. The former relies on an automatic garbage collector, while the latter requires explicit memory allocation and deallocation.

8 Memory and Execution Control. Imperative programming provides greater control over execution and memory representation, but can be less efficient. Functional programming offers higher abstraction and execution safety, with stricter typing and automatic storage reclamation.

9. Historical Perspectives. Historically, functional programming was associated with symbolic applications, and imperative programming with numerical applications. However, advances in compiling and garbage collection have improved efficiency and execution safety for both paradigms.

10. Differ in control. Functional and imperative programming languages differ in control over program execution and memory management. Functional programs compute expressions, and the order of operations doesn't matter. Imperative programs are sequences of instructions that modify a memory state.

11. Imperative Programs. Imperative programs enforce control structures and manipulate pointers or references. Memory space must be allocated and reclaimed explicitly, which may lead to errors. However, garbage control can be used.

12. Imperative vs. Functional. Imperative languages offer more control over execution and data memory representation but may be less safe. Functional programming provides a higher level of abstraction and better execution safety, with stricter typing and automatic storage reclamation.

13. Evolution of Programming Paradigms. Functional and imperative languages were historically seen as belonging to different universes, but recent advancements in compiling and garbage control efficiency have made them more versatile. Execution safety has become an essential criterion for application quality.

Proportion Rules as basis of Algorithms

The Babylonian Rules of Proportions and the false position algorithm, in particular, are intriguing examples of how our ancestors used logic and calculation to solve complex problems. The TCL calculator is a modern tool that can help us understand and apply these ancient methods in our own work. Some mathematicians contend the B. proportion formulas are solutions to linear equations. By loading the Babylonian false position algorithm into the calculator, we can see how this technique was used to find the correct dimensions of a field, given the area and the short side constraint ratio. It is interesting to note that the Babylonians did not use algebra notation, which may seem anachronistic to us today. However, their use of these algorithms shows that they were able to think logically and solve complex problems without the benefit of modern mathematical notation.

Note. Proportions or some Proportion Rules are called "rule of three" in some older manuscripts and philosophy. The Babylonian Rules of Proportions on clay tablets were the first known solutions of linear equations.

Pseudocode Checklist for Pseudocode Development from Proportion Rules

Note. Proportions or some Proportion Rules are called "rule of three" in some older manuscripts and philosophy. For example, Pythagoras calls three the perfect number, expressive of "beginning, middle, and end." In the biography of Abraham Lincoln, Mr. Lincoln states that he learned to "read, write, and cipher to the rule of 3." But some modern mathematicians call 2*3 or 6 as the perfect number. From the Babylonian clay tablets, the Babylonian mathematicians seem to emphasize either 3*4=20 or 3*20=60, in using Base 60. One modern mathematician counted 12 finger joints on each hand, totaling 3*8 = 24 , but I confess that I lost his count.

Pseudocode Checklist for Pseudocode Development from Proportion Rules

     #pseudocode can be developed from rules of thumb.
     #pseudocode: some problems can be solved by proportions (rule of three), to some order of magnitude
     #pseudocode: enter quantity1,  quantity2, quantity3 and expected output (quantity4) for testcases.
     #pseudocode: enter time in years, number of remaining items
     #pseudocode: output fraction of (remaining items) over (items at time zero)
     #pseudocode: output remaining items as fraction or percent
     #pseudocode: output fraction of (quantity4 ) over ( quantity1 at time zero)
     #pseudocode: output fraction of (quantity2) * (quantity3 ) over (quantity1 at time zero)
     #pseudocode: outputs should be in compatible units.
     #pseudocode: rules of thumb can be 3 to 15 percent off, partly since g..in g..out.
     #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?

Pseudocode Section for Babylonian trailing edge algorithm

      # using pseudocode for Babylonian trailing edge algorithm
      # and reverse sequence algorithm for reciprocals 
      # possible problem instances include, given  n , find 1/n from trailing edge factors 
      # reverse sequence algorithm is finding inverse or 1/(1/n) 
      # irregular defined as not in standard B. table of reciprocals
      target_number= supplied value 
      #   decompose target number
      c = a + b 
      1/n = (1/n1)  * (1/n2) 
      a+b is not unique, 
      test a for prime, even, odd?
      test b for prime, even, odd?
      find a as factorable into 2**x, 3**y, 5**z, or n/<(2**x)*(3**y)*(5**z)>???
      # here describing possible steps of Babylonian scribe solving
      # Base 60 reciprocal using table lookup on Clay tablet tables. 
      take (1/a) 
      table lookup (1/a) 
      take (1/a)*(b)
      take 1/(1+(1/a)*(b))
      take  (1/a)* (1/(1+(1/a)*(b)))
      check_answer new area =? desired goal 
      n*(1/n) =? 1  , (yes/no logic)
      set answers and printout with resulting values
      # "drop" B. clay tablets here as program stop. 
      13500 >>>  factors 2 2 3 3 3 5 5 5
      1./13500. = 7.4074e-5
      1./7.4074e-5 =  13500.
      factors for 13500 or standing reciprocal algorithm on its head
      2 2 3 3 3 5 5 5      *(1/5)
      2 2 3 3 3 5 5        *(1/5)
      2 2 3 3 3 5          *(1/5)
      2 2 3 3 3            *(1/3)
      2 2 3 3              *(1/3)        
      2 2 3                *(1/3)
      2 2                  *(1/2)     
      2
      2                    *(2)
      2 2                  *(3)       
      2 2 3                *(3)
      2 2 3 3              *(3)
      2 2 3 3 3            *(5)
      2 2 3 3 3 5          *(5)
      2 2 3 3 3 5 5        *(5)
      2 2 3 3 3 5 5 5
      set list_factors_trailing <200 400 10 16 25 40 1350> base 60
      set list_factors_reverse < 30 12 15 24 36 45 48 225> base 60
      # should swap out tiny prime factors for larger Babylonian factors
      # if factor r does not work or is exhausted ,
      # factor r should be temporally struck from the factor list.
      # factor of target number on left
      # factor of the reciprocal on the right
      # preclean list of possible factors that do not evenly divide!
      [ list_cleaner_factors $lister $item ] 
      # begin factorization of precleaned list of factors
      # there might be factors used once or multiple times before exhausted   

Modify discrete events on tugboats_tester3

From Discrete event modelling with coroutines by here Arjen Markus (21 april 2009). Added easy eye console for my bad eyes. If you have a detailed schedule or day journal of problems, pretty close to pseudocode.

Figure. Simulated Tugboat Schedule from Arjen Markus

Pseudocode Section on Text Adventure

Session from trial console script

    buy or sell, my lord? 
    starts with 1000 units 
    answer has form:  king buy 20 or king sell 30  
   1% king buy 20
    decision was buy 20, total was 1020.0 
 
   advisor:  new situation 
   need 10 liters of grain.
   need 60 hectares of land.
   predict rain.
   subjects from census 5000. 

    advisor: buy or sell, my lord? 
    2% king sell 500
    decision was sell 500, total was 520.0 
 
    advisor:  new situation 
    need 10 liters of grain.
    need 100 hectares of land.
    predict cold.
    subjects from census 3000. 

    advisor: buy or sell, my lord? 

Sample commands from King

      Commands from the king on the TCL console  
      or commands in the king entry field (canvas gui)
      vary on versions, but here are some samples.
      initial land is 1000 barleyfields
      initial barley is 1000 measures
      king buy 22
      king sell 100
       else 
      king buy 100 land
      king sell 33 land
      king buy 222 barley
      king sell 33 barley
      conditions for winner are very liberal.

Pseudocode for Example Commands from King

      kingdom starts with 1000 units land 
      initial barley is 1000 measures <for palace>
      king's answer has lower case form: 
      example >>   king buy 20 land 
      example >>   king sell 30 land  
      example >>   king buy 33 barley 
      example >>   king sell 11 barley 
      example >>   for new game, enter command reset 1 

Pseudocode for Endgame

    pseudocode: game is halted after 5 trials, count > 5,
    and estimate if (winner) conditions prevail.
    pseudocode:  if barleyfields > 500 , winner declared
    pseudocode:  if barley  > 500 winner declared
    pseudocode:  clear resets counter to zero
    pseudocode:  clear zeros king & advisor entry fields, 
    pseudocode:  & zeros canvas

Pseudocode on Deisel Train Journey

Improve, number steps, explain details, and elaborate on each step to make Pseudocode more comprehensive.

1. Start

For me, Start usually means a summary of initial conditions or initial states. For example, whether the diesel tank on the train is low or full, might be assigned logic variables and tank capacity values in a computer program.

2. Display "Please enter the number of kilometers for the journey:"

3. Input kilometers

4. If kilometers <= 0, display "Invalid input. Please enter a number greater than zero." and go back to step 2

This step is crucial to ensure that the user enters a valid number for the journey distance. If the user enters 0 or a negative number, the program will prompt them again to enter a valid number.

5. Set fuel = kilometers * 100

This step calculates the amount of fuel needed for the journey based on the distance entered by the user. The fuel consumption is assumed to be 100 liters per 100 kilometers.

6. If fuel < 1500, set fuel = 1500

This step sets a minimum fuel requirement of 1500 liters. If the calculated fuel is less than 1500 liters, the program will set the fuel requirement to 1500 liters.

7. Display "The amount of fuel needed for the journey is: " + fuel

This step displays the final fuel requirement for the journey based on the user's input and the calculations performed in the previous steps.

8. Output results

This step includes a final look at the answers and final states of the logic variables.

9. End

For me, End usually means a summary and study of final conditions or final states. For example, whether the diesel tank on the train is low or full, might be assigned logic variables and tank capacity values in a computer program. If treating a train ride as a boundary value problem, the answer should on the train journey between Start and End.

By breaking down the pseudocode into numbered steps and explaining the details of each step, the program is more understandable and easier to follow.

Vaporware or MockUp for Pseudocode Article *

Note. Comments etc are removed. A Mockup is not a complete working TCL program. Mockup is compiling on local TCL interpreter. One could assign one or several procs to different students.

    # Vaporware or MockUp for Pseudocode Article
    # Deisel Train Journey V2
    # written on Windows 10 for TCL 8.6
    # Engineer Yaya-Yada on 3Mar2024
    # Initial file name is diesel2.txt
    # Improve, number steps, explain details,
    # and elaborate on each step, more comprehensive.
    # Comments etc are removed. 
    # A Mockup  is not a complete working TCL program. 
    # Mockup is  compiling on local TCL interpreter, jdoodle 
    # One could assign one or several procs to different students.
    # Initial goal is to see mock variables passing correctly 
    # through proc, without obvious issues. 
    set mock 1
    proc Start { mock}     {return 1 }
    proc Display {mock}    {return 1 }
    proc Input  { mock}    {return 1 }
    proc Calulate_results  {mock}  {return 1 }
    proc Display {mock}    {return 1 }
    proc Output_results    {mock} {puts " Mockup 1,  completed $mock"; return 1 }
    proc End {mock}        {return 1 }
    Output_results 1
    # Bye Bye

Figure 1g. One Line Procedures Follow-up mock up flowchart for train project

Note. Editor shuffles procs out of order on flowchart here.

Figure 2. Text Adventure Game Screenshot 1

Random Dice and other Related Randoms

gold 2/20/2024 update. The random pick algorithm was posted by Suchenworth RS on Horseracing in Tcl. Using the random pick algorithm from Suchenworth RS is an alternate way to simulate dice play and sometimes easier for the non standard dice set ups. Other dice pages are Throwing Two Dice GWM and Dice by Keith Vetter. Also int from RLE has dice expression expr {1 + int(rand()*6)} RLE. Several Dr. Math emails may reduce some dice issues to simple paths. Another useful wiki page was Counting Elements in a List from RWT.

        #  Random Dice & alternate procedures, checking math and format here
        # Original base expression is expr {1 + int(rand()*6)}    RLE
        # check parens? weak eyes here. 
        proc dice_sides_N    { dice_sides } { expr { 1 + int(rand()*$dice_sides)} }  
        proc dice_sides_N    { dice_sides } { expr { 1 + int(rand()*$dice_sides)} }
        # Computes optimum for Dragon Counting Game  from James Munro,  Oxford mathematician  
        proc optimum_N    { dice_sides } { expr { int(1.718281828 *$dice_sides) }} 
        # Alternate gimmick and fudge constant under test
        proc optimum_G    { dice_sides } { expr { int(1.6180339887498948420  *$dice_sides) }} 
        # set g_constant .6180339887498948420
        #  golden ratio is 1.6180339887498948420 

Still Proof Reading Here

# Still Proof Reading Here & Under Test
proc double_dice_sides_N    { dice_sides } { expr { (1 + int(rand()*$dice_sides)) + (1 + int(rand()*$dice_sides)) } }  

The provided code is a simple random function in the Tcl programming language. It is designed to generate a random integer between 1 and a specified number (dice_sides). The function is named "dice_sides_N" and it takes one parameter, "dice_sides", which represents the highest possible value for the generated integer (similar to the number of sides on a dice). Inside the function, the expression "1 + int(rand()*$dice_sides)" is used to generate a random number.

Here's how it works: rand generates a random floating-point number between 0 and 1. Multiplying this number by the dice_sides gives a random number between 0 and the dice_sides value. int then converts the resulting floating-point number to an integer. Finally, adding 1 to the integer gives a random number between 1 and the dice_sides value. When this function is called with a specific dice_sides value, it will return a random integer between 1 and the provided dice_sides value, simulating the roll of a dice with that many sides.

Pseudocode Section for Kahan summation algorithm

          # using  pseudocode for Kahan summation algorithm
          trying to "cure" or slow growth of tail digits
          from round off errors, 
         # kahan summation algorithm in pseudocode
          a(i)  = sequence of floating point numbers, a(i)>=3
          c = keeper result
          sum of floating point numbers
          loop following
          y = a(i) -c
          t = sum + y
          c = (t-sum)-y
          sum = t
         10000.0, 3.14159, 2.71828= (a + b) + c
          => single precision fp errors =>  10005.8.
          Kahan function a, b, c results in  10005.9
          ref normal TCL precision 12 or 17,
          expr is double precision inside calculations
          and not show these errors in sp.
          have to reproduce rd. error in single precision
          have to add fp format statements  
          correct for inputs of large angles and accumulated round off errors
     check_answer  (a + b) + c =?  a + ( b  + c ) (yes/no)
     set answers and printout with resulting values

Still Proof Reading Here

Trial Abbreviation of Decalogue and Counting to 12 Rules

Here is trial abbreviation of the 12 rules that define the syntax and semantics of the Tcl language. Refers to Endekalogue [L2 ]. Decalogue refers to Ten Commandments.

1. Command Structure: A Tcl script is composed of one or more commands, separated by semicolons or newlines.

2. Command Evaluation: A command is processed in two steps – first, the Tcl interpreter divides the command into words and performs substitutions. Then, the first word is used to locate a routine to execute the command.

3. Word Separation: Words in a command are separated by white space.

4. Double Quotes: A word enclosed in double quotes allows for command, variable, and backslash substitutions.

5. Argument Expansion: Words starting with "{}" are treated as lists and added to the command being substituted.

6. Braces: Braces enclose a word without any substitutions or special interpretation of characters.

7. Command Substitution: Open brackets initiate command substitution, which replaces the brackets and all characters between them with the result of the script.

8. Variable Substitution: Dollar signs followed by a variable name replace the dollar sign and name with the variable's value.

9. Backslash substitution & Lists: If a backslash (“\”) appears within a word then backslash substitution occurs. Lists are sequences of elements separated by white space, with elements being any valid Tcl string.

10. Comment lines: If a hash character (“#”) appears at the first character of the first word of a command, then the line or remaining line treated as a comment and ignored. Backslashes, braces, and quotes can be used to prevent certain characters from being treated as command separators or substitutions.

11. Order of substitution & Control Structures: Tcl provides control structures for conditional execution, loops, and error handling, such as if/else, for, while, and catch.

12. Substitution and word boundaries & Error Handling: Substitutions do not affect the word boundaries of a command, except for argument expansion. Built-in mechanisms like catch command and error return value help in handling and trapping errors in Tcl scripts.

Note. 12 Refers to Endekalogue [L3 ] . Decalogue refers to ten commandments. There is some dispute on counting commandments, The Decalogue and The Twelve Commandments in other quarters.

Approach to One Line Procedures

There is a gold mine of One Liners Programs and content in the Tool Control language TCL 8.6 core distribution, TCL manual pages, and TCLLIB library that can be adapted or recast into brief one liners programs. These one liners programs or procedures can be pasted into the TCL 8.6 console window for quick results, reference the TCL Wiki. Some one liners programs use the return statement, return $value, or return 1 to return the results to the program line. Although many TCL programmers just rely on the last computation being returned by the one liner procedure in the TCL console window.

Mostly I use the expired eTCL on an older outdated personal computer. Some of these single line procedures are easier to patch as an older TCL procedure rather than learn a new TCL grammar and pull the TCLLIB library. Naming no names as the TCL language versions and associated libraries get ever larger, one or two of these one liner programs were implemented on some smaller homebrew compilers without using the current massive TCL language. Reference the older Fortran and QuickBasic dogmas, I confess that habits brought from prior learned languages and dogmas in the moldy Fortran, DOS, and Qbasic textbooks of 50 years ago are hard to change.

There is some room in the Wiki publications for programming style differences. But it is usually best to put usage, credits, or TCL documentation references for the one liners procedures on separate comment lines. The random rand procedures make use of the random function and do not return the same answer every time. Dependence on math operator notation, helper procedures, math check examples, and special library functions should be noted in the comment lines. The terms program, routine, subroutine, procedure, and proc are used interchangeably in this article. Recognize that the TCL nomenclature uses the exceptional term procedure and proc, but the internet search engines including the general public do not accept or pull the terms procedure and proc as equitably with respect to the other computer languages using terms subroutine and program. There are pros and cons to one liner programs in TCL.

gold Philosophy On One Liners Programs. I remember when my teenage sister would ask about a math problem. I would lead up and carefully explain this and that algebra proposition. But my sister would say " I just want the answer!" In most engineering problems, there is an advantage in finding the answer in an approximate solution, say slide rule accuracy or 4 significant places. For example, using the old slide rule, one would make a preliminary pencil calculation and approximate answer to set the decimal point, before using the slide rule accuracy to 4 significant places. If one thinks of TCL as primarily as a graphical gui language, then the one liners programs are best used to check the preliminary math concepts. One liners programs and initial console programs are often used to check the math concepts and generate testcases before loading the calculator gui shell.

gold 3/3/2024. One may contrast the approach to one line programs in problem solving versus the traditional procedural approach. One liners programs are not a replacement for the TCL core. There are better routines and methods in faster language constructs in the current TCL core distribution and TCLLIB. Working with recursion, primes, text search, and timing the procedures will quickly show the warts on the one liners programs. To gain speed and shorter computation times, one will generally have to access the TCL core distribution and TCLLIB. Since the TCL interpreter collapses the carriage returns, skips, blank lines, and dead space of traditional written procedures into a single line of machine code, is not every script a one liner program to the parser? As grandfather remarked, the gourmet omelet, beef mulligan stew, and farm buttermilk all go to the same place.

References:

• GoDuck search engine < Functional Programming >
• GoDuck search engine < Imperative Programming >
• GoDuck search engine < Programming Examples >
• Google search engine < vaporware >
• Professor Frisby's Mostly Adequate Guide to Functional Programming on internet archive
• GoDuck search engine < TCL version >
• One Liners Programs Pie in the Sky
• One Liners
• One Liners Programs Compendium [L4 ]
• WIKI BOOKS, Programming_Examples pdf
• WIKI BOOKS, Tcl_Programming_Introduction pdf
• Note. I did find a useful online IDE, jdoodle
• Note. I can paste, edit, and run an output using this online IDE.
• How Do I Write Pseudocode? video by Mr. Brown CS
• Refers to rand, RandMT, Mersenne Twister, & random
• Suchenworth RS on Horseracing in Tcl.
• Throwing Two Dice GWM and Dice by Keith Vetter.
• int from RLE has dice expression expr {1 + int(rand()*6)} RLE.
• Several Dr. Math emails may reduce some dice issues to simple paths, internet archive.
• Counting Elements in a List from RWT.

Extra Credit on One Line Procedures

• Little L Programming Language
• Let's assign with let
• let
• let2
• Easy Eye Calculator [L5 ]
• Tcl the Misunderstood
• Maximum nummeric value from max
• L-Language pdf L , by Larry McVoy:
• One liners Programs Pie in the Sky
• Counting characters in a string
• Playing with recursion
• recursive functions
• If we had no expr
• expr
• little language
• string is

More on One Line Procedures

• Why Tcl is so much slower than Perl, pros and cons
• Playing with recursion
• Category Numerical Analysis
• TCLLIB numtheory section
• Gauss Approximate Number of Primes and eTCL demo example calculator
• math::numtheory::isprime
• math::numtheory::firstNprimes
• math::numtheory::primesLowerThan
• math::numtheory::primeFactors
• math::numtheory::numberPrimesGauss
• math::numtheory::numberPrimesLegendre
• math::numtheory::numberPrimesLegendreModified
• math::numtheory::differenceNumberPrimesLegendreModified
• On-Line Encyclopedia of Integer Sequences , OEIS

Refs on One Line Procedures

• a little proving engine
• Parsing Polish notation
• let
• let - a simpler sugar for expr
• AMG's language ideas
• Let's assign with let
• The L Programming Language or
• Tcl for C Programmers, Oscar Bonilla, Tim Daly, Jr., Larry McVoy
• search keywords <Avoiding Brackets>
• Assign using equals
• Partcl - a minimal Tcl interpreter
• Tiny Tcl 6.8 is a rommable,
• minimal Tcl for embedded applications.
• Basic256, So You Want to Learn to Program?, English pdf

Conversion unit formulas in one line TCL procs

    #  conversion unit formulas in one line TCL procs
    #  HOMA-IR standing for Homeostatic Model Assessment of Insulin Resistance 
    #  HOMA_IR = expr { $insulin * $glucose * $scale_factor}
    #  fasting blood insulin in units  uIU/mL
    #  fasting blood glucose in units mg/dL
    proc HOMA_IR2 { insulin  glucose }  {
            set scale_factor [ expr { 1. / 405. } ]
            return [expr { $insulin * $glucose * $scale_factor}]}
    #  HOMA-IR calculations here requires U.S. standard units.
    #  European SI units as best understood. 
    #  To convert component terms of  HOMA-IR ( $insulin & $glucose)
    #  from international S.I. units:
    #  Insulin: pmol/L to uIU/mL, divide by (÷) 6
    #  Glucose: mmol/L to mg/dL, multiply by (x) 18
    #  hbA1c_convert_to_average_blood_glucose mg/dl  HbA1c
    #  HbA1c test is a simple blood test that measures your 
    #  average blood sugar levels over the past 3 months.
    #  As a peg point, 5 HbA1c units converts to 100 mg/dl,
    #  mg/dl is abbreviation for milligrams per deciliter.
    proc a1c hbA1c {  expr { 35.6*$hbA1c -77.3} }
    #  convert mg/dl to mmol/L average blood glucose
    #   European SI units conversion on blood glucose
    #  some papers round off 18.016 to mgdl/18.
    proc mgdl_to_mmoll mgdl {  expr { $mgdl/18.0 } }
    #  convert  mmol/L to mg/dl average blood glucose
    proc mmoll_to_mgdl mmoll {  expr { $mmoll*18.0 } }
    #  formula QUICKI_index insulin resistance = 1/(log(insulin) + log(glucose)), decimal logs 
    proc QUICKI_INDEX_IR { insulin  glucose } { return [ expr { 1./(log10($insulin) + log10($glucose))} ] }
    #  Usage set answer [  QUICKI_INDEX_IR 4. 100. ] #  eval 0.38

Screenshots Section

figure 1t. Dragon Counting Dice Game V4, second vaporware screenshot

figure 1r. Dragon Counting Dice Game V4, various flowcharts

figure Babylonian Combined Market Rates Concepts

figure Babylonian Combined Market Rates Concepts

figure Babylonian Combined Market Rates Concepts

Hidden Comments Section

1.  Prompt the user to enter the number of kilometers for the journey.
2.  Check if the user entered a value greater than zero.
3.  If the user entered a value greater than zero, proceed to the next step. Otherwise, display an error message and exit the program.
4.  Set the amount of fuel to be 100 times the number of kilometers entered by the user.
5.  Ensure that the amount of fuel is at least 1500.
6.  Display the calculated amount of fuel to the user.

  here is a pseudocode with numbered steps for calculating the amount of fuel the train will use based on the user input:

1. Start
2. Display "Please enter the number of kilometers for the journey:"
3. Input kilometers
4. If kilometers <= 0, display "Invalid input. Please enter a number greater than zero." and go back to step 2
5. Set fuel = kilometers * 100
6. If fuel < 1500, set fuel = 1500
7. Display "The amount of fuel needed for the journey is: " + fuel
8. End