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?

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?

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

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

Quote:

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:"

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

> 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);