On Wednesday, March 5, 2014 7:56:46 AM UTC-6, Steven D'Aprano wrote:On Tue, Mar 04, 2014 at 07:42:28PM -0800, Mark H. Harris wrote:
> The idea of *python number* means that there are no types, no limits, no
> constraints, and that all *python numbers *are dynamic. The upper level
> syntax is also very simple; all* python numbers *are simply human.
What makes this a "python number"? In what way are they "dynamic"?
At this point in the discussion please try not to think "implementation," rather think
conceptually in an open framework where anything is possible. Dynamic in terms
of python numbers is not that far off from the concept of dynamic name binding used
everywhere else in python.
In terms of unifying numbers as python numbers which needs to be defined at some
point, the idea of dynamic binding means first that numeric symbol sets have no type,
and are not 'bound' until run-time, if at all. Consider:
What is this? ===> PI / 2
Is it two numbers with a divisor,? or a Decimal and an int with a divisor,? or a python number ?
Or, is it a string of characters that are readily recognizable to humans that means 'the top of
the unit circle," or half_of_PI whatever I mean by that, or '1.57079632679489661923132169163975144209858469968755291048747229615390820314'
Dynamic means the symbols sets are bound (name-wise, abstraction-wise) only at run-time, and
with some 'smarts' as it were (AI) so that the right things happen under the covers (not magic)
because the machine has been taught to think, as it were, about numbers and symbols the way
normal humans do (in the kitchen, at high school, at the university, in science and business).
Another way to think of this Steven is to think of 'pretty print' on the TI 89 Platinum edition
graphical programming calculator (my personal favorite). Anyone who plays with it the first time
is frustrated because numbers are symbolized instead of printed out in strings of numerals. So
if I enter {1} [/] {3} and press enter, I get 1/3 <====
Yes, I can press evaluate and get .33333333333333333 but 1/3 is just as good a number as
any other number (and what type is it???) PI / 2 is another example. That's a great number and
I don't really need to see a numeric list of digits to use it, do I... and what is its type??? who cares.
Another very simple (and not quite good enough) example is the pdeclib file I just created over the
past couple of days. I have a need within the module to use PI or half_PI for some method or
function (but I don't need the user to know that, and I don't want to calculate it over and over, and
I want it within accuracy for the context on demand)... so what? I created __gpi__ global PI. It is
reset to Decimal(0) if the dscale(n) precision context changes. Then, and function that requires PI
of half_PI can check first to see if it is cached as __gpi__ and if so pull it back, or if not calculate
it. If the context does not change than I half some whopping value of PI for the duration of the
context (but, and this is the big but, if I don't need it --- then it never gets bound).
Binding for python numbers must be dynamic, typeless, limitless, and no constraints. If I enter a
formula of symbols into python (whatever I mean by that) python just handles it dynamically just
like the TI 89--- if I want explicit control of the processing, I am free to ask for that too, just like
the TI 89.
By the by, complex numbers are no different what-so-ever, nor fractions either, nor any other number.
The system needs to be able to parse symbol sets intelligently (Alonzo Church, Alan Turning, and John
McCarthy dreamed of this, but had no way to accomplish it in their day) and then dynamically bind
the naming / representation to the abstraction (or implementation) that makes sense for that symbol
set in 'that' context, for 'that' problem. This is not simply business as usual... it requires AI, it requires
a severe paradigm shift of a very high order.
Kind regards,
marcus