Thanks.

Matthew Heaney

   Do any of you know of a mathematics newsgroup?  I have a probability problem
   that needs solving, and wanted to seek help on the 'net.

Closest I know of is Mathematica:

comp.soft-sys.math.mathematica

I read it for about a week. It seemed fairly active, and not solely
focused on the tool syntax; they would probably help with a pure math
problem, or be able to refer you on.

- Stephe
--
Stephen Leake, NASA Goddard Space Flight Center

I would like to answer questions about the advantages of possibly having
dispatching on several parameters in a primitive operation (Ada) vs having
single dispatching on the implicit "this" parameter of a method (C++).

Are there Ada dispatching examples that cannot be easily translated into C++?

Thank you,

  Jerome.

-'-^-----------------------------------------

A standard C++ trick which can also be used in Ada to re-dispatch, thereby
gaining something that looks like dispatch on multiple parameters goes
something like this:

        class B;
        class A {
                public:
                        A () { }

                        foo (B *q, int loop) {
                                if (!loop)
                                        // Redispatch based on specific type of B, with 'this'
                                        q->foo (this, 1);
                                else {
                                        // handle it
                                }
                        }
        };

        class B {
                public:
                        B () { }

                        foo (A *q, int loop) {
                                if (!loop)
                                        // Redispatch based on specific type of A, with 'this'
                                        q->foo (this, 1);
                                else {
                                        // handle it
                                }
                        }
        };

then, if you derive classes from A & B, and pass them around as A* or B*,
you can still get the most specific method which applies to the most specific
type of A & B for which the method exists, by going back & forth until
either you loop, or until some method handles it.

        - Vladimir

A standard C++ trick which can also be used in Ada to re-dispatch, thereby
gaining something that looks like dispatch on multiple parameters goes
something like this:"

Vladimir, the question was about dispatching on multiple PARAMETERS, not
on multiple TYPES. This *is* a significant difference between C++ and
Ada 95, and an important one!

    Jerome> Did somebody ever write a paper on this subject?  I would
    Jerome> like to answer questions about the advantages of possibly
    Jerome> having dispatching on several parameters in a primitive
    Jerome> operation (Ada) vs having single dispatching on the
    Jerome> implicit "this" parameter of a method (C++).
    Jerome> Are there Ada dispatching examples that cannot be easily
    Jerome> translated into C++?

The fact that there can be more than one dispatching parameters in Ada
seems quite a minor detail since all the dispatching parameters must
have EXACTLY the same tag, and they must all be dynamically tagged (or
none). So one can say that only the first one is dispatching without
changing much of the semantics of the language.
The only big difference that I know of in this area is dispatching on
result. I find this feature more confusing than useful but at least it
qualifies as "non easily translated into C++" ;-)
Example:

   ...
   type T is tagged ...;
   function F return T'class;
   procedure P (X, Y : T);
   ...

   A : T'Class := ....;

   P (A, F);
         ^
         |
         +------ This F will dispatch according to the tag of A

--
------------------------------------------------------------------------

Gnat Project                                    US phone: (212) 998-3489

Pragma (C++_Gripe, On);

C++ with fun bugs now where some obj foo which happens to be 0x0 does
stuff like foo->blah()->bar()->dostuff (i), and the dereference of 0x0
succeeds.. and you get a crash somewhere in dostuff, when it actually
tries to do anything with 'this'... of course, it was more fun where
blah() is inlined, and it seems that in g++, if you call an inlined
function which returns a pointer (just a pointer, it seems.. does
nothing else) with a this of 0x0, you get a value of 0xbadfca11 back.
cute.

Pragma (C++_Gripe, Off);

        -- Vladimir Vukicevic
        -- Team Ada Member -- Ada 95 -- Not My Father's Ada