Re: Alternatives to C: ObjectPascal, Eiffel, Ada or Modula-3?

[Colin Paul Gloster <Colin_Paul_Gloster@ACM.org>]

On Mon, 20 Jul 2009, Cesar Rabak wrote:

|-------------------------------------------------------------------------------|
|"[..]                                                                          |
|Nicholas Paul Collin Gloucester escreveu:                                      |
|> On 2009-07-20, Cesar Rabak <csrabak@yahoo.com.br> wrote:                     |
|[..]                                                                           |
|> In this case there is a reason for having more types. An angle and a         |
|> length are simply not interchangable, so they should not be                  |
|> represented both by Float. The amount of money equal to U.S.$1.00 is         |
|> not equal to the amount of money equal to 1.00 Canadian dollar, but          |
|> they are both written with the number 1.00.                                  |
|>                                                                              |
|                                                                               |
|I disagree strongly: an angle in radians is a real number as any other there is|
|not any intrinsic difference in its *type* on ordinary Mathematics.            |
|Dimensionally they are 'pure numbers' with no unit atached, your example on    |
|monetary units being fallacious, so non sequitur."                             |
|-------------------------------------------------------------------------------|

I doubt that you or I shall convince me or you but... if you want to
complain that I misuse the word "type", then fine. If you want to
claim that an angle in radians is the same thing as a length, then you
are mistaken. You can measure an angle with a protractor. You can not
measure a length with a protractor. You can measure a length with a
ruler. You can not measure an angle with a ruler (without some
additional hassle). A rotation is not a translation, despite both
being transformations.

If you believe that a real number of an angle in radians is the same
as a length, then do you believe that a real number of an angle
gradients is the same as a real number of an angle in degrees? 200.0
(a measurement in gradients of an angle) is not equal to pi (a
measurement in radians of the same angle) which is not equal to 180.0
(a measurement in degrees of the same angle). The angle is the same
and the numbers are not so casually interchangable.

A NASA probe was lost when all units were treated as equivalent
numbers.

|-------------------------------------------------------------------------------|
|"[..]                                                                          |
|                                                                               |
|As for normalization, IMNHO it has to be done in the constructor of the        |
|class/object, and not as an (external) wrapper."                               |
|-------------------------------------------------------------------------------|

I did not necessarily prohibit that. The wrapper could be called by
the constructor. The wrapper is external to the floating point Ada
type Radians or Magnitude or X_Coordinate or Y_Coordinate, which
itself could be restricted to the internals of a client's class, much
as a C++ std::string might use a char* internally.

If normalization is required, it might not be ideal to keep it in the
constructor because a variable could be constructed whose value is
changed later, for example
--Call a constructor for Radius but do not give it a value yet.
[..]
  for some_iterations loop
    Radius := Get_Current_Radius;
    --Do stuff.
  end loop;

|-------------------------------------------------------------------------------|
|"> With the type Radians as I had typed it,                                    |
|> Theta := 7.0;                                                                |
|> would not result in a runtime exception. It would be rejected by a           |
|> compiler.                                                                    |
|                                                                               |
|Because we are dealing with examples with literals, let the value come from an |
|input...                                                                       |
|                                                                               |
|[..]"                                                                          |
|-------------------------------------------------------------------------------|

Literals are not restricted to input, but yes, a runtime exception
would occur with input if some other precaution is not taken.