<!doctype html><html lang="en">
 <head>
  <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
  <title>P1467R0: Extended floating-point types</title>
<style data-fill-with="stylesheet">/******************************************************************************
 *                   Style sheet for the W3C specifications                   *
 *
 * Special classes handled by this style sheet include:
 *
 * Indices
 *   - .toc for the Table of Contents (<ol class="toc">)
 *     + <span class="secno"> for the section numbers
 *   - #toc for the Table of Contents (<nav id="toc">)
 *   - ul.index for Indices (<a href="#ref">term</a><span>, in §N.M</span>)
 *   - table.index for Index Tables (e.g. for properties or elements)
 *
 * Structural Markup
 *   - table.data for general data tables
 *     -> use 'scope' attribute, <colgroup>, <thead>, and <tbody> for best results !
 *     -> use <table class='complex data'> for extra-complex tables
 *     -> use <td class='long'> for paragraph-length cell content
 *     -> use <td class='pre'> when manual line breaks/indentation would help readability
 *   - dl.switch for switch statements
 *   - ol.algorithm for algorithms (helps to visualize nesting)
 *   - .figure and .caption (HTML4) and figure and figcaption (HTML5)
 *     -> .sidefigure for right-floated figures
 *   - ins/del
 *
 * Code
 *   - pre and code
 *
 * Special Sections
 *   - .note       for informative notes             (div, p, span, aside, details)
 *   - .example    for informative examples          (div, p, pre, span)
 *   - .issue      for issues                        (div, p, span)
 *   - .assertion  for assertions                    (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *
 * Definition Boxes
 *   - pre.def   for WebIDL definitions
 *   - table.def for tables that define other entities (e.g. CSS properties)
 *   - dl.def    for definition lists that define other entitles (e.g. HTML elements)
 *
 * Numbering
 *   - .secno for section numbers in .toc and headings (<span class='secno'>3.2</span>)
 *   - .marker for source-inserted example/figure/issue numbers (<span class='marker'>Issue 4</span>)
 *   - ::before styled for CSS-generated issue/example/figure numbers:
 *     -> Documents wishing to use this only need to add
 *        figcaption::before,
 *        .caption::before { content: "Figure "  counter(figure) " ";  }
 *        .example::before { content: "Example " counter(example) " "; }
 *        .issue::before   { content: "Issue "   counter(issue) " ";   }
 *
 * Header Stuff (ignore, just don't conflict with these classes)
 *   - .head for the header
 *   - .copyright for the copyright
 *
 * Miscellaneous
 *   - .overlarge for things that should be as wide as possible, even if
 *     that overflows the body text area. This can be used on an item or
 *     on its container, depending on the effect desired.
 *     Note that this styling basically doesn't help at all when printing,
 *     since A4 paper isn't much wider than the max-width here.
 *     It's better to design things to fit into a narrower measure if possible.
 *   - js-added ToC jump links (see fixup.js)
 *
 ******************************************************************************/

/******************************************************************************/
/*                                   Body                                     */
/******************************************************************************/

	body {
		counter-reset: example figure issue;

		/* Layout */
		max-width: 50em;               /* limit line length to 50em for readability   */
		margin: 0 auto;                /* center text within page                     */
		padding: 1.6em 1.5em 2em 50px; /* assume 16px font size for downlevel clients */
		padding: 1.6em 1.5em 2em calc(26px + 1.5em); /* leave space for status flag     */

		/* Typography */
		line-height: 1.5;
		font-family: sans-serif;
		widows: 2;
		orphans: 2;
		word-wrap: break-word;
		overflow-wrap: break-word;
		hyphens: auto;

		/* Colors */
		color: black;
		background: white top left fixed no-repeat;
		background-size: 25px auto;
	}


/******************************************************************************/
/*                         Front Matter & Navigation                          */
/******************************************************************************/

/** Header ********************************************************************/

	div.head { margin-bottom: 1em }
	div.head hr { border-style: solid; }

	div.head h1 {
		font-weight: bold;
		margin: 0 0 .1em;
		font-size: 220%;
	}

	div.head h2 { margin-bottom: 1.5em;}

/** W3C Logo ******************************************************************/

	.head .logo {
		float: right;
		margin: 0.4rem 0 0.2rem .4rem;
	}

	.head img[src*="logos/W3C"] {
		display: block;
		border: solid #1a5e9a;
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		color: white;
		font-weight: bold;
	}

	.head a:hover > img[src*="logos/W3C"],
	.head a:focus > img[src*="logos/W3C"] {
		opacity: .8;
	}

	.head a:active > img[src*="logos/W3C"] {
		background: #c00;
		border-color: #c00;
	}

	/* see also additional rules in Link Styling section */

/** Copyright *****************************************************************/

	p.copyright,
	p.copyright small { font-size: small }

/** Back to Top / ToC Toggle **************************************************/

	@media print {
		#toc-nav {
			display: none;
		}
	}
	@media not print {
		#toc-nav {
			position: fixed;
			z-index: 2;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
			color: black;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

			height: 1.33em;
			padding: .1em 0.3em;
			margin: 0;

			background: white;
			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;
			background: white;
		}
		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		#toc-nav > a:hover,
		#toc-nav > a:focus {
			background: #f8f8f8;
		}
		#toc-nav > a:not(:hover):not(:focus) {
			color: #707070;
		}

		/* statusbar gets in the way on keyboard focus; remove once browsers fix */
		#toc-nav > a[href="#toc"]:not(:hover):focus:last-child {
			padding-bottom: 1.5rem;
		}

		#toc-nav:not(:hover) > a:not(:focus) > span + span {
			/* Ideally this uses :focus-within on #toc-nav */
			display: none;
		}
		#toc-nav > a > span + span {
			padding-right: 0.2em;
		}

		#toc-toggle-inline {
			vertical-align: 0.05em;
			font-size: 80%;
			color: gray;
			color: hsla(203,20%,40%,.7);
			border-style: none;
			background: transparent;
			position: relative;
		}
		#toc-toggle-inline:hover:not(:active),
		#toc-toggle-inline:focus:not(:active) {
			text-shadow: 1px 1px silver;
			top: -1px;
			left: -1px;
		}

		#toc-nav :active {
			color: #C00;
		}
	}

/** ToC Sidebar ***************************************************************/

	/* Floating sidebar */
	@media screen {
		body.toc-sidebar #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			max-width: 80%;
			max-width: calc(100% - 2em - 26px);
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
		}
		body.toc-sidebar #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
		}
		body.toc-sidebar #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	/* Hide main scroller when only the ToC is visible anyway */
	@media screen and (max-width: 28em) {
		body.toc-sidebar {
			overflow: hidden;
		}
	}

	/* Sidebar with its own space */
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
		}
		body:not(.toc-inline) #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
		}

		body:not(.toc-inline) {
			padding-left: 29em;
		}
		/* See also Overflow section at the bottom */

		body:not(.toc-inline) #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) {
			margin: 0 4em;
		}
	}

/******************************************************************************/
/*                                Sectioning                                  */
/******************************************************************************/

/** Headings ******************************************************************/

	h1, h2, h3, h4, h5, h6, dt {
		page-break-after: avoid;
		page-break-inside: avoid;
		font: 100% sans-serif;   /* Reset all font styling to clear out UA styles */
		font-family: inherit;    /* Inherit the font family. */
		line-height: 1.2;        /* Keep wrapped headings compact */
		hyphens: manual;         /* Hyphenated headings look weird */
	}

	h2, h3, h4, h5, h6 {
		margin-top: 3rem;
	}

	h1, h2, h3 {
		color: #005A9C;
		background: transparent;
	}

	h1 { font-size: 170%; }
	h2 { font-size: 140%; }
	h3 { font-size: 120%; }
	h4 { font-weight: bold; }
	h5 { font-style: italic; }
	h6 { font-variant: small-caps; }
	dt { font-weight: bold; }

/** Subheadings ***************************************************************/

	h1 + h2,
	#subtitle {
		/* #subtitle is a subtitle in an H2 under the H1 */
		margin-top: 0;
	}
	h2 + h3,
	h3 + h4,
	h4 + h5,
	h5 + h6 {
		margin-top: 1.2em; /* = 1 x line-height */
	}

/** Section divider ***********************************************************/

	:not(.head) > hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		border: transparent solid 0;
		background: transparent;
	}
	:not(.head) > hr::before {
		content: "\2727\2003\2003\2727\2003\2003\2727";
	}

/******************************************************************************/
/*                            Paragraphs and Lists                            */
/******************************************************************************/

	p {
		margin: 1em 0;
	}

	dd > p:first-child,
	li > p:first-child {
		margin-top: 0;
	}

	ul, ol {
		margin-left: 0;
		padding-left: 2em;
	}

	li {
		margin: 0.25em 0 0.5em;
		padding: 0;
	}

	dl dd {
		margin: 0 0 .5em 2em;
	}

	.head dd + dd { /* compact for header */
		margin-top: -.5em;
	}

	/* Style for algorithms */
	ol.algorithm ol:not(.algorithm),
	.algorithm > ol ol:not(.algorithm) {
	 border-left: 0.5em solid #DEF;
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	  padding: .5em;
	  border: thin solid #ddd; border-radius: .5em;
	  margin: .5em calc(-0.5em - 1px);
	}
	[data-algorithm]:not(.heading) > :first-child {
	  margin-top: 0;
	}
	[data-algorithm]:not(.heading) > :last-child {
	  margin-bottom: 0;
	}

	/* Style for switch/case <dl>s */
	dl.switch > dd > ol.only,
	dl.switch > dd > .only > ol {
	 margin-left: 0;
	}
	dl.switch > dd > ol.algorithm,
	dl.switch > dd > .algorithm > ol {
	 margin-left: -2em;
	}
	dl.switch {
	 padding-left: 2em;
	}
	dl.switch > dt {
	 text-indent: -1.5em;
	 margin-top: 1em;
	}
	dl.switch > dt + dt {
	 margin-top: 0;
	}
	dl.switch > dt::before {
	 content: '\21AA';
	 padding: 0 0.5em 0 0;
	 display: inline-block;
	 width: 1em;
	 text-align: right;
	 line-height: 0.5em;
	}

/** Terminology Markup ********************************************************/


/******************************************************************************/
/*                                 Inline Markup                              */
/******************************************************************************/

/** Terminology Markup ********************************************************/
	dfn   { /* Defining instance */
		font-weight: bolder;
	}
	a > i { /* Instance of term */
		font-style: normal;
	}
	dt dfn code, code.idl {
		font-size: medium;
	}
	dfn var {
		font-style: normal;
	}

/** Change Marking ************************************************************/

	del { color: red;  text-decoration: line-through; }
	ins { color: #080; text-decoration: underline;    }

/** Miscellaneous improvements to inline formatting ***************************/

	sup {
		vertical-align: super;
		font-size: 80%
	}

/******************************************************************************/
/*                                    Code                                    */
/******************************************************************************/

/** General monospace/pre rules ***********************************************/

	pre, code, samp {
		font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
		font-size: .9em;
		page-break-inside: avoid;
		hyphens: none;
		text-transform: none;
	}
	pre code,
	code code {
		font-size: 100%;
	}

	pre {
		margin-top: 1em;
		margin-bottom: 1em;
		overflow: auto;
	}

/** Inline Code fragments *****************************************************/

  /* Do something nice. */

/******************************************************************************/
/*                                    Links                                   */
/******************************************************************************/

/** General Hyperlinks ********************************************************/

	/* We hyperlink a lot, so make it less intrusive */
	a[href] {
		color: #034575;
		text-decoration: none;
		border-bottom: 1px solid #707070;
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		border-bottom-color: #BBB;
	}

	/* Use distinguishing colors when user is interacting with the link */
	a[href]:focus,
	a[href]:hover {
		background: #f8f8f8;
		background: rgba(75%, 75%, 75%, .25);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	a[href]:active {
		color: #C00;
		border-color: #C00;
	}

	/* Backout above styling for W3C logo */
	.head .logo,
	.head .logo a {
		border: none;
		text-decoration: none;
		background: transparent;
	}

/******************************************************************************/
/*                                    Images                                  */
/******************************************************************************/

	img {
		border-style: none;
	}

	/* For autogen numbers, add
	   .caption::before, figcaption::before { content: "Figure " counter(figure) ". "; }
	*/

	figure, .figure, .sidefigure {
		page-break-inside: avoid;
		text-align: center;
		margin: 2.5em 0;
	}
	.figure img,    .sidefigure img,    figure img,
	.figure object, .sidefigure object, figure object {
		max-width: 100%;
		margin: auto;
	}
	.figure pre, .sidefigure pre, figure pre {
		text-align: left;
		display: table;
		margin: 1em auto;
	}
	.figure table, figure table {
		margin: auto;
	}
	@media screen and (min-width: 20em) {
		.sidefigure {
			float: right;
			width: 50%;
			margin: 0 0 0.5em 0.5em
		}
	}
	.caption, figcaption, caption {
		font-style: italic;
		font-size: 90%;
	}
	.caption::before, figcaption::before, figcaption > .marker {
		font-weight: bold;
	}
	.caption, figcaption {
		counter-increment: figure;
	}

	/* DL list is indented 2em, but figure inside it is not */
	dd > .figure, dd > figure { margin-left: -2em }

/******************************************************************************/
/*                             Colored Boxes                                  */
/******************************************************************************/

	.issue, .note, .example, .assertion, .advisement, blockquote {
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	.issue,
	.note,
	.example,
	.advisement,
	.assertion,
	blockquote {
		margin: 1em auto;
	}
	.note  > p:first-child,
	.issue > p:first-child,
	blockquote > :first-child {
		margin-top: 0;
	}
	blockquote > :last-child {
		margin-bottom: 0;
	}

/** Blockquotes ***************************************************************/

	blockquote {
		border-color: silver;
	}

/** Open issue ****************************************************************/

	.issue {
		border-color: #E05252;
		background: #FBE9E9;
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		text-transform: uppercase;
		color: #AE1E1E;
		padding-right: 1em;
		text-transform: uppercase;
	}
	/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
	   or use class="marker" to mark up the issue number in source. */

/** Example *******************************************************************/

	.example {
		border-color: #E0CB52;
		background: #FCFAEE;
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		text-transform: uppercase;
		color: #827017;
		min-width: 7.5em;
		display: block;
	}
	/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
	   or use class="marker" to mark up the example number in source. */

/** Non-normative Note ********************************************************/

	.note {
		border-color: #52E052;
		background: #E9FBE9;
		overflow: auto;
	}

	.note::before, .note > .marker,
	details.note > summary::before,
	details.note > summary > .marker {
		text-transform: uppercase;
		display: block;
		color: hsl(120, 70%, 30%);
	}
	/* Add .note::before { content: "Note"; } for autogen label,
	   or use class="marker" to mark up the label in source. */

	details.note > summary {
		display: block;
		color: hsl(120, 70%, 30%);
	}
	details.note[open] > summary {
		border-bottom: 1px silver solid;
	}

/** Assertion Box *************************************************************/
	/*  for assertions in algorithms */

	.assertion {
		border-color: #AAA;
		background: #EEE;
	}

/** Advisement Box ************************************************************/
	/*  for attention-grabbing normative statements */

	.advisement {
		border-color: orange;
		border-style: none solid;
		background: #FFEECC;
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement > .marker {
		color: #B35F00;
	}

/** Spec Obsoletion Notice ****************************************************/
	/* obnoxious obsoletion notice for older/abandoned specs. */

	details {
		display: block;
	}
	summary {
		font-weight: bolder;
	}

	.annoying-warning:not(details),
	details.annoying-warning:not([open]) > summary,
	details.annoying-warning[open] {
		background: #fdd;
		color: red;
		font-weight: bold;
		padding: .75em 1em;
		border: thick red;
		border-style: solid;
		border-radius: 1em;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

@media not print {
	details.annoying-warning[open] {
		position: fixed;
		left: 1em;
		right: 1em;
		bottom: 1em;
		z-index: 1000;
	}
}

	details.annoying-warning:not([open]) > summary {
		text-align: center;
	}

/** Entity Definition Boxes ***************************************************/

	.def {
		padding: .5em 1em;
		background: #DEF;
		margin: 1.2em 0;
		border-left: 0.5em solid #8CCBF2;
	}

/******************************************************************************/
/*                                    Tables                                  */
/******************************************************************************/

	th, td {
		text-align: left;
		text-align: start;
	}

/** Property/Descriptor Definition Tables *************************************/

	table.def {
		/* inherits .def box styling, see above */
		width: 100%;
		border-spacing: 0;
	}

	table.def td,
	table.def th {
		padding: 0.5em;
		vertical-align: baseline;
		border-bottom: 1px solid #bbd7e9;
	}

	table.def > tbody > tr:last-child th,
	table.def > tbody > tr:last-child td {
		border-bottom: 0;
	}

	table.def th {
		font-style: italic;
		font-weight: normal;
		padding-left: 1em;
		width: 3em;
	}

	/* For when values are extra-complex and need formatting for readability */
	table td.pre {
		white-space: pre-wrap;
	}

	/* A footnote at the bottom of a def table */
	table.def           td.footnote {
		padding-top: 0.6em;
	}
	table.def           td.footnote::before {
		content: " ";
		display: block;
		height: 0.6em;
		width: 4em;
		border-top: thin solid;
	}

/** Data tables (and properly marked-up index tables) *************************/
	/*
		 <table class="data"> highlights structural relationships in a table
		 when correct markup is used (e.g. thead/tbody, th vs. td, scope attribute)

		 Use class="complex data" for particularly complicated tables --
		 (This will draw more lines: busier, but clearer.)

		 Use class="long" on table cells with paragraph-like contents
		 (This will adjust text alignment accordingly.)
		 Alternately use class="longlastcol" on tables, to have the last column assume "long".
	*/

	table {
		word-wrap: normal;
		overflow-wrap: normal;
		hyphens: manual;
	}

	table.data,
	table.index {
		margin: 1em auto;
		border-collapse: collapse;
		border: hidden;
		width: 100%;
	}
	table.data caption,
	table.index caption {
		max-width: 50em;
		margin: 0 auto 1em;
	}

	table.data td,  table.data th,
	table.index td, table.index th {
		padding: 0.5em 1em;
		border-width: 1px;
		border-color: silver;
		border-top-style: solid;
	}

	table.data thead td:empty {
		padding: 0;
		border: 0;
	}

	table.data  thead,
	table.index thead,
	table.data  tbody,
	table.index tbody {
		border-bottom: 2px solid;
	}

	table.data colgroup,
	table.index colgroup {
		border-left: 2px solid;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		border-right: 2px solid;
		border-top: 1px solid silver;
		padding-right: 1em;
	}

	table.data th[colspan],
	table.data td[colspan] {
		text-align: center;
	}

	table.complex.data th,
	table.complex.data td {
		border: 1px solid silver;
		text-align: center;
	}

	table.data.longlastcol td:last-child,
	table.data td.long {
	 vertical-align: baseline;
	 text-align: left;
	}

	table.data img {
		vertical-align: middle;
	}


/*
Alternate table alignment rules

	table.data,
	table.index {
		text-align: center;
	}

	table.data  thead th[scope="row"],
	table.index thead th[scope="row"] {
		text-align: right;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		text-align: right;
	}

Possible extra rowspan handling

	table.data  tbody th[rowspan]:not([rowspan='1']),
	table.index tbody th[rowspan]:not([rowspan='1']),
	table.data  tbody td[rowspan]:not([rowspan='1']),
	table.index tbody td[rowspan]:not([rowspan='1']) {
		border-left: 1px solid silver;
	}

	table.data  tbody th[rowspan]:first-child,
	table.index tbody th[rowspan]:first-child,
	table.data  tbody td[rowspan]:first-child,
	table.index tbody td[rowspan]:first-child{
		border-left: 0;
		border-right: 1px solid silver;
	}
*/

/******************************************************************************/
/*                                  Indices                                   */
/******************************************************************************/


/** Table of Contents *********************************************************/

	.toc a {
		/* More spacing; use padding to make it part of the click target. */
		padding-top: 0.1rem;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Reverse color scheme */
		color: black;
		border-color: #3980B5;
		border-bottom-width: 3px !important;
		margin-bottom: 0px !important;
	}
	.toc a:visited {
		border-color: #054572;
	}
	.toc a:not(:focus):not(:hover) {
		/* Allow colors to cascade through from link styling */
		border-bottom-color: transparent;
	}

	.toc, .toc ol, .toc ul, .toc li {
		list-style: none; /* Numbers must be inlined into source */
		/* because generated content isn't search/selectable and markers can't do multilevel yet */
		margin:  0;
		padding: 0;
		line-height: 1.1rem; /* consistent spacing */
	}

	/* ToC not indented until third level, but font style & margins show hierarchy */
	.toc > li             { font-weight: bold;   }
	.toc > li li          { font-weight: normal; }
	.toc > li li li       { font-size:   95%;    }
	.toc > li li li li    { font-size:   90%;    }
	.toc > li li li li .secno { font-size: 85%; }
	.toc > li li li li li { font-size:   85%;    }
	.toc > li li li li li .secno { font-size: 100%; }

	/* @supports not (display:grid) { */
		.toc > li             { margin: 1.5rem 0;    }
		.toc > li li          { margin: 0.3rem 0;    }
		.toc > li li li       { margin-left: 2rem;   }

		/* Section numbers in a column of their own */
		.toc .secno {
			float: left;
			width: 4rem;
			white-space: nowrap;
		}

		.toc li {
			clear: both;
		}

		:not(li) > .toc              { margin-left:  5rem; }
		.toc .secno                  { margin-left: -5rem; }
		.toc > li li li .secno       { margin-left: -7rem; }
		.toc > li li li li .secno    { margin-left: -9rem; }
		.toc > li li li li li .secno { margin-left: -11rem; }

		/* Tighten up indentation in narrow ToCs */
		@media (max-width: 30em) {
			:not(li) > .toc              { margin-left:  4rem; }
			.toc .secno                  { margin-left: -4rem; }
			.toc > li li li              { margin-left:  1rem; }
			.toc > li li li .secno       { margin-left: -5rem; }
			.toc > li li li li .secno    { margin-left: -6rem; }
			.toc > li li li li li .secno { margin-left: -7rem; }
		}
	/* } */

	@supports (display:grid) {
		/* Use #toc over .toc to override non-@supports rules. */
		#toc {
			display: grid;
			align-content: start;
			grid-template-columns: auto 1fr;
			grid-column-gap: 1rem;
			column-gap: 1rem;
			grid-row-gap: .6rem;
			row-gap: .6rem;
		}
		#toc h2 {
			grid-column: 1 / -1;
			margin-bottom: 0;
		}
		#toc ol,
		#toc li,
		#toc a {
			display: contents;
			/* Switch <a> to subgrid when supported */
		}
		#toc span {
			margin: 0;
		}
		#toc > .toc > li > a > span {
			/* The spans of the top-level list,
			   comprising the first items of each top-level section. */
			margin-top: 1.1rem;
		}
		#toc#toc .secno { /* Ugh, need more specificity to override base.css */
			grid-column: 1;
			width: auto;
			margin-left: 0;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
		}
		#toc .content:hover {
			background: rgba(75%, 75%, 75%, .25);
			border-bottom: 3px solid #054572;
			margin-bottom: -3px;
		}
		#toc li li li .content {
			margin-left: 1rem;
		}
		#toc li li li li .content {
			margin-left: 2rem;
		}
	}


/** Index *********************************************************************/

	/* Index Lists: Layout */
	ul.index       { margin-left: 0; columns: 15em; text-indent: 1em hanging; }
	ul.index li    { margin-left: 0; list-style: none; break-inside: avoid; }
	ul.index li li { margin-left: 1em }
	ul.index dl    { margin-top: 0; }
	ul.index dt    { margin: .2em 0 .2em 20px;}
	ul.index dd    { margin: .2em 0 .2em 40px;}
	/* Index Lists: Typography */
	ul.index ul,
	ul.index dl { font-size: smaller; }
	@media not print {
		ul.index li span {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
		}
	}

/** Index Tables *****************************************************/
	/* See also the data table styling section, which this effectively subclasses */

	table.index {
		font-size: small;
		border-collapse: collapse;
		border-spacing: 0;
		text-align: left;
		margin: 1em 0;
	}

	table.index td,
	table.index th {
		padding: 0.4em;
	}

	table.index tr:hover td:not([rowspan]),
	table.index tr:hover th:not([rowspan]) {
		background: #f7f8f9;
	}

	/* The link in the first column in the property table (formerly a TD) */
	table.index th:first-child a {
		font-weight: bold;
	}

/******************************************************************************/
/*                                    Print                                   */
/******************************************************************************/

	@media print {
		/* Pages have their own margins. */
		html {
			margin: 0;
		}
		/* Serif for print. */
		body {
			font-family: serif;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}

/******************************************************************************/
/*                                    Legacy                                  */
/******************************************************************************/

	/* This rule is inherited from past style sheets. No idea what it's for. */
	.hide { display: none }



/******************************************************************************/
/*                             Overflow Control                               */
/******************************************************************************/

	.figure .caption, .sidefigure .caption, figcaption {
		/* in case figure is overlarge, limit caption to 50em */
		max-width: 50rem;
		margin-left: auto;
		margin-right: auto;
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-left: calc(13px + 26.5rem - 50vw);
			margin-right: calc(13px + 26.5rem - 50vw);
			max-width: none;
		}
	}
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) .overlarge {
			/* 30.5em body padding 50em content area */
			margin-left: calc(40em - 50vw) !important;
			margin-right: calc(40em - 50vw) !important;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) .overlarge {
			/* 4em html margin 30.5em body padding 50em content area */
			margin-left: 0 !important;
			margin-right: calc(84.5em - 100vw) !important;
		}
	}

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			 * http://lea.verou.me/2012/04/background-attachment-local/
			 *
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
			            top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
			            top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style type="text/css">
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }
  </style>
  <meta content="Bikeshed version dff342f4b23fb230b71436fb31b55f5f169715bd" name="generator">
  <link href="https://wg21.link/P1467R0" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="fb1a34ced14452c34269737974f54f5bfbb7ece5" name="document-revision">
<style>
ins             {background-color: #CCFFCC;             text-decoration: underline;}
del             {background-color: #FFCACA;             text-decoration: line-through;}
ins .highlight  {background-color: #CCFFCC !important;  text-decoration: underline;}
ins blockquote  {border-color:     #008000 !important;  text-decoration: underline;}
del .highlight  {background-color: #FFCACA !important;  text-decoration: line-through;}
del blockquote  {border-color:     #FF0000 !important;  text-decoration: line-through;}
</style>
<style>/* style-md-lists */

/* This is a weird hack for me not yet following the commonmark spec
   regarding paragraph and lists. */
[data-md] > :first-child {
    margin-top: 0;
}
[data-md] > :last-child {
    margin-bottom: 0;
}</style>
<style>/* style-hidedel */

            #hidedel:checked ~ del, #hidedel:checked ~ * del { display:none; }
            #hidedel ~ #hidedel-label::before, #hidedel ~ * #hidedel-label::before { content: "☐ "; }
            #hidedel:checked ~ #hidedel-label::before, #hidedel:checked ~ * #hidedel-label::before { content: "☑ "; }
        </style>
<style>/* style-selflinks */

.heading, .issue, .note, .example, li, dt {
    position: relative;
}
a.self-link {
    position: absolute;
    top: 0;
    left: calc(-1 * (3.5rem - 26px));
    width: calc(3.5rem - 26px);
    height: 2em;
    text-align: center;
    border: none;
    transition: opacity .2s;
    opacity: .5;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: gray;
    color: white;
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: black;
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }</style>
<style>/* style-counters */

body {
    counter-reset: example figure issue;
}
.issue {
    counter-increment: issue;
}
.issue:not(.no-marker)::before {
    content: "Issue " counter(issue);
}

.example {
    counter-increment: example;
}
.example:not(.no-marker)::before {
    content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
    content: "Invalid Example" counter(example);
}

figcaption {
    counter-increment: figure;
}
figcaption:not(.no-marker)::before {
    content: "Figure " counter(figure) " ";
}</style>
<style>/* style-autolinks */

.css.css, .property.property, .descriptor.descriptor {
    color: #005a9c;
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

[data-link-type].production::before,
[data-link-type].production::after,
.prod [data-link-type]::before,
.prod [data-link-type]::after {
    content: "";
}

[data-link-type=element],
[data-link-type=element-attr] {
    font-family: Menlo, Consolas, "DejaVu Sans Mono", monospace;
    font-size: .9em;
}
[data-link-type=element]::before { content: "<" }
[data-link-type=element]::after  { content: ">" }

[data-link-type=biblio] {
    white-space: pre;
}</style>
<style>/* style-syntax-highlighting */

.highlight:not(.idl) { background: hsl(24, 20%, 95%); }
code.highlight { padding: .1em; border-radius: .3em; }
pre.highlight, pre > code.highlight { display: block; padding: 1em; margin: .5em 0; overflow: auto; border-radius: 0; }
c-[a] { color: #990055 } /* Keyword.Declaration */
c-[b] { color: #990055 } /* Keyword.Type */
c-[c] { color: #708090 } /* Comment */
c-[d] { color: #708090 } /* Comment.Multiline */
c-[e] { color: #0077aa } /* Name.Attribute */
c-[f] { color: #669900 } /* Name.Tag */
c-[g] { color: #222222 } /* Name.Variable */
c-[k] { color: #990055 } /* Keyword */
c-[l] { color: #000000 } /* Literal */
c-[m] { color: #000000 } /* Literal.Number */
c-[n] { color: #0077aa } /* Name */
c-[o] { color: #999999 } /* Operator */
c-[p] { color: #999999 } /* Punctuation */
c-[s] { color: #a67f59 } /* Literal.String */
c-[t] { color: #a67f59 } /* Literal.String.Single */
c-[u] { color: #a67f59 } /* Literal.String.Double */
c-[cp] { color: #708090 } /* Comment.Preproc */
c-[c1] { color: #708090 } /* Comment.Single */
c-[cs] { color: #708090 } /* Comment.Special */
c-[kc] { color: #990055 } /* Keyword.Constant */
c-[kn] { color: #990055 } /* Keyword.Namespace */
c-[kp] { color: #990055 } /* Keyword.Pseudo */
c-[kr] { color: #990055 } /* Keyword.Reserved */
c-[ld] { color: #000000 } /* Literal.Date */
c-[nc] { color: #0077aa } /* Name.Class */
c-[no] { color: #0077aa } /* Name.Constant */
c-[nd] { color: #0077aa } /* Name.Decorator */
c-[ni] { color: #0077aa } /* Name.Entity */
c-[ne] { color: #0077aa } /* Name.Exception */
c-[nf] { color: #0077aa } /* Name.Function */
c-[nl] { color: #0077aa } /* Name.Label */
c-[nn] { color: #0077aa } /* Name.Namespace */
c-[py] { color: #0077aa } /* Name.Property */
c-[ow] { color: #999999 } /* Operator.Word */
c-[mb] { color: #000000 } /* Literal.Number.Bin */
c-[mf] { color: #000000 } /* Literal.Number.Float */
c-[mh] { color: #000000 } /* Literal.Number.Hex */
c-[mi] { color: #000000 } /* Literal.Number.Integer */
c-[mo] { color: #000000 } /* Literal.Number.Oct */
c-[sb] { color: #a67f59 } /* Literal.String.Backtick */
c-[sc] { color: #a67f59 } /* Literal.String.Char */
c-[sd] { color: #a67f59 } /* Literal.String.Doc */
c-[se] { color: #a67f59 } /* Literal.String.Escape */
c-[sh] { color: #a67f59 } /* Literal.String.Heredoc */
c-[si] { color: #a67f59 } /* Literal.String.Interpol */
c-[sx] { color: #a67f59 } /* Literal.String.Other */
c-[sr] { color: #a67f59 } /* Literal.String.Regex */
c-[ss] { color: #a67f59 } /* Literal.String.Symbol */
c-[vc] { color: #0077aa } /* Name.Variable.Class */
c-[vg] { color: #0077aa } /* Name.Variable.Global */
c-[vi] { color: #0077aa } /* Name.Variable.Instance */
c-[il] { color: #000000 } /* Literal.Number.Integer.Long */
</style>
 <body class="h-entry">
  <input id="hidedel" style="display:none" type="checkbox">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P1467R0<br>Extended floating-point types</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Published Proposal, <time class="dt-updated" datetime="2019-01-21">2019-01-21</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://wg21.link/P1467R0">https://wg21.link/P1467R0</a>
     <dt>Authors:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:griwes@griwes.info">Michał Dominiak</a> (<span class="p-org org">NVIDIA</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:dolsen@nvidia.com">David Olsen</a> (<span class="p-org org">NVIDIA</span>)
     <dt>Audience:
     <dd>SG6, EWG, LEWG
     <dt>Toggle Diffs:
     <dd>
      <label for="hidedel" id="hidedel-label">Hide deleted text</label>
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li><a href="#abstract"><span class="secno">1</span> <span class="content">Abstract</span></a>
    <li><a href="#motivation"><span class="secno">2</span> <span class="content">Motivation</span></a>
    <li>
     <a href="#proposal"><span class="secno">3</span> <span class="content">Proposed approach</span></a>
     <ol class="toc">
      <li>
       <a href="#design"><span class="secno">3.1</span> <span class="content">Finer design details</span></a>
       <ol class="toc">
        <li><a href="#rank"><span class="secno">3.1.1</span> <span class="content">Floating-point conversion rank</span></a>
        <li><a href="#narrowing"><span class="secno">3.1.2</span> <span class="content">Narrowing conversions</span></a>
        <li><a href="#support"><span class="secno">3.1.3</span> <span class="content">Support throughout the library</span></a>
       </ol>
     </ol>
    <li>
     <a href="#wording"><span class="secno">4</span> <span class="content">Proposed wording</span></a>
     <ol class="toc">
      <li><a href="#core"><span class="secno">4.1</span> <span class="content">Core language</span></a>
      <li><a href="#library"><span class="secno">4.2</span> <span class="content">Library</span></a>
     </ol>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="abstract"><span class="secno">1. </span><span class="content">Abstract</span><a class="self-link" href="#abstract"></a></h2>
   <p>This proposal is the less evolutionary part of <a data-link-type="biblio" href="#biblio-p1468">[P1468]</a>, that attempts to ultimately provide the same functionality of <a data-link-type="biblio" href="#biblio-p0192">[P0192]</a> in a way that we expect to be more acceptable to the committee than the previous attempt.</p>
   <p>This paper introduces the notion of <em>extended floating-point types</em>, modeled after extended integer types. To accomodate them,
this paper also attempts to rewrite the current rules for floating-point types, to enable well-defined interactions between all
the floating-point types. The end goal of this paper, together with <a data-link-type="biblio" href="#biblio-p1468">[P1468]</a>, is to have a language to enable <code class="highlight"><c- o>&lt;</c-><c- n>cstdint</c-><c- o>></c-></code>-like
aliases for implementation specific floating point types, that can model more binary layouts than just a single fundamental type
(the previously proposed <code class="highlight"><c- b>short</c-> <c- b>float</c-></code>) can provide for.</p>
   <p>It also attempts to rewrite existing specification for both the core language and the library to not spell out all standard
floating-point types every time.</p>
   <h2 class="heading settled" data-level="2" id="motivation"><span class="secno">2. </span><span class="content">Motivation</span><a class="self-link" href="#motivation"></a></h2>
   <p>The motivation for the general effort of this paper is the same as for <a data-link-type="biblio" href="#biblio-p0192">[P0192]</a>, so we decided to avoid repeating it here, for
brevity.</p>
   <p>The motivation for taking the currently proposed approach comes from the result of discussion on the previous paper. Several
people raised concerns about introducing just a single new fundamental type with not well defined layout; those same people
were not satisfied with the option of having a dual ABI for that type, when for instance both IEEE-754 <code class="highlight"><c- n>binary16</c-></code> and <code class="highlight"><c- n>bfloat</c-></code> are needed in the same application.</p>
   <p>This paper legitimizes implementation-specific floating-point types, which makes standardizing an existing practice an additional
motivation for solving the need in the way described below.</p>
   <h2 class="heading settled" data-level="3" id="proposal"><span class="secno">3. </span><span class="content">Proposed approach</span><a class="self-link" href="#proposal"></a></h2>
   <p>In a nutshell:</p>
   <ol>
    <li data-md>
     <p>Introduce the notion of <em>extended floating-point types</em>.</p>
    <li data-md>
     <p>Redefine usual arithmetic conversions in terms of <em>floating-point conversion rank</em>, closely modeled after the integer
equivalent.</p>
    <li data-md>
     <p>Redefine narrowing conversions for floating-point types, to be defined in terms of value ranges, instead of being fixed
for the standard floating-point types.</p>
    <li data-md>
     <p>Rewrite as much of the standard library spec to use the new notion where it is possible and makes sense.</p>
   </ol>
   <h3 class="heading settled" data-level="3.1" id="design"><span class="secno">3.1. </span><span class="content">Finer design details</span><a class="self-link" href="#design"></a></h3>
   <p>Here’s a list of the details of the design of this paper that we think are important; we’d like guidance on whether the committee
likes the decision we’ve made, or if a change to them is requested; please consider them as proposed polls to determine that.</p>
   <h4 class="heading settled" data-level="3.1.1" id="rank"><span class="secno">3.1.1. </span><span class="content">Floating-point conversion rank</span><a class="self-link" href="#rank"></a></h4>
   <p>At this time, the paper uses the <em>range of finite values</em> of a given floating-point type for determining the conversion rank;
this is motivated by the fact that converting a value to a type that can’t represent it is undefined behavior. It is
implementation-defined if a floating-point type can represent infinities or not; if they can, then the UB goes away, but we think
that this is the useful way to determine the rank, even when the range of values is the entire set of real numbers, therefore
the use of the notion of range of <strong>finite</strong> values. There is probably more acceptable behaviors, but this seems to be the most
acceptable of them for the authors.</p>
   <p>Since the definition this paper gives orders types by the relation of the ranges of finite values of different types, we included
an item for when two types have ranges of finite values that are neither a subset nor a superset of each other. This doesn’t seem
necessary in reality, but we decided to include it for completeness of the rules.</p>
   <h4 class="heading settled" data-level="3.1.2" id="narrowing"><span class="secno">3.1.2. </span><span class="content">Narrowing conversions</span><a class="self-link" href="#narrowing"></a></h4>
   <p>This paper proposes to change the rules of narrowing conversions in a way that may introduce changes to what expressions are
well- or ill-formed on systems, where <code class="highlight"><c- b>float</c-></code> and <code class="highlight"><c- b>double</c-></code>, and/or <code class="highlight"><c- b>double</c-></code> and <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>, have the same size and layout.</p>
   <p>Currently, the rule for narrowing conversion reads: <code class="highlight"><c- b>long</c-> <c- b>double</c-></code> to <code class="highlight"><c- b>double</c-></code> or <code class="highlight"><c- b>float</c-></code> and <code class="highlight"><c- b>double</c-></code> to <code class="highlight"><c- b>float</c-></code> is a narrowed
conversion. After the proposed change, that will only be the case if those types have different ranges of finite values. This
change is made to simplify the rules; the rule that determines if a conversion is narrowing or not based on the range of finite
values is necessary for extended floating-point types, so it needs to appear in the text, so we decided to change the old rule
and unify it with the new one; the situation where they give a different result seems strange enough to justify this decision.</p>
   <p>There’s another possible approach: to define that a floating-point conversion from a type with a higher floating-point conversion
rank to a type with a lower floating-point conversion rank is always narrowing. This mostly follows the rule above, however it
preserves the current narrowing conversion relations between standard floating-point types. This is not the approach currently
worded by this paper, but we have no objections to move to this approach if it is preferred by the committee.</p>
   <h4 class="heading settled" data-level="3.1.3" id="support"><span class="secno">3.1.3. </span><span class="content">Support throughout the library</span><a class="self-link" href="#support"></a></h4>
   <p>Extended floating-point types are supported in some part of the library, that is: <code class="highlight"><c- o>&lt;</c-><c- n>cmath</c-><c- o>></c-></code> (because having access to operations
on shorter <code class="highlight"><c- b>float</c-></code>s is the entire point of this feature), <code class="highlight"><c- o>&lt;</c-><c- n>complex</c-><c- o>></c-></code> (for the same reason), and <code class="highlight"><c- o>&lt;</c-><c- n>charconv</c-><c- o>></c-></code> (because some way
of I/O should be available for them, and because the existing spec supports extended integer types already). They are not
supported in <code class="highlight"><c- n>num_get</c-></code> and <code class="highlight"><c- n>num_put</c-></code>, because (a) properly supporting them would require an ABI break (and then again every
time the implementation adds an extended floating-point type) and (b) because extended integer types are not supported there.
Similarly, no stream support is included in this paper.</p>
   <h2 class="heading settled" data-level="4" id="wording"><span class="secno">4. </span><span class="content">Proposed wording</span><a class="self-link" href="#wording"></a></h2>
   <p>The wording changes in this paper are relative to N4791.</p>
   <h3 class="heading settled" data-level="4.1" id="core"><span class="secno">4.1. </span><span class="content">Core language</span><a class="self-link" href="#core"></a></h3>
   <p>Modify Fundamental types [<strong>basic.fundamental</strong>] paragraph 12:</p>
   <blockquote>
    <p>
     There are three <i><ins>standard </ins>floating-point types</i>: <code class="highlight"><c- b>float</c-></code>, <code class="highlight"><c- b>double</c-></code>, and <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>. The type <code class="highlight"><c- b>double</c-></code> provides
  at least as much precision as <code class="highlight"><c- b>float</c-></code>, and the type <code class="highlight"><c- b>long</c-> <c- b>double</c-></code> provides at least as much precision as <code class="highlight"><c- b>double</c-></code>. The set of
  values of the type <code class="highlight"><c- b>float</c-></code> is a subset of the set of values of the type <code class="highlight"><c- b>double</c-></code>; the set of values of the type <code class="highlight"><c- b>double</c-></code> is a
  subset of the set of values of the type <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>. The value representation of 
     <ins>standard </ins>
     floating-point types is
  implementation-defined. 
     <ins>There may also be implementation-defined <em>extended floating-point types</em>. The range from the
  lowest finite value representable by a floating-point type to the maximum finite value representable by that type is called the <em>range of finite values</em> of that type. The standard and extended floating-point types are collectively called <em>floating-point
  types</em>.</ins>
      [...]
    </p>
   </blockquote>
   <p>
    Rename 
    <del>Integer conversion rank</del>
     [<strong>conv.rank</strong>] to 
    <ins>Conversion ranks</ins>
     and insert a new paragraph at the end:
   </p>
   <ins>
    <blockquote>
     <ol start="2">
      <li data-md>
       <p>Every floating-point type has an <em>floating-point conversion rank</em> defined as follows:</p>
       <ul>
        <li data-md>
         <p>(2.1) The rank of a floating point type <code class="highlight"><c- n>T</c-></code> shall be greater than the rank of any floating-point type whose range of finite values
is a subset of the range of finite values of <code class="highlight"><c- n>T</c-></code>.</p>
        <li data-md>
         <p>(2.2) The rank of <code class="highlight"><c- b>long</c-> <c- b>double</c-></code> shall be greater than the rank of <code class="highlight"><c- b>double</c-></code>, which shall be greater than the rank of <code class="highlight"><c- b>float</c-></code>.</p>
        <li data-md>
         <p>(2.3) The rank of any standard floating-point type shall be greater than the rank of any extended floating-point type with
the same range of finite values.</p>
        <li data-md>
         <p>(2.4) The rank of any extended floating-point type relative to another extended floating-point type with the same range of
values is implementation-defined, but still subject to the other rules for determining the floating-point conversion
rank.</p>
        <li data-md>
         <p>(2.5) For extended floating-point types <code class="highlight"><c- n>T1</c-></code> and <code class="highlight"><c- n>T2</c-></code>, if the range of finite values of <code class="highlight"><c- n>T1</c-></code> is neither a subset nor a superset of
the range of finite values of <code class="highlight"><c- n>T2</c-></code>, the rank of <code class="highlight"><c- n>T1</c-></code> relative to <code class="highlight"><c- n>T2</c-></code> is implementation-defined.</p>
        <li data-md>
         <p>(2.6) For all floating-point types <code class="highlight"><c- n>T1</c-></code>, <code class="highlight"><c- n>T2</c-></code> and <code class="highlight"><c- n>T3</c-></code>, if <code class="highlight"><c- n>T1</c-></code> has greater rank than <code class="highlight"><c- n>T2</c-></code> and <code class="highlight"><c- n>T2</c-></code> has greater rank than <code class="highlight"><c- n>T3</c-></code>, then <code class="highlight"><c- n>T1</c-></code> shall have greater rank than <code class="highlight"><c- n>T3</c-></code>.</p>
       </ul>
       <p>[ <em>Note</em>: The floating-point conversion rank is used in the definition of the usual arithmetic conversions ([expr.arith.conv]).
-- <em>end note</em> ]</p>
     </ol>
    </blockquote>
   </ins>
   <p>Modify Floating-point promotion [<strong>conv.fpprom</strong>] paragraph 1:</p>
   <blockquote>
    <ol>
     <li data-md>
      <p>
       A prvalue of 
       <ins>a floating-point </ins>
       type 
       <del><code class="highlight"><c- b>float</c-></code></del>
       <ins>whose floating-point conversion rank ([conv.rank]) is
less than the rank of <code class="highlight"><c- b>double</c-></code></ins>
        can be converted to a prvalue of type <code class="highlight"><c- b>double</c-></code>. The value is unchanged.
      </p>
    </ol>
   </blockquote>
   <p>Modify Usual arithmetic conversions [<strong>expr.arith.conv</strong>] paragraph 1:</p>
   <blockquote>
    <ul>
     <li data-md>
      <p>(1.1) If either operand is of scoped enumeration type, no conversions are performed; if the other operand does not have the
same type, the expression is ill-formed.</p>
     <li data-md>
      <del>(1.2) If either operand is of type long double, the other shall be converted to long double.</del>
     <li data-md>
      <del>(1.3) Otherwise, if either operand is double, the other shall be converted to double.</del>
     <li data-md>
      <del>(1.4) Otherwise, if either operand is float, the other shall be converted to float.</del>
     <li data-md>
      <ins>(1.2) Otherwise, if either operand has a floating-point type, the following rules shall be applied:</ins>
      <ul>
       <li data-md>
        <ins>(1.2.1) If both operands have the same type, no further conversion is needed.</ins>
       <li data-md>
        <ins>(1.2.2) Otherwise, if one of the operands has a type that is not a floating-point type, that operand shall be converted
to the type of the operand with floating-point type.</ins>
       <li data-md>
        <ins>(1.2.3) Otherwise, the operand with the type of lesser floating-point conversion rank shall be converted to the type
of the operand with greater rank. </ins>
      </ul>
     <li data-md>
      <p>(1.5) Otherwise, the integral promotions [...]</p>
    </ul>
   </blockquote>
   <p>Modify the definition of narrowing conversions in List-initialization [<strong>dcl.init.list</strong>] paragraph 7 item 2:</p>
   <blockquote>
    <ul>
     <li data-md>
      <p>
       (7.2) 
       <del>from <code class="highlight"><c- b>long</c-> <c- b>double</c-></code> to <code class="highlight"><c- b>double</c-></code> or <code class="highlight"><c- b>float</c-></code>, or from <code class="highlight"><c- b>double</c-></code> to <code class="highlight"><c- b>float</c-></code></del>
       <ins>from a floating-point type <code class="highlight"><c- n>T</c-></code> to another floating-point type whose range of finite values is not a superset of the range of finite values of <code class="highlight"><c- n>T</c-></code></ins>
       , except where
the source is a constant expression and the actual value after conversion is within the range of finite values that can be represented
(even if it cannot be represented exactly), or
      </p>
    </ul>
   </blockquote>
   <h3 class="heading settled" data-level="4.2" id="library"><span class="secno">4.2. </span><span class="content">Library</span><a class="self-link" href="#library"></a></h3>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>charconv</c-><c- o>></c-></code> synopsis [<strong>charconv.syn</strong>]:</p>
   <blockquote>
    <p>[...]<br></p>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-> <c- n>value</c-><c- p>,</c-> <c- b>int</c-> <c- n>base</c-> <c- o>=</c-> <c- mi>10</c-><c- p>);</c->
</pre>
    <del>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>float</c-> <c- n>value</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>double</c-> <c- n>value</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>);</c->

  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->

  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>float</c-> <c- n>value</c-><c- p>,</c->
                           <c- n>chars_format</c-> <c- n>fmt</c-><c- p>,</c-> <c- b>int</c-> <c- n>precision</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c->
                           <c- n>chars_format</c-> <c- n>fmt</c-><c- p>,</c-> <c- b>int</c-> <c- n>precision</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c->
                          <c- n>chars_format</c-> <c- n>fmt</c-><c- p>,</c-> <c- b>int</c-> <c- n>precision</c-><c- p>);</c->
</pre>
    </del>
    <ins>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-> <c- n>value</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-> <c- n>value</c-><c- p>,</c->
                           <c- n>chars_format</c-> <c- n>fmt</c-><c- p>,</c-> <c- b>int</c-> <c- n>precision</c-><c- p>);</c->
</pre>
    </ins>
    <p>[...]<br></p>
<pre class="highlight">  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c->
                               <c- n>see</c-> <c- n>below</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c-> <c- b>int</c-> <c- n>base</c-> <c- o>=</c-> <c- mi>10</c-><c- p>);</c->
</pre>
    <del>
<pre class="highlight">  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c->
                               <c- n>chars_format</c-> <c- n>fmt</c-> <c- o>=</c-> <c- n>chars_format</c-><c- o>::</c-><c- n>general</c-><c- p>);</c->
  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>double</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c->
                               <c- n>chars_format</c-> <c- n>fmt</c-> <c- o>=</c-> <c- n>chars_format</c-><c- o>::</c-><c- n>general</c-><c- p>);</c->
  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c->
                               <c- n>chars_format</c-> <c- n>fmt</c-> <c- o>=</c-> <c- n>chars_format</c-><c- o>::</c-><c- n>general</c-><c- p>);</c->
</pre>
    </del>
    <ins>
<pre class="highlight">  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*&amp;</c-> <c- n>value</c-><c- p>,</c->
                               <c- n>chars_format</c-> <c- n>fmt</c-> <c- o>=</c-> <c- n>chars_format</c-><c- o>::</c-><c- n>general</c-><c- p>);</c->
</pre>
    </ins>
    <p>[...]<br></p>
   </blockquote>
   <p>Modify Primitive numeric output conversion [<strong>charconv.to.chars</strong>]:</p>
   <blockquote>
    <p>[...]</p>
    <del>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>float</c-> <c- n>value</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>double</c-> <c- n>value</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>);</c->
</pre>
    </del>
    <ins>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-> <c- n>value</c-><c- p>);</c->
</pre>
    </ins>
    <ol start="8">
     <li data-md>
      <p><em>Effects</em>: <code class="highlight"><c- n>value</c-></code> is converted to a string in the style of <code class="highlight"><c- n>printf</c-></code> in the <code class="highlight"><c- s>"C"</c-></code> locale. The conversion specifier is <code class="highlight"><c- n>f</c-></code> or <code class="highlight"><c- n>e</c-></code>, chosen according to the requirement for a shortest representation (see above); a tie is resolved in favor of <code class="highlight"><c- n>f</c-></code>.</p>
     <li data-md>
      <p><em>Throws</em>: Nothing.</p>
     <li data-md>
      <ins><em>Remarks</em>: The implementation shall provide overloads for all floating-point types as the type of parameter <code class="highlight"><c- n>value</c-></code>.</ins>
    </ol>
    <del>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
</pre>
    </del>
    <ins>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
</pre>
    </ins>
    <ol start="10">
     <li data-md>
      <p><em>Requires</em>: <code class="highlight"><c- n>fmt</c-></code> has the value of one of the enumerators of <code class="highlight"><c- n>chars_format</c-></code>.</p>
     <li data-md>
      <p><em>Effects</em>: <code class="highlight"><c- n>value</c-></code> is converted to a string in the style of <code class="highlight"><c- n>printf</c-></code> in the <code class="highlight"><c- s>"C"</c-></code> locale.</p>
     <li data-md>
      <p><em>Throws</em>: Nothing.</p>
     <li data-md>
      <ins><em>Remarks</em>: The implementation shall provide overloads for all floating-point types as the type of parameter <code class="highlight"><c- n>value</c-></code>.</ins>
    </ol>
    <del>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>float</c-> <c- n>value</c-><c- p>,</c->
                           <c- n>chars_format</c-> <c- n>fmt</c-><c- p>,</c-> <c- b>int</c-> <c- n>precision</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c->
                           <c- n>chars_format</c-> <c- n>fmt</c-><c- p>,</c-> <c- b>int</c-> <c- n>precision</c-><c- p>);</c->
  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c->
                           <c- n>chars_format</c-> <c- n>fmt</c-><c- p>,</c-> <c- b>int</c-> <c- n>precision</c-><c- p>);</c->
</pre>
    </del>
    <ins>
<pre class="highlight">  <c- n>to_chars_result</c-> <c- nf>to_chars</c-><c- p>(</c-><c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-> <c- n>value</c-><c- p>,</c->
                           <c- n>chars_format</c-> <c- n>fmt</c-><c- p>,</c-> <c- b>int</c-> <c- n>precision</c-><c- p>);</c->
</pre>
    </ins>
    <ol start="13">
     <li data-md>
      <p><em>Requires</em>: <code class="highlight"><c- n>fmt</c-></code> has the value of one of the enumerators of <code class="highlight"><c- n>chars_format</c-></code>.</p>
     <li data-md>
      <p><em>Effects</em>: value is converted to a string in the style of <code class="highlight"><c- n>printf</c-></code> in the <code class="highlight"><c- s>"C"</c-></code> locale with the given precision.</p>
     <li data-md>
      <p><em>Throws</em>: Nothing.</p>
     <li data-md>
      <ins><em>Remarks</em>: The implementation shall provide overloads for all floating-point types as the type of parameter <code class="highlight"><c- n>value</c-></code>.</ins>
    </ol>
   </blockquote>
   <p>Modify Primitive numeric input conversions [<strong>charconv.from.chars</strong>]:</p>
   <blockquote>
    <p>[...]<br></p>
    <del>
<pre class="highlight">  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c->
                               <c- n>chars_format</c-> <c- n>fmt</c-> <c- o>=</c-> <c- n>chars_format</c-><c- o>::</c-><c- n>general</c-><c- p>);</c->
  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>double</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c->
                               <c- n>chars_format</c-> <c- n>fmt</c-> <c- o>=</c-> <c- n>chars_format</c-><c- o>::</c-><c- n>general</c-><c- p>);</c->
  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-><c- o>&amp;</c-> <c- n>value</c-><c- p>,</c->
                               <c- n>chars_format</c-> <c- n>fmt</c-> <c- o>=</c-> <c- n>chars_format</c-><c- o>::</c-><c- n>general</c-><c- p>);</c->
</pre>
    </del>
    <ins>
<pre class="highlight">  <c- n>from_chars_result</c-> <c- nf>from_chars</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>first</c-><c- p>,</c-> <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>last</c-><c- p>,</c-> <c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*&amp;</c-> <c- n>value</c-><c- p>,</c->
                               <c- n>chars_format</c-> <c- n>fmt</c-> <c- o>=</c-> <c- n>chars_format</c-><c- o>::</c-><c- n>general</c-><c- p>);</c->
</pre>
    </ins>
    <ol start="6">
     <li data-md>
      <p><em>Requires</em>: <code class="highlight"><c- n>fmt</c-></code> has the value of one of the enumerators of <code class="highlight"><c- n>chars_format</c-></code>.</p>
     <li data-md>
      <p><em>Effects</em>: The pattern is the expected form of the subject sequence in the <code class="highlight"><c- s>"C"</c-></code> locale, as described for <code class="highlight"><c- n>strtod</c-></code>, except that</p>
      <ul>
       <li data-md>
        <p>(7.1) the sign <code class="highlight"><c- sc>'+'</c-></code> may only appear in the exponent part;</p>
       <li data-md>
        <p>(7.2) if <code class="highlight"><c- n>fmt</c-></code> has <code class="highlight"><c- n>chars_format</c-><c- o>::</c-><c- n>scientific</c-></code> set but not <code class="highlight"><c- n>chars_format</c-><c- o>::</c-><c- n>fixed</c-></code>, the otherwise optional exponent part shall
appear;</p>
       <li data-md>
        <p>(7.3) if <code class="highlight"><c- n>fmt</c-></code> has <code class="highlight"><c- n>chars_format</c-><c- o>::</c-><c- n>fixed</c-></code> set but not <code class="highlight"><c- n>chars_format</c-><c- o>::</c-><c- n>scientific</c-></code>, the optional exponent part shall not appear;
and</p>
       <li data-md>
        <p>(7.4) if <code class="highlight"><c- n>fmt</c-></code> is <code class="highlight"><c- n>chars_format</c-><c- o>::</c-><c- n>hex</c-></code>, the prefix <code class="highlight"><c- s>"0x"</c-></code> or <code class="highlight"><c- s>"0X"</c-></code> is assumed. [ <em>Example</em>: The string <code class="highlight"><c- mh>0x123</c-></code> is parsed to
have the value <code class="highlight"><c- mi>0</c-></code> with remaining characters <code class="highlight"><c- n>x123</c-></code>. — <em>end example</em> ]</p>
      </ul>
      <p>In any case, the resulting value is one of at most two floating-point values closest to the value of the string matching the
    pattern.</p>
     <li data-md>
      <p><em>Throws</em>: Nothing.</p>
     <li data-md>
      <ins><em>Remarks</em>: The implementation shall provide overloads for all floating-point types as the type of parameter <code class="highlight"><c- n>value</c-></code>.</ins>
    </ol>
   </blockquote>
   <p class="note" role="note"><span>Note:</span> other conversion to string functions (from [<strong>strings</strong>]) are not rewritten to support extended floating-point types.</p>
   <p>Modify Complex numbers [<strong>complex.numbers</strong>] paragraph 2:</p>
   <blockquote>
    <ol start="2">
     <li data-md>
      <p>
       The effect of instantiating the template <code class="highlight"><c- n>complex</c-></code> for any type 
       <del>other than <code class="highlight"><c- b>float</c-></code>, <code class="highlight"><c- b>double</c-></code>, or <code class="highlight"><c- b>long</c-> <c- b>double</c-></code></del>
       <ins> that is not a floating-point type</ins>
        is unspecified. The specializations 
       <del>specializations <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-></code>, <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-></code>, and <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-></code></del>
       <ins>of <code class="highlight"><c- n>complex</c-></code> for floating-point types</ins>
        are literal types.
      </p>
    </ol>
   </blockquote>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>complex</c-><c- o>></c-></code> synopsis [<strong>complex.syn</strong>]:</p>
   <blockquote>
    <p>[...]<br></p>
    <del>
<pre class="highlight">  <c- c1>// [complex.special], specializations</c->
  <c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>;</c->
  <c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-><c- p>;</c->
  <c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-><c- p>;</c->
</pre>
    </del>
   </blockquote>
   <p>Modify Class template <code class="highlight"><c- n>complex</c-></code> [<strong>complex</strong>]:</p>
   <blockquote>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
  <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>T</c-><c- o>></c-> <c- k>class</c-> <c- nc>complex</c-> <c- p>{</c->
  <c- k>public</c-><c- o>:</c->
    <c- k>using</c-> <c- n>value_type</c-> <c- o>=</c-> <c- n>T</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>re</c-> <c- o>=</c-> <c- n>T</c-><c- p>(),</c-> <c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-> <c- n>im</c-> <c- o>=</c-> <c- n>T</c-><c- p>());</c->
</pre>
    <del>
<pre class="highlight">    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
</pre>
    </del>
    <ins>
<pre class="highlight">    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- k>explicit</c-><c- p>(</c-><c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-><c- p>)</c-> <c- n>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">    <c- k>constexpr</c-> <c- n>T</c-> <c- nf>real</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>void</c-> <c- nf>real</c-><c- p>(</c-><c- n>T</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>T</c-> <c- nf>imag</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>void</c-> <c- nf>imag</c-><c- p>(</c-><c- n>T</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-> <c- p>(</c-><c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*=</c-><c- p>(</c-><c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>/=</c-><c- p>(</c-><c- k>const</c-> <c- n>T</c-><c- o>&amp;</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-> <c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>/=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
  <c- p>};</c->
<c- p>}</c->
</pre>
   </blockquote>
   <p>Remove Specializations [<strong>complex.special</strong>]:</p>
   <blockquote>
    <del>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
  <c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-> <c- p>{</c->
  <c- k>public</c-><c- o>:</c->
    <c- k>using</c-> <c- n>value_type</c-> <c- o>=</c-> <c- b>float</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- b>float</c-> <c- n>re</c-> <c- o>=</c-> <c- mf>0.0f</c-><c- p>,</c-> <c- b>float</c-> <c- n>im</c-> <c- o>=</c-> <c- mf>0.0f</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- k>explicit</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- k>explicit</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>>&amp;</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- b>float</c-> <c- nf>real</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>void</c-> <c- nf>real</c-><c- p>(</c-><c- b>float</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- b>float</c-> <c- nf>imag</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>void</c-> <c- nf>imag</c-><c- p>(</c-><c- b>float</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-> <c- p>(</c-><c- b>float</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- b>float</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- b>float</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*=</c-><c- p>(</c-><c- b>float</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>/=</c-><c- p>(</c-><c- b>float</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-> <c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>/=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
  <c- p>};</c->

  <c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-> <c- p>{</c->
  <c- k>public</c-><c- o>:</c->
    <c- k>using</c-> <c- n>value_type</c-> <c- o>=</c-> <c- b>double</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- b>double</c-> <c- n>re</c-> <c- o>=</c-> <c- mf>0.0</c-><c- p>,</c-> <c- b>double</c-> <c- n>im</c-> <c- o>=</c-> <c- mf>0.0</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- k>explicit</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>>&amp;</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- b>double</c-> <c- nf>real</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>void</c-> <c- nf>real</c-><c- p>(</c-><c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- b>double</c-> <c- nf>imag</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>void</c-> <c- nf>imag</c-><c- p>(</c-><c- b>double</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-> <c- p>(</c-><c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*=</c-><c- p>(</c-><c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>/=</c-><c- p>(</c-><c- b>double</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-> <c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>/=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
  <c- p>};</c->

  <c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-> <c- p>{</c->
  <c- k>public</c-><c- o>:</c->
    <c- k>using</c-> <c- n>value_type</c-> <c- o>=</c-> <c- b>long</c-> <c- b>double</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>re</c-> <c- o>=</c-> <c- mf>0.0</c-><c- n>L</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>im</c-> <c- o>=</c-> <c- mf>0.0</c-><c- n>L</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>>&amp;</c-><c- p>)</c-> <c- o>=</c-> <c- k>default</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- b>long</c-> <c- b>double</c-> <c- nf>real</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>void</c-> <c- nf>real</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- b>long</c-> <c- b>double</c-> <c- nf>imag</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
    <c- k>constexpr</c-> <c- b>void</c-> <c- nf>imag</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-> <c- p>(</c-><c- b>long</c-> <c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*=</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>/=</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-><c- p>);</c->

    <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>=</c-> <c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>+=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>-=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>*=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
    <c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- n>complex</c-><c- o>&amp;</c-> <c- k>operator</c-><c- o>/=</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-><c- p>);</c->
  <c- p>};</c->
<c- p>}</c->
</pre>
    </del>
   </blockquote>
   <p>Modify Member functions [<strong>complex.members</strong>] by inserting the following after paragraph 2:</p>
   <ins>
    <blockquote>
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>X</c-><c- o>></c-> <c- k>constexpr</c-> <c- k>explicit</c-><c- p>(</c-><c- o>*</c-><c- n>see</c-> <c- n>below</c-><c- o>*</c-><c- p>)</c-> <c- n>complex</c-><c- p>(</c-><c- k>const</c-> <c- n>complex</c-><c- o>&lt;</c-><c- n>X</c-><c- o>>&amp;</c-> <c- n>other</c-><c- p>);</c->
</pre>
     <ol start="3">
      <li data-md>
       <p><em>Effects</em>: Constructs an object of class <code class="highlight"><c- n>complex</c-></code>.</p>
      <li data-md>
       <p><em>Ensures</em>: <code class="highlight"><c- n>real</c-><c- p>()</c-> <c- o>==</c-> <c- n>other</c-><c- p>.</c-><c- n>real</c-><c- p>()</c-> <c- o>&amp;&amp;</c-> <c- n>imag</c-><c- p>()</c-> <c- o>==</c-> <c- n>other</c-><c- p>.</c-><c- n>imag</c-><c- p>()</c-></code>.</p>
      <li data-md>
       <p><em>Remarks</em>: The expression inside <code class="highlight"><c- k>explicit</c-></code> evaluates to <code class="highlight">false</code> if and only if the range of finite values of <code class="highlight"><c- n>T</c-></code> is a superset of
the range of finite values of <code class="highlight"><c- n>X</c-></code>.</p>
     </ol>
    </blockquote>
   </ins>
   <p>Modify Additional overloads [<strong>cmplx.over</strong>] paragraph 2 and 3:</p>
   <blockquote>
    <ol start="2">
     <li data-md>
      <p>The additional overloads shall be sufficient to ensure:</p>
      <ul>
       <li data-md>
        <del>(2.1) If the argument has type <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>, then it is effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-></code>.</del>
       <li data-md>
        <del>(2.2) Otherwise, if the argument has type <code class="highlight"><c- b>double</c-></code> or an integer type, then it is effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-></code>.</del>
       <li data-md>
        <del>(2.3) Otherwise, if the argument has type <code class="highlight"><c- b>float</c-></code>, then it is effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-></code>.</del>
       <li data-md>
        <ins>(2.1) If the argument has a floating-point type <code class="highlight"><c- n>T</c-></code>, then it is effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>.</ins>
       <li data-md>
        <ins>(2.2) Otherwise, if the argument has an integer type, then it is effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-></code>.</ins>
      </ul>
     <li data-md>
      <p>Function template <code class="highlight"><c- n>pow</c-></code> shall have additional overloads sufficient to ensure, for a call with at least one argument of type <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>.:</p>
      <ul>
       <li data-md>
        <del>(3.1) If either argument has type <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-></code> or type <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>, then both arguments are effectively
cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-></code>.</del>
       <li data-md>
        <del>(3.2) Otherwise, if either argument has type <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-></code>, <code class="highlight"><c- b>double</c-></code>, or an integer type, then both arguments
are effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-></code>.</del>
       <li data-md>
        <del>(3.3) Otherwise, if either argument has type <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-></code> or <code class="highlight"><c- b>float</c-></code>, then both arguments are effectively cast
to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-></code>.</del>
       <li data-md>
        <ins>(3.1) If the type of one of the arguments is <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- n>T1</c-><c- o>></c-></code> and the type of the other is <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- n>T2</c-><c- o>></c-></code>, then both
arguments are effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- n>TR</c-><c- o>></c-></code>, where <code class="highlight"><c- n>TR</c-></code> is <code class="highlight"><c- n>T1</c-></code> if <code class="highlight"><c- n>T1</c-></code> has a higher floating-point conversion
rank than <code class="highlight"><c- n>T2</c-></code>, otherwise <code class="highlight"><c- n>T2</c-></code>.</ins>
       <li data-md>
        <ins>(3.2) Otherwise, if the type of one of the arguments is <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- n>T1</c-><c- o>></c-></code> and the type of the other is a floating-point
type <code class="highlight"><c- n>T2</c-></code>, then both arguments are effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- n>TR</c-><c- o>></c-></code>, where <code class="highlight"><c- n>TR</c-></code> is <code class="highlight"><c- n>T1</c-></code> if <code class="highlight"><c- n>T1</c-></code> has a higher
floating-point conversion rank than <code class="highlight"><c- n>T2</c-></code>, otherwise <code class="highlight"><c- n>T2</c-></code>.</ins>
       <li data-md>
        <ins>(3.3) Otherwise, both arguments are effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>.</ins>
      </ul>
    </ol>
   </blockquote>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>cmath</c-><c- o>></c-></code> synopsis [<strong>cmath.syn</strong>] paragraph 2 and add paragraph 3:</p>
   <blockquote>
    <ol start="2">
     <li data-md>
      <p>For each set of overloaded functions within <code class="highlight"><c- o>&lt;</c-><c- n>cmath</c-><c- o>></c-></code>, with the exception of <code class="highlight"><c- n>abs</c-></code>, there shall be additional overloads
sufficient to ensure:</p>
      <ol>
       <li data-md>
        <del>If any argument of arithmetic type corresponding to a double parameter has type long double, then all arguments of
arithmetic type corresponding to double parameters are effectively cast to long double.</del>
       <li data-md>
        <del>Otherwise, if any argument of arithmetic type corresponding to a double parameter has type double or an integer type,
then all arguments of arithmetic type corresponding to double parameters are effectively cast to double.</del>
       <li data-md>
        <ins>If all arguments of arithmetic types corresponding to <code class="highlight"><c- b>double</c-></code> parameters have floating-point types, then all arguments
of arithmetic type corresponding to <code class="highlight"><c- b>double</c-></code> parameters have type that is the type among the argument types with the highest
floating-point conversion rank. If that type is an extended floating-point type, then the return type is also that
type.</ins>
       <li data-md>
        <ins>Otherwise, if any argument of arithmetic type corresponding to a <code class="highlight"><c- b>double</c-></code> parameter has a floating-point type, then all
arguments of arithmetic type corresponding to <code class="highlight"><c- b>double</c-></code> parameters are effectively cast to that of parameters of
floating-point type that is the type with the highest floating-point conversion rank among those of argument types that
are floating-point.</ins>
       <li data-md>
        <p>Otherwise, all arguments of arithmetic type corresponding to <code class="highlight"><c- b>double</c-></code> parameters have type <code class="highlight"><c- b>float</c-></code>.</p>
      </ol>
     <li data-md>
      <ins>There shall be additional overloads of <code class="highlight"><c- n>abs</c-></code> for each extended floating-point type <code class="highlight"><c- n>T</c-></code>. Those overloads shall have the
signature <code class="highlight"><c- n>T</c-> <c- n>abs</c-><c- p>(</c-><c- n>T</c-> <c- n>j</c-><c- p>)</c-></code> and return the absolute value of <code class="highlight"><c- n>j</c-></code>.</ins>
    </ol>
   </blockquote>
   <p class="note" role="note"><span>Note:</span> LWG question: should the signatures be somehow added to the synopsis itself?</p>
   <p class="note" role="note"><span>Note:</span> We have tried to capture what the current specification says, without having to add three identical items into this wording
to cover, respectively, EFPTs bigger than <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>, EFPTs between <code class="highlight"><c- b>double</c-></code> and <code class="highlight"><c- b>float</c-></code>, and EFPTs smaller than <code class="highlight"><c- b>float</c-></code>. We
don’t have anything against reverting to that, but wanted to try this more generic way of describing the behavior.</p>
   <p class="note" role="note"><span>Note:</span> We are pretty sure this new paragraph 3 is not the way to spell it, so we will welcome any suggestions.</p>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

  var sidebarMedia = window.matchMedia('screen and (min-width: 78em)');
  var autoToggle   = function(e){ toggleSidebar(e.matches) };
  if(sidebarMedia.addListener) {
    sidebarMedia.addListener(autoToggle);
  }

  function toggleSidebar(on) {
    if (on == undefined) {
      on = !document.body.classList.contains('toc-sidebar');
    }

    /* Don’t scroll to compensate for the ToC if we’re above it already. */
    var headY = 0;
    var head = document.querySelector('.head');
    if (head) {
      // terrible approx of "top of ToC"
      headY += head.offsetTop + head.offsetHeight;
    }
    var skipScroll = window.scrollY < headY;

    var toggle = document.getElementById('toc-toggle');
    var tocNav = document.getElementById('toc');
    if (on) {
      var tocHeight = tocNav.offsetHeight;
      document.body.classList.add('toc-sidebar');
      document.body.classList.remove('toc-inline');
      toggle.innerHTML = collapseSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, 0 - tocHeight);
      }
      tocNav.focus();
      sidebarMedia.addListener(autoToggle); // auto-collapse when out of room
    }
    else {
      document.body.classList.add('toc-inline');
      document.body.classList.remove('toc-sidebar');
      toggle.innerHTML = expandSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, tocNav.offsetHeight);
      }
      if (toggle.matches(':hover')) {
        /* Unfocus button when not using keyboard navigation,
           because I don’t know where else to send the focus. */
        toggle.blur();
      }
    }
  }

  function createSidebarToggle() {
    /* Create the sidebar toggle in JS; it shouldn’t exist when JS is off. */
    var toggle = document.createElement('a');
      /* This should probably be a button, but appearance isn’t standards-track.*/
    toggle.id = 'toc-toggle';
    toggle.class = 'toc-toggle';
    toggle.href = '#toc';
    toggle.innerHTML = collapseSidebarText;

    sidebarMedia.addListener(autoToggle);
    var toggler = function(e) {
      e.preventDefault();
      sidebarMedia.removeListener(autoToggle); // persist explicit off states
      toggleSidebar();
      return false;
    }
    toggle.addEventListener('click', toggler, false);


    /* Get <nav id=toc-nav>, or make it if we don’t have one. */
    var tocNav = document.getElementById('toc-nav');
    if (!tocNav) {
      tocNav = document.createElement('p');
      tocNav.id = 'toc-nav';
      /* Prepend for better keyboard navigation */
      document.body.insertBefore(tocNav, document.body.firstChild);
    }
    /* While we’re at it, make sure we have a Jump to Toc link. */
    var tocJump = document.getElementById('toc-jump');
    if (!tocJump) {
      tocJump = document.createElement('a');
      tocJump.id = 'toc-jump';
      tocJump.href = '#toc';
      tocJump.innerHTML = tocJumpText;
      tocNav.appendChild(tocJump);
    }

    tocNav.appendChild(toggle);
  }

  var toc = document.getElementById('toc');
  if (toc) {
    createSidebarToggle();
    toggleSidebar(sidebarMedia.matches);

    /* If the sidebar has been manually opened and is currently overlaying the text
       (window too small for the MQ to add the margin to body),
       then auto-close the sidebar once you click on something in there. */
    toc.addEventListener('click', function(e) {
      if(e.target.tagName.toLowerCase() == "a" && document.body.classList.contains('toc-sidebar') && !sidebarMedia.matches) {
        toggleSidebar(false);
      }
    }, false);
  }
  else {
    console.warn("Can’t find Table of Contents. Please use <nav id='toc'> around the ToC.");
  }

  /* Wrap tables in case they overflow */
  var tables = document.querySelectorAll(':not(.overlarge) > table.data, :not(.overlarge) > table.index');
  var numTables = tables.length;
  for (var i = 0; i < numTables; i++) {
    var table = tables[i];
    var wrapper = document.createElement('div');
    wrapper.className = 'overlarge';
    table.parentNode.insertBefore(wrapper, table);
    wrapper.appendChild(table);
  }

})();
</script>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-p0192">[P0192]
   <dd>Michał Dominiak; et al. <a href="https://wg21.link/P0192">`short float` and fixed-size floating point types</a>. URL: <a href="https://wg21.link/P0192">https://wg21.link/P0192</a>
   <dt id="biblio-p1468">[P1468]
   <dd>Michał Dominiak; Boris Fomitchev; Sergei Nikolaev. <a href="https://wg21.link/P1468">Fixed-layout floating-point type aliasess</a>. URL: <a href="https://wg21.link/P1468">https://wg21.link/P1468</a>
  </dl>
