ISO/ IEC 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:
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

	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,
		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.
		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 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.
		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 of this
		document illustrates the required semantics.

	In the Rationale document, change the first sentence
	of The div function from:
		div and ldiv provide a well-specified semantics
		for signed integral division and remainder
		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 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.