JTC1/SC22/WG14
N613
Document Number: WG14 N613/X3J11 96-077
C9X Revision Proposal
=====================
Title: Specify truncation for signed integer division
Author: Douglas A. Gwyn
Author Affiliation: United States Army Research Laboratory
Postal Address: 801-L Cashew Court, Bel Air, MD 21014, USA
E-mail Address: gwyn@arl.mil
Telephone Number: +1-410-278-8945
Fax Number: +1-410-278-2934
Sponsor: X3J11
Date: 1996-09-13
Document History: Proposal from Tom MacDonald was approved,
but consensus was not reached on the proper wording
Proposal Category:
__ Editorial change/non-normative contribution
__ Correction
__ New feature
__ Addition to obsolescent feature list
__ Addition to Future Directions
x_ Other (please specify) tighten up semantics
Area of Standard Affected:
__ Environment
x_ Language
x_ Preprocessor
x_ Library
__ Macro/typedef/tag name
x_ Function
__ Header
x_ Other (please specify) run-time semantics
Prior Art: Fortran
Target Audience: all C programmers, porters of code from
Fortran to C
Related Documents (if any): ANSI X3.9-1978, ISO 1539-1980
(programming language FORTRAN), ANSI X3.198-1992 &
ISO/IEC 1539:1992 (Fortran 90)
Proposal Attached: x_ Yes __ No, but what's your interest?
Abstract: Currently, the C standard (C89) permits some
flexibility in the implementation of signed integer
division; when the division is inexact and one of
the operands is negative, the result may be rounded
up or rounded down, in an implementation-defined
manner. (The behavior of the % operator is required
to be consistent with that of the / operator.) This
differs from Fortran, which requires that the result
must definitely be truncated toward zero. Fortran-
like behavior is permitted by C89, but it is not
required.
The origin of this practice seems to have been a
desire to map C's division directly to the "natural"
behavior of the target instruction set, whatever it
may be, without requiring extra code overhead that
might be necessary to check for special cases and
enforce a particular behavior. However, the
argument that Fortran programmers are unpleasantly
surprised by this aspect of C and that there would
be negligible impact on code efficiency was accepted
by WG14, who agreed to require Fortran-like behavior
in C9x. Previous attempts to devise wording for this
change did not attain consensus; the present proposal
takes a somewhat more radical approach, which avoids
previous ambiguities.
Proposal: The intent is to require signed integer division
where at least one operand is negative to "truncate
toward zero".
Change in 6.3.5 Multiplicative operators, Semantics,
from:
When integers are divided and the division is
inexact, if both operands are positive the
result of the / operator is the largest integer
less than the algebraic quotient and the result
of the % operator is positive. If either
operand is negative, whether the result of the
/ operator is the largest integer less than or
equal to the algebraic quotient or the smallest
integer greater than or equal to the algebraic
quotient is implementation-defined, as is the
sign of the result of the % operator.
to:
When integers are divided, the result of the /
operator must be representable as an integer,
so any fractional part of the quotient is
discarded. [FOOTNOTE: This is often called
"truncation toward zero".]
(Note that the relation between % and / is preserved.)
Change in 7.10.6.2 The div function, Description from:
If the division is inexact, the resulting
quotient is the integer of lesser magnitude
that is the nearest to the algebraic quotient.
to:
The returned quotient is the algebraic quotient
with any fractional part discarded.
In the Rationale document, replace the first paragraph
of 6.3.5 Multiplicative operators with:
In C89, division of integers involving
negative operands could round upward or
downward, in an implementation-defined manner;
the intent was to avoid incurring overhead in
run-time code to check for special cases and
enforce specific behavior. However, in Fortran
the result would always truncate toward zero,
and the overhead seems to be acceptable to the
numeric programming community. Therefore, C9x
now requires similar behavior, which should
facilitate porting of code from Fortran to C.
The table in subsection 7.10.6.2. of this
document illustrates the required semantics.
In the Rationale document, change the first sentence
of 7.10.6.2 The div function from:
div and ldiv provide a well-specified semantics
for signed integral division and remainder
operations.
to:
Because C89 had implementation-defined
semantics for division of signed integers when
negative operands were involved, div and ldiv
were invented to provide well-specified
semantics for signed integral division and
remainder operations.
In the Rationale document, add a new paragraph at the
end of 7.10.6.2 The div function:
Now that C9x requires similar semantics for
the division operator, the main reason for new
programs to use div or ldiv is to
simultaneously obtain quotient and remainder.