[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

# Issue: EXPT-RATIO (Version 1)

• To: CL-Cleanup@sail.stanford.edu
• Subject: Issue: EXPT-RATIO (Version 1)
• From: David A. Moon <Moon@STONY-BROOK.SCRC.Symbolics.COM>
• Date: Tue, 4 Oct 88 15:14 EDT
• Cc: JGA@STONY-BROOK.SCRC.Symbolics.COM, Cassels@STONY-BROOK.SCRC.Symbolics.COM
• References: <19880930174110.6.JGA@JUBJUB.SCRC.Symbolics.COM>

```Issue:         EXPT-RATIO

References:    CLtL pages 204 and 211

Category:      CLARIFICATION

Edit history:  Version 1, 4-Oct-88, by Aspinall and Moon

Problem description:

The comment (page 204, 2nd para) that "... an implementation [of expt]
might choose to compute (expt x 3/2) as if it had been written
(sqrt (expt x 3) 2)" disagrees with the principal value definition on
page 211.  See the example below for a case where the two disagree.  We
believe the principal value definitions are consistent and reasonable,
therefore the implementation comment is wrong.

Proposal (EXPT-RATIO:211):

Clarify that (sqrt (expt x 3) 2) is not equivalent to (expt x 3/2)
and that page 211 rules.

Test Cases/Examples:

(defvar x (exp (/ (* 2 pi #c(0 1)) 3)))         ;exp(2.pi.i/3)
(expt x 3) => 1 (except for round-off error)
(sqrt (expt x 3)) => 1 (except for round-off error)
(expt x 3/2) => -1 (except for round-off error)

There can be no question that
(expt x 3) ==> 1
because expt is single-valued with an integer second argument, and
(sqrt 1) ==> 1
definitely follows the principal branch of the square root function.

But (expt x 3/2) is defined as (exp (* (log x) 3/2)) (page 211).
(log x) ==> 2.pi.i/3
according to the definition of the logarithm's branch cuts on page 211
(which really comes down to the branch cuts of phase - page 210), so
(* (log x) 3/2) ==> pi.i
and
exp(pi.i) is -1.

Rationale:

We believe the principal value definitions are consistent and
reasonable, therefore the implementation comment is wrong.

Current practice:

Symbolics Genera 7.3 currently returns the wrong answer, following page
204 rather than page 211.  We have not surveyed any other implementations.

Cost to Implementors:

The obvious code changes in complex expt.

Cost to Users:

None.

Cost of non-adoption:

Self-contradictory language specification.

Benefits:

Users can better predict the branch cuts in expt.

Discussion:

Mathematical Explanation:  When the expt function returns a complex result
in CL (Cartesian) form, the phase of the complex number is effectively
canonicalized.  Information is lost, and that information is necessary to
specify upon which branch of the sqrt function the final result should lie.

Another way to put it would be that although
sqrt(expt(x,3)) = expt(x,3/2)
where expt and sqrt are the mathematical multi-valued functions, it is not
true that:
pv-sqrt(pv-expt(x,3)) = pv-expt(x,3/2)
where pv-expt and pv-sqrt denote the principal value versions of those functions.

```