Looking for a math.probability newsgroup 
Author Message
 Looking for a math.probability newsgroup

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.

Thanks.

Matthew Heaney



Fri, 12 Dec 1997 03:00:00 GMT  
 Looking for a math.probability newsgroup

   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



Sat, 13 Dec 1997 03:00:00 GMT  
 Looking for a math.probability newsgroup
Did somebody ever write a paper on this subject?

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.

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



Mon, 15 Dec 1997 03:00:00 GMT  
 Looking for a math.probability newsgroup

Quote:

> Did somebody ever write a paper on this subject?

> 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++).

Actually, in Ada, you can only dispatch on one type... it's the same model
as C++, with a different 'look'... for example, where in C++ you would write
obj.foo (x), in Ada you would write foo (obj, x).

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



Tue, 16 Dec 1997 03:00:00 GMT  
 Looking for a math.probability newsgroup

Quote:
Vladimir writes:

"> I would like to answer questions about the advantages of possibly having

Quote:
> dispatching on several parameters in a primitive operation (Ada) vs having
> single dispatching on the implicit "this" parameter of a method (C++).

Actually, in Ada, you can only dispatch on one type... it's the same model
as C++, with a different 'look'... for example, where in C++ you would write
obj.foo (x), in Ada you would write foo (obj, x).

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!



Tue, 16 Dec 1997 03:00:00 GMT  
 Looking for a math.probability newsgroup

    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



Wed, 17 Dec 1997 03:00:00 GMT  
 Looking for a math.probability newsgroup

Quote:

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

Whoops. I've been doing too much C++ programming lately.

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



Wed, 17 Dec 1997 03:00:00 GMT  
 
 [ 9 post ] 

 Relevant Pages 

1. Looking for math for LargePositiveInteger

2. Looking for math for LargePositiveInteger

3. Looking for easy-to-use, powerful math software?

4. Looking for Ada Math Package

5. REQ: Looking for program that evaluates Math equations

6. Looking for the NSWC math subroutine package

7. Looking for tcl/tk's experts to fix a free math program

8. looking for a math package

9. Looking for Math Systems in Common Lisp

10. Looking for testers of the Newsgroup server

11. Looking for testers of the Newsgroup server

12. Looking for a Visual Age NewsGroup

 

 
Powered by phpBB® Forum Software