From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: *
X-Spam-Status: No, score=1.2 required=5.0 tests=BAYES_00,FROM_WORDY,
	INVALID_MSGID autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,184737148aef02ac
X-Google-Attributes: gid103376,public
From: "Nick Roberts" <Nick.Roberts@dial.pipex.com>
Subject: Re: Fixed point multiplication ambiguity
Date: 1999/01/28
Message-ID: <78od6d$b4t$2@plug.news.pipex.net>#1/1
X-Deja-AN: 437748800
References: <369E14CA.90715966@lmco.com>
 <F5KMxx.3L8.0.-s@inmet.camb.inmet.com>
X-MimeOLE: Produced By Microsoft MimeOLE V4.72.3110.3
Organization: UUNET WorldCom server (post doesn't reflect views of UUNET
 WorldCom)
Newsgroups: comp.lang.ada
Date: 1999-01-28T00:00:00+00:00
List-Id: <comp.lang.ada>

Tucker Taft wrote in message ...
[...]
|: procedure Tf is
|
|:     D : Duration := 5.0;
|
|:     Dec_Delt : Integer := Integer (D * 10.0 + 0.5);
|
|This is legal.  Overload resolution interprets "D * 10.0" as returning
|universal_fixed.  This is implicitly convertible to Duration (as well
|as any other fixed point type), as is 0.5.  Presuming there is no
|other fixed-point type with a directly visible "+", this should resolve,
|and use the "+" of Duration.
[...]

Yes, this is legal, but Tucker's explanation is not precisely right. The
D*10.0 does resolve as Tucker says, giving a universal_fixed. The 0.5
literal is a universal_real. Thus adding them gives us the pattern
"+"(universal_fixed,universal_real) return unknown. However, it is the rule
in RM 8.6 [29,30] preferring root types that allows this to be resolved into
the pattern "+"(root_real,root_real) return root_real implied by RM 4.5.3
[2]. So the expression D*10.0+0.5 returns a value of type root_real, which
can then be converted to an integer and assigned to Dec_Delt.

However, the expression Integer(D*10.0+0.5) causes a root_real addition and
conversion to integer to be executed dynamically. It may be slightly more
efficient to use the expression Integer(D*10+0.5) instead, causing the
multiplication, addition, and conversion to all be carried out on the type
Duration. For some implementations, operations on the type Duration will
execute slightly faster than the same operations on the type root_real. On
the other hand, some implementations' optimisers will effectively make this
change automatically.

-------------------------------------------
Nick Roberts
-------------------------------------------