|
INTRODUCTION to Tcl-Tk script
'tkSpeedConvertSelect'
I was planning (in 2016-2017) to make some Tcl-Tk GUI's for converting
various kinds of quantities (distances, areas, volumes, weights, densities,
speeds, etc.) from one specified unit-of-measure to another.
In August 2017, I published the first of these Tk GUI's --- a
tkDistanceConvertSelect
Tk script --- and soon after that a
tkAreaConvertSelect
Tk script --- and a
tkVolumeConvertSelect
Tk script --- and a
tkWeightConvertSelect
Tk script.
One of my main goals in creating these 'convert' GUI's is to support
conversions over a very wide range of values.
For example, for distances, I wanted to be able to support
converting distances that may be astronomically huge
(for example, distances up to the diameter of the
'observable' universe, in
light-years or whatever) or distances that may be
microscopically small (for example, distances at the
sub-atomic level, in
nanometers or whatever).
To do this, I wanted to allow the user to specify the
'convert-from' distance in
'scientific notation' ---
a decimal coefficient and a base-10 exponent (an integer).
And the 'convert-to' distance was also to be expressed in 'scientific notation'.
This is in contrast to the
tkSpeedGun utility I wrote in 2013, which was intended to convert between
kilometers-per-hour and miles-per-hour --- with the intention of
handling a restricted range of speeds --- like those encountered
by a tennis ball in a tennis match.
That 'speed gun' utility had the luxury of knowing that
the speeds would be numbers in the range of
zero to a maximum of about 300 (or 1000 or therabout)
--- in kilometers-per-hour or miles-per-hour --- and
in increments of no smaller than about 0.1.
Instead of dealing with a range of values FROM about
0.1 TO about 10-to-the-3rd, I wanted to deal with values
in the RANGE of about 10-to-the-minus-80
TO about 10-to-the-plus-80.
Using the
tkWeightConvertSelect Tk script as a starting point,
I decided to code this 'speed converter' utility --- and,
like the distance, area, volume, and weight 'converter'
'tkGooies' utilities, allow it to be a 'selector' utility
also, in the sense that a specified speed (in the
specified units) could be written to
'stdout' --- by a click on a button of the GUI.
Speed versus Velocity
For this utility, the term SPEED is used rather than VELOCITY, because,
strictly speaking, 'velocity' is a 'vector' and we are doing 'scalar'
calculations.
We imagine that we are dealing with 'linear' distances rather
than 'curvilinear' distances and paths.
Distances and Times
(a huge number of combinations)
Speed is a RATIO of distance-over-time.
If we imagine allowing for 10 different units-of-measure for
'distance' and 8 different units-of-measure for 'time',
this results in 10 x 8 = 80 different
units-of-measure of speed to choose from.
If --- like in the 'tkGooies' for converting distance, area,
volume, and weight --- we allow only ONE listbox for selecting
the units-of-measure for speed, the user could be dealing with
a very long list.
To avoid a long list of speed units-of-measure, I decided that
the speed-convert GUI would allow the user to pick a pair of
speed units (numerator and denominator) --- from units in TWO
'listbox' widgets.
So ...
Rather than using a single listbox with about 80 entries (or more),
we use TWO listboxes --- a 'distance' listbox and a 'time' listbox
--- with about 10 to 20 entries each.
Examples of distance units:
inches, feet, yards, miles,
kilometers, meters, centimeters, millimeters,
micrometers, nanometers, light-years, etc.
Examples of time units:
century, decade, year, week, day,
hour, minute, second, millisecond,
microsecond, nanosecond
--- and more.
Range of sizes
(huge and tiny speeds --- macro and micro)
This converter is intended to be able to convert speeds chosen
from a huge range of sizes:
-
high speeds on the order of a lightyear-per-year
(which is the speed of light ;
the theoretical maximum speed of any entity)
--- or even faster
-
--- and extremely slow speeds,
on the order of a micrometer-per-century
--- or slower.
Estimates of the diameter of the 'observable' universe are on the
order of 1.0 times 10 to the 11th lightyears --- which is about
10 to the 27th meters.
Imagine traversing the diameter of the 'observable' universe
in a second.
Even though this is theoretically impossible, this GUI allows for
dealing with speeds like 10 to the 27th meters per second.
Similarly for extremely small speeds.
Estimates of the diameter of a hydrogen atom are on the order of
1.0 times 10 to the -11 meters.
And the size of a subatomic particle is at least 1000 times smaller
--- so less than 10 to the -14 meters.
This GUI can deal with speeds encountered by traversing the
diameter of a subatomic particle in a century or more ---
where a century is about 3 times 10^9 seconds.
Traversing 10^-14 meters in 10^9 seconds is a speed on the
order of 10^-23 meters per second.
This GUI is meant to handle such extremely slow speeds.
In order to be able to handle such huge ranges, in the various
units, the GUI allows for specifying the speed (in either
of the pair of user-selected units) in 'scientific notation':
a COEFFICIENT
(for example,
between 1.00000000
and 10000.00000000)
and
an EXPONENT
(an integer, assuming a 'base' of 10).
And the exponents we want to be able to handle are on the order
of about minus-100 --- to plus-100 --- including zero.
THE GUI DESIGN
Following a Tk GUI design procedure that I started using around 2015,
I laid out a 'text-sketch' of a proposed layout for the GUI.
In the below sketch of the GUI:
|
