<!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>P0192R4: `short float` and fixed-size 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 47cb5324cd11789aef12f220cf86d1780f94ab9c" name="generator">
  <link href="https://wg21.link/P0192R4" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
  <meta content="0310af613daed69d42e38f19151611e57032180a" 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">P0192R4<br>`short float` and fixed-size 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="2018-10-08">2018-10-08</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>This version:
     <dd><a class="u-url" href="https://wg21.link/P0192R4">https://wg21.link/P0192R4</a>
     <dt>Issue Tracking:
     <dd><a href="#issues-index">Inline In Spec</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:brycelelbach@gmail.com">Bryce Adelstein Lelbach</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:boris@stlport.com">Boris Fomitchev</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:me@cvmlib.com">Sergei Nikolaev</a> (<span class="p-org org">NVIDIA</span>)
     <dt>Audience:
     <dd>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>
     <ol class="toc">
      <li><a href="#motivation-apps"><span class="secno">2.1</span> <span class="content">Application use is growing</span></a>
      <li><a href="#support-software"><span class="secno">2.2</span> <span class="content">Software support is growing</span></a>
      <li><a href="#support-hardware"><span class="secno">2.3</span> <span class="content">Hardware support is growing</span></a>
     </ol>
    <li>
     <a href="#solution"><span class="secno">3</span> <span class="content">Proposed solution</span></a>
     <ol class="toc">
      <li><a href="#solution-options"><span class="secno">3.1</span> <span class="content">Implementation options</span></a>
      <li><a href="#solution-experience"><span class="secno">3.2</span> <span class="content">Implementation experience</span></a>
     </ol>
    <li>
     <a href="#wording"><span class="secno">4</span> <span class="content">Proposed wording</span></a>
     <ol class="toc">
      <li>
       <a href="#wording-fundamental"><span class="secno">4.1</span> <span class="content">Wording for a new fundamental type</span></a>
       <ol class="toc">
        <li><a href="#wording-fundamental-core"><span class="secno">4.1.1</span> <span class="content">Core language</span></a>
        <li><a href="#wording-fundamental-library"><span class="secno">4.1.2</span> <span class="content">Library wording</span></a>
       </ol>
      <li>
       <a href="#wording-library"><span class="secno">4.2</span> <span class="content">Wording for library aliases</span></a>
       <ol class="toc">
        <li><a href="#wording-library-library"><span class="secno">4.2.1</span> <span class="content">Library wording</span></a>
       </ol>
     </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>
    <li><a href="#issues-index"><span class="secno"></span> <span class="content">Issues Index</span></a>
   </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 follows <a data-link-type="biblio" href="#biblio-p0192r1">P0192R1</a> in proposing a new fundamental type, <code class="highlight"><c- b>short</c-> <c- b>float</c-></code>: a floating point type of
unspecified length, shorter or equal to that of <code class="highlight"><c- b>float</c-></code>. In addition, it also proposes standard library aliases for fixed
width floating point types, required to conform to <a data-link-type="biblio" href="#biblio-ieee-754-2008">[IEEE-754-2008]</a>, including <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>float16_t</c-></code>. Library support for <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> and <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>float16_t</c-></code> is also included.</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>One may wonder: why would a programming language need yet another floating point type after so many years of doing just
fine without it? Apparently, the times are (a-)changing. Small binary floating-point representation demand and support
are becoming more and more common rapidly. Efficient support for hardware that use the new formats becomes mission critical
for major software products.</p>
   <h3 class="heading settled" data-level="2.1" id="motivation-apps"><span class="secno">2.1. </span><span class="content">Application use is growing</span><a class="self-link" href="#motivation-apps"></a></h3>
   <p>Application areas include computer graphics, image representation and machine learning. For example, a 16-bit floating-point
number better represents the dynamic range of images than 16-bit or even 32-bit integers. A 16-bit floating-point number
adequately handles human perceptual range. In 2012, Adobe has defined new HDR <a data-link-type="biblio" href="#biblio-dng">[DNG]</a> image file format that most commonly
uses 16-bit floats. This gives those 16-bits much more dynamic range than a traditional file stored as 16 or 32-bit integer
data. Both Photoshop and Lightroom, as well as every professional camera produced in 2015 make use of it.</p>
   <h3 class="heading settled" data-level="2.2" id="support-software"><span class="secno">2.2. </span><span class="content">Software support is growing</span><a class="self-link" href="#support-software"></a></h3>
   <ul>
    <li data-md>
     <p>OpenGL has <code class="highlight"><c- n>GL_HALF_FLOAT</c-></code> format since <a data-link-type="biblio" href="#biblio-opengl30">[OpenGL3.0]</a>.</p>
    <li data-md>
     <p>The <a data-link-type="biblio" href="#biblio-openexr">[OpenEXR]</a> software distribution includes <code class="highlight"><c- n>Half</c-></code>, a C++ class for manipulating half float values almost as if they were
a built-in C++ data type.</p>
    <li data-md>
     <p>NVIDIA’s <a data-link-type="biblio" href="#biblio-cuda75">[CUDA7.5]</a> platform header <code class="highlight"><c- n>cuda_fp16</c-><c- p>.</c-><c- n>h</c-></code> defines the <code class="highlight"><c- n>half</c-></code> and <code class="highlight"><c- n>half2</c-></code> data types and defines <code class="highlight"><c- n>__half2float</c-><c- p>()</c-></code> and <code class="highlight"><c- n>__float2half</c-><c- p>()</c-></code> for conversion between that and <code class="highlight"><c- b>float</c-></code>. [4]</p>
    <li data-md>
     <p>The GCC compiler provides an <code class="highlight"><c- n>__fp16</c-></code> native data type extension for ARM. Values of that type are promoted to <code class="highlight"><c- b>float</c-></code> for computation (<a data-link-type="biblio" href="#biblio-gccfp16">[GCCFP16]</a>).</p>
    <li data-md>
     <p>The <a data-link-type="biblio" href="#biblio-llvmir">LLVM IR</a> provides a 16-bit floating-point type called <code class="highlight"><c- n>half</c-></code>.</p>
    <li data-md>
     <p>Recently, a new 16-bit float format appeared, called <a data-link-type="biblio" href="#biblio-bfloat16">[bfloat16]</a> - truncated 32-bit float, used in Google TPUs and TensorFlow <code class="highlight"><c- n>half</c-></code>.</p>
   </ul>
   <h3 class="heading settled" data-level="2.3" id="support-hardware"><span class="secno">2.3. </span><span class="content">Hardware support is growing</span><a class="self-link" href="#support-hardware"></a></h3>
   <ul>
    <li data-md>
     <p>NVIDIA was the first to implement 16-bit floating point in silicon, with the GeForce FX, released in late 2002.</p>
    <li data-md>
     <p>Intel provides instructions for converting between 16-bit and 32-bit floats and C-level intrinsics to use them (see <a data-link-type="biblio" href="#biblio-intel-half-perf">[INTEL-HALF-PERF]</a>, an Intel article on half precision performance benefits).</p>
    <li data-md>
     <p>ARM provides support as an optional extension to the VFPv3 architecture: <a data-link-type="biblio" href="#biblio-arm-hf">[ARM-HF]</a>.</p>
   </ul>
   <p>Defining standards for 16-bit float math already exist. The <a data-link-type="biblio" href="#biblio-ieee-754-2008">[IEEE-754-2008]</a> standard defined <code class="highlight"><c- n>binary16</c-></code> 16-bit float in 2008.
ISO/IEC 60559 ratified that standard in 2011. However, support for just the IEEE <code class="highlight"><c- n>binary16</c-></code> format does not cover
existing use cases.</p>
   <ul>
    <li data-md>
     <p>OpenGL provides 11-bit and 10-bit float channels in <code class="highlight"><c- n>GL_R11F_G11F_B10F</c-></code> and 14-bit float in <code class="highlight"><c- n>GL_RGB9_E5</c-></code>.</p>
    <li data-md>
     <p>ARM, along an <a data-link-type="biblio" href="#biblio-ieee-754-2008">[IEEE-754-2008]</a> compatible 16-bit floating-point format, provides a 16-bit floating-point format that
differs from IEEE ’binary16’ by dropping support for NaN and Infinity and then extending the range of values.</p>
    <li data-md>
     <p>The TI MSP430X architecture provides a 20-bit word-addressed machine. Short floating-point support on that machine would
naturally use a 20-bit format.</p>
    <li data-md>
     <p>Google TPU and TensorFlow use <a data-link-type="biblio" href="#biblio-bfloat16">[bfloat16]</a>.</p>
   </ul>
   <h2 class="heading settled" data-level="3" id="solution"><span class="secno">3. </span><span class="content">Proposed solution</span><a class="self-link" href="#solution"></a></h2>
   <p>We propose adding a new fundamental type, <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> - for a floating-point type of unspecified (platform defined) bit
size, shorter or equal to that of <code class="highlight"><c- b>float</c-></code>. Language needs <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> to represent "shorter than <code class="highlight"><c- b>float</c-></code>" math that may
be natively available on the platform. This name looks intuitive via <code class="highlight"><c- b>short</c-> <c- b>int</c-></code> analogy. Most important, it does not
introduce any new keywords.</p>
   <p>The proposed suffixes for <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> literals are <code class="highlight"><c- n>sf</c-></code> and <code class="highlight"><c- n>SF</c-></code>.</p>
   <p>This proposal also extends the definition of <em>floating-point promotions</em>, including a promotion from <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> to <code class="highlight"><c- b>float</c-></code>.</p>
   <p>We also propose adding a set of conditionally supported type aliases in namespace <code class="highlight"><c- n>std</c-></code>: <code class="highlight"><c- n>float16_t</c-></code>, <code class="highlight"><c- n>float32_t</c-></code> and <code class="highlight"><c- n>float64_t</c-></code>.
Those types would be quaranteed to be respectively 16, 32 and 64 bit long in their representation, and would be required
to implement <a data-link-type="biblio" href="#biblio-ieee-754-2008">[IEEE-754-2008]</a> <code class="highlight"><c- n>binary16</c-></code>, <code class="highlight"><c- n>binary32</c-></code> and <code class="highlight"><c- n>binary64</c-></code> formats, respectively. We propose to put those aliases
into a new header, <code class="highlight"><c- o>&lt;</c-><c- n>cstdfloat</c-><c- o>></c-></code> for consistency with <code class="highlight"><c- o>&lt;</c-><c- n>cstdint</c-><c- o>></c-></code>, and to make this new header a freestanding header.</p>
   <p>Several people have suggested not having a new fundamental type, but only exposing it as the <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>float16_t</c-></code> alias. This
approach problems. All the library changes would still need to be done, but substituting <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>float16_t</c-></code>,
plus additional wording gauranteeing that the additional overloads don’t exist if, for some reason, <code class="highlight"><c- b>float</c-></code> has 16 bits.
Additionally, the definition of a floating-point type would still need to be extended to include that - conditionally supported! -
type, and to give it the same capabilities that other floating-point types have. The authors of this paper find this to
be a change that is almost as complex as adding a new fundamental type, but with more corner cases around overload resolution
for standard library functions.</p>
   <h3 class="heading settled" data-level="3.1" id="solution-options"><span class="secno">3.1. </span><span class="content">Implementation options</span><a class="self-link" href="#solution-options"></a></h3>
   <p>As of storage and bit-layout for a short float number, we would expect most implementations to follow <a data-link-type="biblio" href="#biblio-ieee-754-2008">[IEEE-754-2008]</a> or <a data-link-type="biblio" href="#biblio-bfloat16">[bfloat16]</a> half-precision floating point number formats. On platform that do not provide any advantages of using shorter
float, short float may be implemented as storage-only type, like <code class="highlight"><c- n>__fp16</c-></code> on GCC/ARM today. For example, it can be stored in <code class="highlight"><c- n>bfloat16</c-></code> format in memory (occupying less bytes than <code class="highlight"><c- b>float</c-></code>), converted to native 32-bit <code class="highlight"><c- b>float</c-></code> on read from memory,
operated on using native 32-bit floating-point math operations and converted back to <code class="highlight"><c- n>bfloat16</c-></code> on store to memory. Or, the
platform may choose to not take any advantage of <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> and represent it using <code class="highlight"><c- b>float</c-></code> in both memory and registers.</p>
   <h3 class="heading settled" data-level="3.2" id="solution-experience"><span class="secno">3.2. </span><span class="content">Implementation experience</span><a class="self-link" href="#solution-experience"></a></h3>
   <p>Since CUDA 7.5 introduction of <code class="highlight"><c- n>half</c-></code> 16-bit floating type, applications can benefit by storing up to 2x larger models in GPU
memory. Applications that are bottlenecked by memory bandwidth may get up to 2x speedup. And applications bottlenecked by FP32
computation may benefit from 2x faster computation on <code class="highlight"><c- n>half2</c-></code> data. NVIDIA GPUs implement the <a data-link-type="biblio" href="#biblio-ieee-754-2008">[IEEE-754-2008]</a> floating point
standard, which defines half-precision numbers as follows:</p>
   <ul>
    <li data-md>
     <p>Sign: 1 bit</p>
    <li data-md>
     <p>Exponent width: 5 bits</p>
    <li data-md>
     <p>Significand precision: 11 bits (10 explicitly stored)</p>
   </ul>
   <p>Google TPUs implement <code class="highlight"><c- n>bfloat16</c-></code> format, which defines half-precision numbers as higher 16 bits of 32-bit IEEE float:</p>
   <ul>
    <li data-md>
     <p>Sign: 1 bit</p>
    <li data-md>
     <p>Exponent width: 8 bits</p>
    <li data-md>
     <p>Significand precision: 8 bits (7 explicitly stored)</p>
   </ul>
   <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>
   <h3 class="heading settled" data-level="4.1" id="wording-fundamental"><span class="secno">4.1. </span><span class="content">Wording for a new fundamental type</span><a class="self-link" href="#wording-fundamental"></a></h3>
   <h4 class="heading settled" data-level="4.1.1" id="wording-fundamental-core"><span class="secno">4.1.1. </span><span class="content">Core language</span><a class="self-link" href="#wording-fundamental-core"></a></h4>
   <p>Modify Floating literals [<strong>lex.fcon</strong>] by adding short float suffixes to <i>floating-suffix</i>:</p>
   <blockquote>
    <p><i>floating-suffix:</i> one of</p>
    <ins>sf</ins>
     f l 
    <ins>SF</ins>
     F L 
   </blockquote>
   <p>In paragraph 1, modify sentence 13:</p>
   <blockquote>
    <p>
     The type of a floating literal is <code class="highlight"><c- b>double</c-></code> unless explicitly specified by a suffix. The 
     <ins>suffixes <code class="highlight"><c- n>sf</c-></code> and <code class="highlight"><c- n>SF</c-></code> specify <code class="highlight"><c- b>short</c-> <c- b>float</c-></code>, the</ins>
      suffixes <code class="highlight"><c- n>f</c-></code> and <code class="highlight"><c- n>F</c-></code> specify <code class="highlight"><c- b>float</c-></code>, the suffixes <code class="highlight"><c- n>l</c-></code> and <code class="highlight"><c- n>L</c-></code> specify <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>. [...]
    </p>
   </blockquote>
   <p>Modify Fundamental types [<strong>basic.fundamental</strong>] paragraph 8:</p>
   <blockquote>
    <p>
     There are 
     <del>three</del>
     <ins>four</ins>
      <em>floating-point types</em>: 
     <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-></code>,</ins>
      <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 
     <ins>type <code class="highlight"><c- b>float</c-></code> provides at least as much precision as <code class="highlight"><c- b>short</c-> <c- b>float</c-></code>, the</ins>
      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 
     <ins>set of values of the type <code class="highlight"><c- b>short</c-> <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</ins>
      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 floating-point
    types is implementation-defined. [...]
    </p>
   </blockquote>
   <p>Modify Floating-point promotion [<strong>conv.fpprom</strong>] as follows:</p>
   <blockquote>
    <ins>A prvalue of type <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> can be converted to a prvalue of type <code class="highlight"><c- b>float</c-></code>. The value is unchanged.</ins>
    <p>A prvalue of type <code class="highlight"><c- b>float</c-></code> can be converted to a prvalue of type <code class="highlight"><c- b>double</c-></code>. The value is unchanged.</p>
    <del>This conversion is</del>
    <ins>These conversions are</ins>
     called <i>floating-point <del>promotion</del><ins>promotions</ins></i>. 
   </blockquote>
   <p>Modify Usual arithmetic conversions [<strong>expr.arith.conv</strong>] paragraph 1 as follows:</p>
   <blockquote>
    <p>[...]</p>
    <ul>
     <li data-md>
      <p>If either operand is of type <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>, the other shall be converted to <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>.</p>
     <li data-md>
      <p>Otherwise, if either operand is <code class="highlight"><c- b>float</c-></code>, the other shall be converted to <code class="highlight"><c- b>float</c-></code>.</p>
     <li data-md>
      <ins>Otherwise, if either operand is <code class="highlight"><c- b>short</c-> <c- b>float</c-></code>, the other shall be converted to <code class="highlight"><c- b>short</c-> <c- b>float</c-></code>.</ins>
     <li data-md>
      <p>Otherwise, the integral promotions shall be performed on both operands. [...]</p>
    </ul>
   </blockquote>
   <p>In Simple type specifiers [<strong>dcl.type.simple</strong>], modify table 11 as follows:</p>
   <blockquote>
    <table>
     <tbody>
      <tr>
       <td><strong>Specifier(s)</strong>
       <td><strong>Type</strong>
      <tr>
       <td>[...]
       <td>[...]
      <tr>
       <td><code class="highlight"><c- b>wchar_t</c-></code>
       <td>"<code class="highlight"><c- b>wchar_t</c-></code>"
      <tr>
       <td>
        <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-></code></ins>
       <td>
        <ins>"<code class="highlight"><c- b>short</c-> <c- b>float</c-></code>"</ins>
      <tr>
       <td><code class="highlight"><c- b>float</c-></code>
       <td>"<code class="highlight"><c- b>float</c-></code>"
      <tr>
       <td>[...]
       <td>[...]
    </table>
   </blockquote>
   <p>Modify List-initialization [<strong>dcl.init.list</strong>] paragraph 7 item 2:</p>
   <blockquote>
    <ul>
     <li data-md>
      <p>
       from 
       <del><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>higher precision floating-point
type to a lower precision one,</ins>
        except where the source is a constant expression and the actual value after
conversion is within the range of values that can be represented (even if it cannot be represented exactly), or
      </p>
    </ul>
   </blockquote>
   <p>In Standard conversion sequences [<strong>over.ics.scs</strong>], modify table 13 as follows:</p>
   <blockquote>
    <p>
     [...] Floating-point 
     <del>promotion</del>
     <ins>promotions</ins>
      [...]
    </p>
   </blockquote>
   <p>In Predefined macro names [<strong>cpp.predefined</strong>], modify table 16 as follows:</p>
   <blockquote>
    <table>
     <tbody>
      <tr>
       <td><strong>Macro name</strong>
       <td><strong>Value</strong>
      <tr>
       <td>[...]
       <td>[...]
      <tr>
       <td><code class="highlight"><c- n>__cpp_rvalue_references</c-></code>
       <td><code class="highlight"><c- mi>200610L</c-></code>
      <tr>
       <td>
        <ins><code class="highlight"><c- n>__cpp_short_float</c-></code></ins>
       <td>
        <ins><code class="highlight"><c- mi>201810L</c-></code></ins>
      <tr>
       <td><code class="highlight"><c- n>__cpp_sized_deallocation</c-></code>
       <td><code class="highlight"><c- mi>201309L</c-></code>
      <tr>
       <td>[...]
       <td>[...]
    </table>
   </blockquote>
   <h4 class="heading settled" data-level="4.1.2" id="wording-fundamental-library"><span class="secno">4.1.2. </span><span class="content">Library wording</span><a class="self-link" href="#wording-fundamental-library"></a></h4>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>cstdlib</c-><c- o>></c-></code> synopsis [<strong>cstdlib.syn</strong>] as follows:</p>
   <blockquote>
    <p>
     [...]<br> <code class="highlight"><c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>abs</c-><c- p>(</c-><c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- n>j</c-><c- p>);</c-></code><br>
     <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-> <c- nf>abs</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>j</c-><c- p>);</c-></code></ins>
     <br> <code class="highlight"><c- b>float</c-> <c- nf>abs</c-><c- p>(</c-><c- b>float</c-> <c- n>j</c-><c- p>);</c-></code><br> [...]<br>
    </p>
   </blockquote>
   <p class="note" role="note"><span>Note:</span> <code class="highlight"><c- n>strtosf</c-></code> is not added on purpose, since the <code class="highlight"><c- n>strto</c-><c- o>*</c-></code> family is owned by C. <code class="highlight"><c- n>abs</c-></code> is provided for the new type,
since C++ already extends the overload set of this function.</p>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>limits</c-><c- o>></c-></code> synopsis [<strong>limits.syn</strong>] as follows:</p>
   <blockquote>
    <p>[...]<br> <code class="highlight"><c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>numeric_limits</c-><c- o>&lt;</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- o>></c-><c- p>;</c-></code></p>
    <ins><code class="highlight"><c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>numeric_limits</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-><c- p>;</c-></code></ins>
    <br> <code class="highlight"><c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>numeric_limits</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>;</c-></code><br> [...] 
   </blockquote>
   <p>Do not modify Header <code class="highlight"><c- o>&lt;</c-><c- n>cfloat</c-><c- o>></c-></code> synopsis [<strong>cfloat.syn</strong>].</p>
   <p class="note" role="note"><span>Note:</span> no macros are added to <code class="highlight"><c- o>&lt;</c-><c- n>cfloat</c-><c- o>></c-></code>, on purpose, because that header’s contents are fully owned by C.</p>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>charconv</c-><c- o>></c-></code> synopsis [<strong>charconv.syn</strong>] as follows:</p>
   <p class="issue" id="issue-e5bd59df"><a class="self-link" href="#issue-e5bd59df"></a> it is possible that instead of adding a new overload, the overloads could be folded into a single specified
function, the way that integer overloads of all of these are specified.</p>
   <blockquote>
    <p>[...]<br></p>
<pre class="highlight"><c- c1>// [charconv.to.chars], primitive numerical output conversion</c->
<c- k>struct</c-> <c- n>to_</c->­<c- n>chars_</c->­<c- n>result</c-> <c- p>{</c->
  <c- b>char</c-><c- o>*</c-> <c- n>ptr</c-><c- p>;</c->
  <c- n>errc</c-> <c- n>ec</c-><c- p>;</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- b>int</c-> <c- n>base</c-> <c- o>=</c-> <c- mi>10</c-><c- p>);</c->
</pre>
    <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- b>short</c-> <c- b>float</c-> <c- n>value</c-><c- p>);</c->
</pre>
    </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- 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>
    <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- b>short</c-> <c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
</pre>
    </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- 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>
    <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- b>short</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->
</pre>
    </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- 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->

<c- c1>// [charconv.from.chars], primitive numerical input conversion</c->
<c- k>struct</c-> <c- n>from_</c->­<c- n>chars_</c->­<c- n>result</c-> <c- p>{</c->
  <c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>ptr</c-><c- p>;</c->
  <c- n>errc</c-> <c- n>ec</c-><c- p>;</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- 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>
    <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- b>short</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->
</pre>
    </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- 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->
<c- p>}</c->
</pre>
   </blockquote>
   <p>Modify Primitive numeric output conversion [<strong>charconv.to.chars</strong>] as follows, by adding overloads to the lists of signatures:</p>
   <blockquote>
    <p>[...]</p>
    <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- b>short</c-> <c- b>float</c-> <c- n>value</c-><c- p>);</c->
</pre>
    </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- 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>
    <p>[...]</p>
    <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- b>short</c-> <c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- n>chars_format</c-> <c- n>fmt</c-><c- p>);</c->
</pre>
    </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- 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>
    <p>[...]</p>
    <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- b>short</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->
</pre>
    </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- 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>
    <p>[...]</p>
   </blockquote>
   <p class="note" role="note"><span>Note:</span> no changes in descriptions are needed, since all those overloads of every of those functions are specified together
already.</p>
   <p>Modify Primitive numeric input conversions [<strong>charconv.from.chars</strong>] as follows, by adding an overload to the list of signatures:</p>
   <blockquote>
    <p>[...]</p>
    <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- b>short</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->
</pre>
    </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- 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>
    <p>[...]</p>
   </blockquote>
   <p class="note" role="note"><span>Note:</span> no changes in descriptions are needed, since all those overloads of every of those functions are specified together
already.</p>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>string</c-><c- o>></c-></code> synopsis [<strong>string.syn</strong>] as follows:</p>
   <blockquote>
    <p>[...]</p>
    <p>
     <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br>
     <ins><code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>val</c-><c- p>);</c-></code></ins>
     <br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>float</c-> <c- n>val</c-><c- p>);</c-></code>
    </p>
    <p>[...]</p>
    <p>
     <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br>
     <ins><code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>val</c-><c- p>);</c-></code></ins>
     <br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>float</c-> <c- n>val</c-><c- p>);</c-></code>
    </p>
    <p>[...]</p>
   </blockquote>
   <p class="issue" id="issue-62214127"><a class="self-link" href="#issue-62214127"></a> the definitions of the <code class="highlight"><c- n>sto</c-><c- o>*</c-></code> family depend on C functions in the <code class="highlight"><c- n>strto</c-><c- o>*</c-></code> family. Should an overload for <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> be added?</p>
   <p>Modify Numeric conversions [<strong>string.conversions</strong>] as follows:</p>
   <blockquote>
    <p>[...]</p>
    <p>
     <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>int</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>unsigned</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>long</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br>
     <ins><code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>val</c-><c- p>);</c-></code></ins>
     <br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>float</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>double</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>string</c-> <c- nf>to_string</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>val</c-><c- p>);</c-></code>
    </p>
    <ol start="7">
     <li data-md>
      <p>
       Returns: Each function returns a <code class="highlight"><c- n>string</c-></code> object holding the character representation of the value of its argument
that would be generated by calling <code class="highlight"><c- n>sprintf</c-><c- p>(</c-><c- n>buf</c-><c- p>,</c-> <c- n>fmt</c-><c- p>,</c-> <c- n>val</c-><c- p>)</c-></code> with a format specifier of <code class="highlight"><c- s>"%d"</c-></code>, <code class="highlight"><c- s>"%u"</c-></code>, <code class="highlight"><c- s>"%ld"</c-></code>, <code class="highlight"><c- s>"%lu"</c-></code>, <code class="highlight"><c- s>"%lld"</c-></code>, <code class="highlight"><c- s>"%llu"</c-></code>, 
       <ins><code class="highlight"><c- s>"%f"</c-></code>,</ins>
        <code class="highlight"><c- s>"%f"</c-></code>, <code class="highlight"><c- s>"%f"</c-></code>, or <code class="highlight"><c- s>"%Lf"</c-></code>, respectively, where <code class="highlight"><c- n>buf</c-></code> designates an internal
character buffer of sufficient size.
      </p>
    </ol>
    <p>[...]</p>
    <p>
     <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>int</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>unsigned</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>long</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br>
     <ins><code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>val</c-><c- p>);</c-></code></ins>
     <br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>float</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>double</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- n>wstring</c-> <c- nf>to_wstring</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>val</c-><c- p>);</c-></code>
    </p>
    <ol start="14">
     <li data-md>
      <p>
       Returns: Each function returns a <code class="highlight"><c- n>wstring</c-></code> object holding the character representation of the value of its argument
that would be generated by calling <code class="highlight"><c- n>sprintf</c-><c- p>(</c-><c- n>buf</c-><c- p>,</c-> <c- n>fmt</c-><c- p>,</c-> <c- n>val</c-><c- p>)</c-></code> with a format specifier of <code class="highlight"><c- s>"%d"</c-></code>, <code class="highlight"><c- s>"%u"</c-></code>, <code class="highlight"><c- s>"%ld"</c-></code>, <code class="highlight"><c- s>"%lu"</c-></code>, <code class="highlight"><c- s>"%lld"</c-></code>, <code class="highlight"><c- s>"%llu"</c-></code>, 
       <ins><code class="highlight"><c- s>"%f"</c-></code>,</ins>
        <code class="highlight"><c- s>"%f"</c-></code>, <code class="highlight"><c- s>"%f"</c-></code>, or <code class="highlight"><c- s>"%Lf"</c-></code>, respectively, where <code class="highlight"><c- n>buf</c-></code> designates an internal
character buffer of sufficient size.
      </p>
    </ol>
   </blockquote>
   <p>Modify Complex numbers [<strong>complex.numbers</strong>] paragraph 2:</p>
   <blockquote>
    <p>
     The effect of instantiating the template <code class="highlight"><c- n>complex</c-></code> for any type other than 
     <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-></code>,</ins>
      <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> is unspecified. The specializations 
     <ins><code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-></code>,</ins>
      <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> are literal types.
    </p>
   </blockquote>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>complex</c-><c- o>></c-></code> synopsis [<strong>complex.syn</strong>] as follows:</p>
   <blockquote>
    <p>[...]</p>
<pre class="highlight"><c- c1>// [complex.special], complex specializations</c->
</pre>
    <ins>
<pre class="highlight"><c- k>template</c-><c- o>&lt;></c-> <c- k>class</c-> <c- nc>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-><c- p>;</c->
</pre>
    </ins>
<pre class="highlight"><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>
    <p>[...]</p>
<pre class="highlight"><c- c1>// [complex.literals], complex literals</c->
<c- kr>inline</c-> <c- k>namespace</c-> <c- n>literals</c-> <c- p>{</c->
<c- kr>inline</c-> <c- k>namespace</c-> <c- n>complex_literals</c-> <c- p>{</c->
  <c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>il</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>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>il</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- p>);</c->
  <c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>i</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>&lt;</c-><c- b>double</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>i</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- p>);</c->
  <c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- k>if</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>&lt;</c-><c- b>float</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- k>if</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>isf</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>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>isf</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight"><c- p>}</c->
<c- p>}</c->
</pre>
   </blockquote>
   <p>Modify <code class="highlight"><c- n>complex</c-></code> specializations [<strong>complex.special</strong>] as follows:</p>
   <blockquote>
    <ins>
<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>short</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>short</c-> <c- b>float</c-><c- p>;</c->

    <c- k>constexpr</c-> <c- nf>complex</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>re</c-> <c- o>=</c-> <c- mf>0.0</c-><c- n>sf</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>im</c-> <c- o>=</c-> <c- mf>0.0</c-><c- n>sf</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>short</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>float</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>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>short</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>short</c-> <c- b>float</c-><c- p>);</c->
    <c- k>constexpr</c-> <c- b>short</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>short</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>short</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>short</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>short</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>short</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>short</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->
</pre>
    </ins>
<pre class="highlight">  <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->
</pre>
    <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>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>>&amp;</c-><c- p>);</c->
</pre>
    </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>&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->
</pre>
    <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>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>>&amp;</c-><c- p>);</c->
</pre>
    </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>&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->
</pre>
    <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>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>>&amp;</c-><c- p>);</c->
</pre>
    </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>&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>
   </blockquote>
   <p>Add an item to Additional overloads [<strong>cmplx.over</strong>] paragraph 2:</p>
   <blockquote>
    <p>[...]</p>
    <ul>
     <li data-md>
      <p>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>.</p>
     <li data-md>
      <ins>Otherwise, if the argument has type <code class="highlight"><c- b>short</c-> <c- b>float</c-></code>, then it is effectively cast to <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-></code>.</ins>
    </ul>
   </blockquote>
   <p>Add an item to Additional overloads [<strong>cmplx.over</strong>] paragraph 3:</p>
   <blockquote>
    <p>[...]</p>
    <ul>
     <li data-md>
      <p>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>.</p>
     <li data-md>
      <ins>Otherwise, if either argument has type <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-></code> org <code class="highlight"><c- b>short</c-> <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>short</c-> <c- b>float</c-><c- o>></c-></code>.</ins>
    </ul>
   </blockquote>
   <p>Modify Suffixes for complex number literals [<strong>complex.literals</strong>] as follows:</p>
   <blockquote>
    <ol>
     <li data-md>
      <p>
       This subclause describes literal suffixes for constructing complex number literals. The suffixes 
       <del><code class="highlight"><c- n>i</c-></code>, <code class="highlight"><c- n>il</c-></code>, and <code class="highlight"><c- k>if</c-></code></del>
       <ins> <code class="highlight"><c- n>il</c-></code>, <code class="highlight"><c- n>i</c-></code>, <code class="highlight"><c- k>if</c-></code>, and <code class="highlight"><c- n>isf</c-></code></ins>
        create complex numbers of the types 
       <del><code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-></code>, <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-></code>,
and</del>
       <ins><code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-></code>, <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-></code></ins>
       , <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-></code>
       <ins>, and <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-></code></ins>
        respectively, with their imaginary part denoted by the given literal number and the real part being zero.
      </p>
    </ol>
<pre class="highlight"><c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>il</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>d</c-><c- p>);</c->
<c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>il</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>d</c-><c- p>);</c->
</pre>
    <ol start="2">
     <li data-md>
      <p>Returns: <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-><c- p>{</c-><c- mf>0.0</c-><c- n>L</c-><c- p>,</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- b>long</c-> <c- b>double</c-><c- o>></c-><c- p>(</c-><c- n>d</c-><c- p>)}</c-></code>.</p>
    </ol>
<pre class="highlight"><c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>i</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>d</c-><c- p>);</c->
<c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>i</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>d</c-><c- p>);</c->
</pre>
    <ol start="3">
     <li data-md>
      <p>Returns: <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-><c- p>{</c-><c- mf>0.0</c-><c- p>,</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-><c- p>(</c-><c- n>d</c-><c- p>)}</c-></code>.</p>
    </ol>
<pre class="highlight"><c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- k>if</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>d</c-><c- p>);</c->
<c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- k>if</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>d</c-><c- p>);</c->
</pre>
    <ol start="4">
     <li data-md>
      <p>Returns: <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>{</c-><c- mf>0.0f</c-><c- p>,</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>(</c-><c- n>d</c-><c- p>)}</c-></code>.</p>
    </ol>
    <ins>
<pre class="highlight"><c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>isf</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>d</c-><c- p>);</c->
<c- k>constexpr</c-> <c- n>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-> <c- k>operator</c-><c- s>""</c-><c- n>isf</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>d</c-><c- p>);</c->
</pre>
     <ol start="5">
      <li data-md>
       <p>Returns: <code class="highlight"><c- n>complex</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-><c- p>{</c-><c- mf>0.0</c-><c- n>sf</c-><c- p>,</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-><c- p>(</c-><c- n>d</c-><c- p>)}</c-></code>.</p>
     </ol>
    </ins>
   </blockquote>
   <p>Modify General requirements [<strong>rand.req.genl</strong>] paragraph 1 d):</p>
   <blockquote>
    <p>
     d) that has a template type parameter named <code class="highlight"><c- n>RealType</c-></code> is undefined unless the corresponding template argument is cv-unqualified
        and is one of 
     <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-></code>,</ins>
      <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>.
    </p>
   </blockquote>
   <p>Modify Header <code class="highlight"><c- o>&lt;</c-><c- n>cmath</c-><c- o>></c-></code> synopsis [<strong>cmath.syn</strong>] as follows:</p>
   <blockquote>
    <p>[...]</p>
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>acos</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c-> <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>acos</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>acos</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>acos</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>acosf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>acosl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>asin</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>asin</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>asin</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>asin</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>asinf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>asinl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>atan</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>atan</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>atan</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>atan</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>atanf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>atanl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>atan2</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>atan2</c-><c- p>(</c-><c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>atan2</c-><c- p>(</c-><c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>atan2</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>atan2f</c-><c- p>(</c-><c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>atan2l</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>cos</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>cos</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>cos</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>cos</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>cosf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>cosl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>sin</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>sin</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>sin</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>sin</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>sinf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>sinl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>tan</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>tan</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>tan</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>tan</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>tanf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>tanl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>acosh</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>acosh</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>acosh</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>acosh</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>acoshf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>acoshl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>asinh</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>asinh</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>asinh</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>asinh</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>asinhf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>asinhl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>atanh</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>atanh</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>atanh</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>atanh</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>atanhf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>atanhl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>cosh</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>cosh</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>cosh</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>cosh</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>coshf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>coshl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>sinh</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>sinh</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>sinh</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>sinh</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>sinhf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>sinhl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>tanh</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>tanh</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>tanh</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>tanh</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>tanhf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>tanhl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>exp</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>exp</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>exp</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>exp</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>expf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>expl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>exp2</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>exp2</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>exp2</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>exp2</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>exp2f</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>exp2l</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>expm1</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>expm1</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>expm1</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>expm1</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>expm1f</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>expm1l</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>frexp</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>exp</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>frexp</c-><c- p>(</c-><c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>exp</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>frexp</c-><c- p>(</c-><c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>exp</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>frexp</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>exp</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>frexpf</c-><c- p>(</c-><c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>exp</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>frexpl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>exp</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>int</c-> <c- nf>ilogb</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>int</c-> <c- nf>ilogb</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>int</c-> <c- nf>ilogb</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>int</c-> <c- nf>ilogb</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>int</c-> <c- nf>ilogbf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>int</c-> <c- nf>ilogbl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>ldexp</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>exp</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>ldexp</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>exp</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>ldexp</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>exp</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>ldexp</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>exp</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>ldexpf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>exp</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>ldexpl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>exp</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>log</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>log</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>log</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>log</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>logf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>logl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>log10</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>log10</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>log10</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>log10</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>log10f</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>log10l</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>log1p</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>log1p</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>log1p</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>log1p</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>log1pf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>log1pl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>log2</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>log2</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>log2</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>log2</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>log2f</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>log2l</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>logb</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>logb</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>logb</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>logb</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>logbf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>logbl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>modf</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-><c- o>*</c-> <c- n>iptr</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>modf</c-><c- p>(</c-><c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- b>float</c-><c- o>*</c-> <c- n>iptr</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>modf</c-><c- p>(</c-><c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- b>double</c-><c- o>*</c-> <c- n>iptr</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>modf</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-><c- o>*</c-> <c- n>iptr</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>modff</c-><c- p>(</c-><c- b>float</c-> <c- n>value</c-><c- p>,</c-> <c- b>float</c-><c- o>*</c-> <c- n>iptr</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>modfl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>value</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-><c- o>*</c-> <c- n>iptr</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>scalbn</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>scalbn</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>scalbn</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>scalbn</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>scalbnf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>scalbnl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>scalbln</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>scalbln</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>scalbln</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>scalbln</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>scalblnf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>scalblnl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>int</c-> <c- n>n</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>cbrt</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>cbrt</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>cbrt</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>cbrt</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>cbrtf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>cbrtl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->

  <c- c1>// [c.math.abs], absolute values</c->
  <c- b>int</c-> <c- nf>abs</c-><c- p>(</c-><c- b>int</c-> <c- n>j</c-><c- p>);</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>abs</c-><c- p>(</c-><c- b>long</c-> <c- b>int</c-> <c- n>j</c-><c- p>);</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>abs</c-><c- p>(</c-><c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- n>j</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>abs</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>j</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>abs</c-><c- p>(</c-><c- b>float</c-> <c- n>j</c-><c- p>);</c->
  <c- b>double</c-> <c- nf>abs</c-><c- p>(</c-><c- b>double</c-> <c- n>j</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>abs</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>j</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>fabs</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>fabs</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>fabs</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fabs</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>fabsf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fabsl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>hypotf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>hypotl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->

  <c- c1>// [c.math.hypot3], three-dimensional hypotenuse</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>z</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>float</c-> <c- n>z</c-><c- p>);</c->
  <c- b>double</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>double</c-> <c- n>z</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>z</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>pow</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>pow</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>pow</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>pow</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>powf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>powl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>sqrt</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>sqrt</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>sqrt</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>sqrt</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>sqrtf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>sqrtl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>erf</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>erf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>erf</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>erf</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>erff</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>erfl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>erfc</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>erfc</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>erfc</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>erfc</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>erfcf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>erfcl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>lgamma</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>lgamma</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>lgamma</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>lgamma</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>lgammaf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>lgammal</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>tgamma</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>tgamma</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>tgamma</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>tgamma</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>tgammaf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>tgammal</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>ceil</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>ceil</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>ceil</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>ceil</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>ceilf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>ceill</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>floor</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>floor</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>floor</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>floor</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>floorf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>floorl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>nearbyint</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>nearbyint</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>nearbyint</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>nearbyint</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>nearbyintf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>nearbyintl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>rint</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>rint</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>rint</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>rint</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>rintf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>rintl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>long</c-> <c- b>int</c-> <c- nf>lrint</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>long</c-> <c- b>int</c-> <c- nf>lrint</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>lrint</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>lrint</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>lrintf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>lrintl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llrint</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llrint</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llrint</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llrint</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llrintf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llrintl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>round</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>round</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>round</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>round</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>roundf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>roundl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>long</c-> <c- b>int</c-> <c- nf>lround</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>long</c-> <c- b>int</c-> <c- nf>lround</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>lround</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>lround</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>lroundf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>int</c-> <c- nf>lroundl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llround</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llround</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llround</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llround</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llroundf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>llroundl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>trunc</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>trunc</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>trunc</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>trunc</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>truncf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>truncl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>fmod</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>fmod</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>fmod</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fmod</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>fmodf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fmodl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>remainder</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>remainder</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>remainder</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>remainder</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>remainderf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>remainderl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>remquo</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>quo</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>remquo</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>quo</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>remquo</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>quo</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>remquo</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>quo</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>remquof</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>quo</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>remquol</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>int</c-><c- o>*</c-> <c- n>quo</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>copysign</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>copysign</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>copysign</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>copysign</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>copysignf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>copysignl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->

  <c- b>double</c-> <c- nf>nan</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>tagp</c-><c- p>);</c->
  <c- b>float</c-> <c- nf>nanf</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>tagp</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>nanl</c-><c- p>(</c-><c- k>const</c-> <c- b>char</c-><c- o>*</c-> <c- n>tagp</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>nextafter</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>nextafter</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>nextafter</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>nextafter</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>nextafterf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>nextafterl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>nexttoward</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>nexttoward</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>nexttoward</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>nexttoward</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>nexttowardf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>nexttowardl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>fdim</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>fdim</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>fdim</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fdim</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>fdimf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fdiml</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>fmax</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>fmax</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>fmax</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fmax</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>fmaxf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fmaxl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>fmin</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>fmin</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>fmin</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fmin</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>fminf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fminl</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>short</c-> <c- b>float</c-> <c- nf>fma</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>z</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>float</c-> <c- nf>fma</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>float</c-> <c- n>z</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>double</c-> <c- nf>fma</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>double</c-> <c- n>z</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fma</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>z</c-><c- p>);</c->  <c- c1>// see [library.c]</c->
  <c- b>float</c-> <c- nf>fmaf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>float</c-> <c- n>z</c-><c- p>);</c->
  <c- b>long</c-> <c- b>double</c-> <c- nf>fmal</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>z</c-><c- p>);</c->

  <c- c1>// [c.math.fpclass], classification / comparison functions</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>int</c-> <c- nf>fpclassify</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>int</c-> <c- nf>fpclassify</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>int</c-> <c- nf>fpclassify</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>int</c-> <c- nf>fpclassify</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isfinite</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isfinite</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isfinite</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isfinite</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isinf</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isinf</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isinf</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isinf</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isnan</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isnan</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isnan</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isnan</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isnormal</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isnormal</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isnormal</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isnormal</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>signbit</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>signbit</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>signbit</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>signbit</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isgreater</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isgreater</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isgreater</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isgreater</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isgreaterequal</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isgreaterequal</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isgreaterequal</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isgreaterequal</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isless</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isless</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isless</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isless</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>islessequal</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>islessequal</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>islessequal</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>islessequal</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>islessgreater</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>islessgreater</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>islessgreater</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>islessgreater</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isunordered</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight">  <c- b>bool</c-> <c- nf>isunordered</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isunordered</c-><c- p>(</c-><c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
  <c- b>bool</c-> <c- nf>isunordered</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>x</c-><c- p>,</c-> <c- b>long</c-> <c- b>double</c-> <c- n>y</c-><c- p>);</c->
</pre>
    <p>[...]</p>
   </blockquote>
   <p class="note" role="note"><span>Note:</span> mathematical special functions for <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> are not provided, out of concern about precision. They are still
callable with a <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> value thanks to a promotion to <code class="highlight"><c- b>float</c-></code>.</p>
   <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:</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>
        <p>If any argument of arithmetic type corresponding to a <code class="highlight"><c- b>double</c-></code> parameter has type <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>, then all arguments
of arithmetic type corresponding to <code class="highlight"><c- b>double</c-></code> parameters are effectively cast to <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>.</p>
       <li data-md>
        <p>Otherwise, if any argument of arithmetic type corresponding to a <code class="highlight"><c- b>double</c-></code> parameter has type <code class="highlight"><c- b>double</c-></code> or an integer type,
then all arguments of arithmetic type corresponding to <code class="highlight"><c- b>double</c-></code> parameters are effectively cast to <code class="highlight"><c- b>double</c-></code>.</p>
       <li data-md>
        <p>
         Otherwise, 
         <del>all arguments</del>
         <ins>if any argument</ins>
          of arithmetic type corresponding to 
         <ins>a</ins>
          <code class="highlight"><c- b>double</c-></code> 
         <del>parameters have</del>
         <ins>parameter has</ins>
          type <code class="highlight"><c- b>float</c-></code>
         <del>.</del>
         <ins>, then all arguments of
arithmetic type corresponding to <code class="highlight"><c- b>double</c-></code> parameters are effectively cast to <code class="highlight"><c- b>float</c-></code>.</ins>
        </p>
       <li data-md>
        <ins>Otherwise, all arguments of arithmetic type corresponding to <code class="highlight"><c- b>double</c-></code> parameters have type <code class="highlight"><c- b>short</c-> <c- b>float</c-></code>.</ins>
      </ol>
    </ol>
   </blockquote>
   <p>Modify Absolute values [<strong>c.math.abs</strong>] as follows:</p>
   <blockquote>
    <ol>
     <li data-md>
      <p>
       [ Note: The headers 
       <cstdlib>
         and 
        <cmath> declare the functions described in this subclause. — end note ]</cmath>
       </cstdlib>
      </p>
    </ol>
    <p><code class="highlight"><c- b>int</c-> <c- nf>abs</c-><c- p>(</c-><c- b>int</c-> <c- n>j</c-><c- p>);</c-></code><br> <code class="highlight"><c- b>long</c-> <c- b>int</c-> <c- nf>abs</c-><c- p>(</c-><c- b>long</c-> <c- b>int</c-> <c- n>j</c-><c- p>);</c-></code><br> <code class="highlight"><c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- nf>abs</c-><c- p>(</c-><c- b>long</c-> <c- b>long</c-> <c- b>int</c-> <c- n>j</c-><c- p>);</c-></code><br> <code class="highlight"><c- b>float</c-> <c- nf>abs</c-><c- p>(</c-><c- b>float</c-> <c- n>j</c-><c- p>);</c-></code><br> <code class="highlight"><c- b>double</c-> <c- nf>abs</c-><c- p>(</c-><c- b>double</c-> <c- n>j</c-><c- p>);</c-></code><br> <code class="highlight"><c- b>long</c-> <c- b>double</c-> <c- nf>abs</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>j</c-><c- p>);</c-></code></p>
    <ol start="2">
     <li data-md>
      <p>Effects: The abs functions have the semantics specified in the C standard library for the functions <code class="highlight"><c- n>abs</c-></code>, <code class="highlight"><c- n>labs</c-></code>, <code class="highlight"><c- n>llabs</c-></code>, <code class="highlight"><c- n>fabsf</c-></code>, <code class="highlight"><c- n>fabs</c-></code>, and <code class="highlight"><c- n>fabsl</c-></code>.</p>
     <li data-md>
      <p>Remarks: If <code class="highlight"><c- n>abs</c-><c- p>()</c-></code> is called with an argument of type <code class="highlight"><c- n>X</c-></code> for which <code class="highlight"><c- n>is_unsigned_v</c-><c- o>&lt;</c-><c- n>X</c-><c- o>></c-></code> is <code class="highlight">true</code> and if <code class="highlight"><c- n>X</c-></code> cannot
be converted to <code class="highlight"><c- b>int</c-></code> by integral promotion, the program is ill-formed. [ Note: Arguments that can be promoted to <code class="highlight"><c- b>int</c-></code> are permitted for compatibility with C. — end note ]</p>
    </ol>
    <ins>
      <code class="highlight"><c- b>short</c-> <c- b>float</c-> <c- nf>abs</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>j</c-><c- p>);</c-></code> 
     <ol start="4">
      <li data-md>
       <p>Effects: as if by <code class="highlight"><c- k>static_cast</c-><c- o>&lt;</c-><c- b>short</c-> <c- b>float</c-><c- o>></c-><c- p>(</c-><c- n>abs</c-><c- p>(</c-><c- k>static_cast</c-><c- o>&lt;</c-><c- b>float</c-><c- o>></c-><c- p>(</c-><c- n>j</c-><c- p>)))</c-></code>.</p>
     </ol>
    </ins>
   </blockquote>
   <p>Modify Three-dimensional hypotenuse [<strong>c.math.hypot3</strong>] as follows:</p>
   <blockquote>
    <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-> <c- n>z</c-><c- p>);</c-></code></ins>
    <br> <code class="highlight"><c- b>float</c-> <c- nf>hypot</c-><c- p>(</c-><c- b>float</c-> <c- n>x</c-><c- p>,</c-> <c- b>float</c-> <c- n>y</c-><c- p>,</c-> <c- b>float</c-> <c- n>z</c-><c- p>);</c-></code><br> [...] 
   </blockquote>
   <p>Modify Classification / comparison functions [<strong>c.math.fpclass</strong>] paragraph 1:</p>
   <blockquote>
    <p>
     The classification / comparison functions behave the same as the C macros with the corresponding names defined in the
    C standard library. Each function is overloaded for the 
     <del>three</del>
     <ins>four</ins>
      floating-point types.
    </p>
   </blockquote>
   <p>Modify Class template <code class="highlight"><c- n>num_get</c-></code> [<strong>locale.num.get</strong>], adding new overloads:</p>
   <blockquote>
    <p>[...]</p>
<pre class="highlight">  <c- n>iter_type</c-> <c- nf>get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-><c- p>,</c->
                <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- o>&amp;</c-> <c- n>v</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    <ins>
<pre class="highlight">  <c- n>iter_type</c-> <c- nf>get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-><c- p>,</c->
                <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>v</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    </ins>
<pre class="highlight">  <c- n>iter_type</c-> <c- nf>get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-><c- p>,</c->
                <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>v</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    <p>[...]</p>
<pre class="highlight">  <c- k>virtual</c-> <c- n>iter_type</c-> <c- nf>do_get</c-><c- p>(</c-><c- n>iter_type</c-><c- p>,</c-> <c- n>iter_type</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-><c- p>,</c->
                           <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- o>&amp;</c-> <c- n>v</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    <ins>
<pre class="highlight">  <c- k>virtual</c-> <c- n>iter_type</c-> <c- nf>do_get</c-><c- p>(</c-><c- n>iter_type</c-><c- p>,</c-> <c- n>iter_type</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-><c- p>,</c->
                           <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>v</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    </ins>
<pre class="highlight">  <c- k>virtual</c-> <c- n>iter_type</c-> <c- nf>do_get</c-><c- p>(</c-><c- n>iter_type</c-><c- p>,</c-> <c- n>iter_type</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-><c- p>,</c->
                           <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>v</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
   </blockquote>
   <p>Modify <code class="highlight"><c- n>num_get</c-></code> members [<strong>facet.num.get.members</strong>], mentioning the new overload:</p>
   <blockquote>
    <p>[...]</p>
<pre class="highlight"><c- n>iter_type</c-> <c- nf>get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-> <c- n>str</c-><c- p>,</c->
              <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    <ins>
<pre class="highlight"><c- n>iter_type</c-> <c- nf>get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-> <c- n>str</c-><c- p>,</c->
              <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    </ins>
<pre class="highlight"><c- n>iter_type</c-> <c- nf>get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-> <c- n>str</c-><c- p>,</c->
              <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    <p>[...]</p>
   </blockquote>
   <p>Modify <code class="highlight"><c- n>num_get</c-></code> virtual functions [<strong>facet.num.get.virtuals</strong>], mentioning the new overload:</p>
   <blockquote>
<pre class="highlight"><c- n>iter_type</c-> <c- nf>do_get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-> <c- n>str</c-><c- p>,</c->
                <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    <ins>
<pre class="highlight"><c- n>iter_type</c-> <c- nf>do_get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-> <c- n>str</c-><c- p>,</c->
                <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>short</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    </ins>
<pre class="highlight"><c- n>iter_type</c-> <c- nf>do_get</c-><c- p>(</c-><c- n>iter_type</c-> <c- n>in</c-><c- p>,</c-> <c- n>iter_type</c-> <c- n>end</c-><c- p>,</c-> <c- n>ios_base</c-><c- o>&amp;</c-> <c- n>str</c-><c- p>,</c->
                <c- n>ios_base</c-><c- o>::</c-><c- n>iostate</c-><c- o>&amp;</c-> <c- n>err</c-><c- p>,</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
   </blockquote>
   <p>In <code class="highlight"><c- n>num_get</c-></code> virtual functions [<strong>facet.num.get.virtuals</strong>] paragraph 3 stage 3, insert a new item before item 3:</p>
   <blockquote>
    <p>[...]</p>
    <ul>
     <li data-md>
      <p>For an unsigned integer value, the function <code class="highlight"><c- n>strtoull</c-></code>.</p>
     <li data-md>
      <ins>For a <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> value, the function <code class="highlight"><c- n>strtof</c-></code>.</ins>
     <li data-md>
      <p>For a <code class="highlight"><c- b>float</c-></code> value, the function <code class="highlight"><c- n>strtof</c-></code>.</p>
    </ul>
    <p>[...]</p>
   </blockquote>
   <p>Modify Class template <code class="highlight"><c- n>basic_istream</c-></code> [<strong>istream</strong>], adding a new overload:</p>
   <blockquote>
    <p>[...]</p>
<pre class="highlight"><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>&amp;</c-> <c- k>operator</c-><c- o>>></c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- o>&amp;</c-> <c- n>n</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight"><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>&amp;</c-> <c- k>operator</c-><c- o>>></c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>f</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight"><c- n>basic_istream</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>&amp;</c-> <c- k>operator</c-><c- o>>></c-><c- p>(</c-><c- b>float</c-><c- o>&amp;</c-> <c- n>f</c-><c- p>);</c->
</pre>
    <p>[...]</p>
   </blockquote>
   <p>Modify Arithmetic extractors [<strong>istream.formatted.arithmetic</strong>] to mention the new overload:</p>
   <blockquote>
    <p>[...]</p>
    <p>
     <code class="highlight"><c- k>operator</c-><c- o>>></c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>);</c-></code><br>
     <ins><code class="highlight"><c- k>operator</c-><c- o>>></c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>);</c-></code></ins>
     <br> <code class="highlight"><c- k>operator</c-><c- o>>></c-><c- p>(</c-><c- b>float</c-><c- o>&amp;</c-> <c- n>val</c-><c- p>);</c-></code>
    </p>
    <p>[...]</p>
   </blockquote>
   <p>Modify Class template <code class="highlight"><c- n>basic_ostream</c-></code> [<strong>ostream</strong>], adding a new overload:</p>
   <blockquote>
    <p>[...]</p>
<pre class="highlight"><c- n>basic_ostream</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>&amp;</c-> <c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>n</c-><c- p>);</c->
</pre>
    <ins>
<pre class="highlight"><c- n>basic_ostream</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>&amp;</c-> <c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>f</c-><c- p>);</c->
</pre>
    </ins>
<pre class="highlight"><c- n>basic_ostream</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>&amp;</c-> <c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>float</c-> <c- n>f</c-><c- p>);</c->
</pre>
    <p>[...]</p>
   </blockquote>
   <p>Modify Arithmetic inserters [<strong>ostream.inserters.arithmetic</strong>] as follows:</p>
   <blockquote>
    <p>
     <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>bool</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>short</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>short</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>int</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>int</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>long</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-> <c- n>val</c-><c- p>);</c-></code><br>
     <ins><code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>short</c-> <c- b>float</c-> <c- n>val</c-><c- p>);</c-></code></ins>
     <br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>float</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>double</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- b>long</c-> <c- b>double</c-> <c- n>val</c-><c- p>);</c-></code><br> <code class="highlight"><c- k>operator</c-><c- o>&lt;&lt;</c-><c- p>(</c-><c- k>const</c-> <c- b>void</c-><c- o>*</c-> <c- n>val</c-><c- p>);</c-></code><br>
    </p>
    <ol>
     <li data-md>
      <p>Effects: The classes <code class="highlight"><c- n>num_get</c-><c- o>&lt;></c-></code> and <code class="highlight"><c- n>num_put</c-><c- o>&lt;></c-></code> handle locale-dependent numeric formatting and parsing. These inserter
functions use the imbued locale value to perform numeric formatting. When val is of type <code class="highlight"><c- b>bool</c-></code>, <code class="highlight"><c- b>long</c-></code>, <code class="highlight"><c- b>unsigned</c-> <c- b>long</c-></code>, <code class="highlight"><c- b>long</c-> <c- b>long</c-></code>, <code class="highlight"><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-></code>, <code class="highlight"><c- b>double</c-></code>, <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>, or <code class="highlight"><c- k>const</c-> <c- b>void</c-><c- o>*</c-></code>, the formatting conversion occurs as if it
performed the following code fragment:</p>
    </ol>
<pre class="highlight"><c- b>bool</c-> <c- n>failed</c-> <c- o>=</c-> <c- n>use_facet</c-><c- o>&lt;</c->
  <c- n>num_put</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>ostreambuf_iterator</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>></c->
    <c- o>></c-><c- p>(</c-><c- n>getloc</c-><c- p>()).</c-><c- n>put</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- n>fill</c-><c- p>(),</c-> <c- n>val</c-><c- p>).</c-><c- n>failed</c-><c- p>();</c->
</pre>
    <p>When val is of type <code class="highlight"><c- b>short</c-></code> the formatting conversion occurs as if it performed the following code fragment:</p>
<pre class="highlight"><c- n>ios_base</c-><c- o>::</c-><c- n>fmtflags</c-> <c- n>baseflags</c-> <c- o>=</c-> <c- n>ios_base</c-><c- o>::</c-><c- n>flags</c-><c- p>()</c-> <c- o>&amp;</c-> <c- n>ios_base</c-><c- o>::</c-><c- n>basefield</c-><c- p>;</c->
<c- b>bool</c-> <c- n>failed</c-> <c- o>=</c-> <c- n>use_facet</c-><c- o>&lt;</c->
  <c- n>num_put</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>ostreambuf_iterator</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>></c->
    <c- o>></c-><c- p>(</c-><c- n>getloc</c-><c- p>()).</c-><c- n>put</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- n>fill</c-><c- p>(),</c->
    <c- n>baseflags</c-> <c- o>==</c-> <c- n>ios_base</c-><c- o>::</c-><c- n>oct</c-> <c- o>||</c-> <c- n>baseflags</c-> <c- o>==</c-> <c- n>ios_base</c-><c- o>::</c-><c- n>hex</c->
      <c- o>?</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- b>long</c-><c- o>></c-><c- p>(</c-><c- k>static_cast</c-><c- o>&lt;</c-><c- b>unsigned</c-> <c- b>short</c-><c- o>></c-><c- p>(</c-><c- n>val</c-><c- p>))</c->
      <c- o>:</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- b>long</c-><c- o>></c-><c- p>(</c-><c- n>val</c-><c- p>)).</c-><c- n>failed</c-><c- p>();</c->
</pre>
    <p>When val is of type <code class="highlight"><c- b>int</c-></code> the formatting conversion occurs as if it performed the following code fragment:</p>
<pre class="highlight"><c- n>ios_base</c-><c- o>::</c-><c- n>fmtflags</c-> <c- n>baseflags</c-> <c- o>=</c-> <c- n>ios_base</c-><c- o>::</c-><c- n>flags</c-><c- p>()</c-> <c- o>&amp;</c-> <c- n>ios_base</c-><c- o>::</c-><c- n>basefield</c-><c- p>;</c->
<c- b>bool</c-> <c- n>failed</c-> <c- o>=</c-> <c- n>use_facet</c-><c- o>&lt;</c->
  <c- n>num_put</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>ostreambuf_iterator</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>></c->
    <c- o>></c-><c- p>(</c-><c- n>getloc</c-><c- p>()).</c-><c- n>put</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- n>fill</c-><c- p>(),</c->
    <c- n>baseflags</c-> <c- o>==</c-> <c- n>ios_base</c-><c- o>::</c-><c- n>oct</c-> <c- o>||</c-> <c- n>baseflags</c-> <c- o>==</c-> <c- n>ios_base</c-><c- o>::</c-><c- n>hex</c->
      <c- o>?</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- b>long</c-><c- o>></c-><c- p>(</c-><c- k>static_cast</c-><c- o>&lt;</c-><c- b>unsigned</c-> <c- b>int</c-><c- o>></c-><c- p>(</c-><c- n>val</c-><c- p>))</c->
      <c- o>:</c-> <c- k>static_cast</c-><c- o>&lt;</c-><c- b>long</c-><c- o>></c-><c- p>(</c-><c- n>val</c-><c- p>)).</c-><c- n>failed</c-><c- p>();</c->
</pre>
    <p>When val is of type <code class="highlight"><c- b>unsigned</c-> <c- b>short</c-></code> or <code class="highlight"><c- b>unsigned</c-> <c- b>int</c-></code> the formatting conversion occurs as if it performed the
        following code fragment:</p>
<pre class="highlight"><c- b>bool</c-> <c- n>failed</c-> <c- o>=</c-> <c- n>use_facet</c-><c- o>&lt;</c->
  <c- n>num_put</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>ostreambuf_iterator</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>></c->
    <c- o>></c-><c- p>(</c-><c- n>getloc</c-><c- p>()).</c-><c- n>put</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- n>fill</c-><c- p>(),</c->
      <c- k>static_cast</c-><c- o>&lt;</c-><c- b>unsigned</c-> <c- b>long</c-><c- o>></c-><c- p>(</c-><c- n>val</c-><c- p>)).</c-><c- n>failed</c-><c- p>();</c->
</pre>
    <p>
     When val is of type 
     <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-></code></ins>
      or <code class="highlight"><c- b>float</c-></code> the formatting conversion occurs as if it performed the
        following code fragment:
    </p>
<pre class="highlight"><c- b>bool</c-> <c- n>failed</c-> <c- o>=</c-> <c- n>use_facet</c-><c- o>&lt;</c->
  <c- n>num_put</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>ostreambuf_iterator</c-><c- o>&lt;</c-><c- n>charT</c-><c- p>,</c-> <c- n>traits</c-><c- o>>></c->
    <c- o>></c-><c- p>(</c-><c- n>getloc</c-><c- p>()).</c-><c- n>put</c-><c- p>(</c-><c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- o>*</c-><c- k>this</c-><c- p>,</c-> <c- n>fill</c-><c- p>(),</c->
      <c- k>static_cast</c-><c- o>&lt;</c-><c- b>double</c-><c- o>></c-><c- p>(</c-><c- n>val</c-><c- p>)).</c-><c- n>failed</c-><c- p>();</c->
</pre>
   </blockquote>
   <p>Modify Specializations for floating-point types [<strong>atomics.ref.float</strong>] paragraph 1:</p>
   <blockquote>
    <p>
     There are specializations of the <code class="highlight"><c- n>atomic_ref</c-></code> class template for the floating-point types 
     <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-></code>,</ins>
      <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>. For each such type <em>floating-point</em>, the specialization <code class="highlight"><c- n>atomic_ref</c-><c- o>&lt;</c-><i><c- n>floating</c-><c- o>-</c-><c- n>point</c-></i><c- o>></c-></code> provides additional atomic operations appropriate to floating-point
    types.
    </p>
   </blockquote>
   <p>Modify Specializations for floating-point types [<strong>atomics.types.float</strong>] paragraph 1:</p>
   <blockquote>
    <p>
     There are specializations of the <code class="highlight"><c- n>atomic</c-></code> class template for the floating-point types 
     <ins><code class="highlight"><c- b>short</c-> <c- b>float</c-></code>,</ins>
      <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>. For each such type <em>floating-point</em>, the specialization <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><i><c- n>floating</c-><c- o>-</c-><c- n>point</c-></i><c- o>></c-></code> provides additional atomic operations appropriate to floating-point
    types.
    </p>
   </blockquote>
   <h3 class="heading settled" data-level="4.2" id="wording-library"><span class="secno">4.2. </span><span class="content">Wording for library aliases</span><a class="self-link" href="#wording-library"></a></h3>
   <h4 class="heading settled" data-level="4.2.1" id="wording-library-library"><span class="secno">4.2.1. </span><span class="content">Library wording</span><a class="self-link" href="#wording-library-library"></a></h4>
   <p>Modify Headers [<strong>headers</strong>], table 18, by adding the new header to the list of C++ headers:</p>
   <blockquote>
    <p>[...]</p>
    <p>
     <code class="highlight"><c- o>&lt;</c-><c- n>contract</c-><c- o>></c-></code><br>
     <ins><code class="highlight"><c- o>&lt;</c-><c- n>cstdfloat</c-><c- o>></c-></code></ins>
     <br> <code class="highlight"><c- o>&lt;</c-><c- n>deque</c-><c- o>></c-></code>
    </p>
    <p>[...]</p>
   </blockquote>
   <p>Modify Freestanding implementation [<strong>compliance</strong>], table 21:</p>
   <blockquote>
    <table>
     <tbody>
      <tr>
       <td>
       <td><strong>Subclause</strong>
       <td><strong>Header(s)</strong>
      <tr>
       <td>[...]
       <td>[...]
       <td>[...]
      <tr>
       <td>16.4
       <td>Integer types
       <td><code class="highlight"><c- o>&lt;</c-><c- n>cstdint</c-><c- o>></c-></code>
      <tr>
       <td>
        <ins>16.?</ins>
       <td>
        <ins>Floating-point types</ins>
       <td>
        <ins><code class="highlight"><c- o>&lt;</c-><c- n>cstdfloat</c-><c- o>></c-></code></ins>
      <tr>
       <td>16.5
       <td>Start and termination
       <td><code class="highlight"><c- o>&lt;</c-><c- n>cstdlib</c-><c- o>></c-></code>
      <tr>
       <td>[...]
       <td>[...]
       <td>[...]
    </table>
   </blockquote>
   <p>Modify General [<strong>support.general</strong>] table 34:</p>
   <blockquote>
    <table>
     <tbody>
      <tr>
       <td>
       <td><strong>Subclause</strong>
       <td><strong>Header(s)</strong>
      <tr>
       <td>[...]
       <td>[...]
       <td>[...]
      <tr>
       <td>16.4
       <td>Integer types
       <td><code class="highlight"><c- o>&lt;</c-><c- n>cstdint</c-><c- o>></c-></code>
      <tr>
       <td>
        <ins>16.?</ins>
       <td>
        <ins>Floating-point types</ins>
       <td>
        <ins><code class="highlight"><c- o>&lt;</c-><c- n>cstdfloat</c-><c- o>></c-></code></ins>
      <tr>
       <td>16.5
       <td>Start and termination
       <td><code class="highlight"><c- o>&lt;</c-><c- n>cstdlib</c-><c- o>></c-></code>
      <tr>
       <td>[...]
       <td>[...]
       <td>[...]
    </table>
   </blockquote>
   <p>Insert a new subclause into Language support library [<strong>language.support</strong>] after Integer types [<strong>cstdint</strong>]:</p>
   <ins>
    <blockquote>
     <ins> 16.? Floating-point types [<strong>cstdfloat</strong>] </ins>
     <ins> 16.?.1 Header <code class="highlight"><c- o>&lt;</c-><c- n>cstdfloat</c-><c- o>></c-></code> synopsis [<strong>cstdfloat.syn</strong>] </ins>
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>using</c-></c-> <c- n><c- n>float16_t</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-> <c- n><c- n>type</c-></c-></i><c- p><c- p>;</c-></c-> <i><span style="font-family: times new roman"><c- c1><c- c1>// optional</c-></c-></span></i>
  <c- k><c- k>using</c-></c-> <c- n><c- n>float32_t</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-> <c- n><c- n>type</c-></c-></i><c- p><c- p>;</c-></c-> <i><span style="font-family: times new roman"><c- c1><c- c1>// optional</c-></c-></span></i>
  <c- k><c- k>using</c-></c-> <c- n><c- n>float64_t</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-> <c- n><c- n>type</c-></c-></i><c- p><c- p>;</c-></c-> <i><span style="font-family: times new roman"><c- c1><c- c1>// optional</c-></c-></span></i>
<c- p><c- p>}</c-></c->
</code></pre>
     <ins> 16.?.1.1 Exact-width floating-point types </ins>
     <ol>
      <li data-md>
       <ins>The typedef name <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>floatX_t</c-></code> designates a <em>floating-point type</em> with width X, no padding bits, and a representation
conforming to that defined as <code class="highlight"><c- n>binaryX</c-></code> format in ISO/IEC/IEEE 60559.</ins>
      <li data-md>
       <ins>These types are optional. However, if an implementation provides floating-point types with widths of 16, 32, or 64 bits,
no padding bits, and that have a representation conforming to that defined above, it shall define the corresponding
typedef names.</ins>
     </ol>
    </blockquote>
   </ins>
  </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-arm-hf">[ARM-HF]
   <dd><a href="http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0205j/CIHGAECI.html">Half-precision floating-point number support</a>. URL: <a href="http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0205j/CIHGAECI.html">http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0205j/CIHGAECI.html</a>
   <dt id="biblio-bfloat16">[BFLOAT16]
   <dd><a href="https://en.wikipedia.org/wiki/Bfloat16_floating-point_format">bfloat16 floating-point format</a>. URL: <a href="https://en.wikipedia.org/wiki/Bfloat16_floating-point_format">https://en.wikipedia.org/wiki/Bfloat16_floating-point_format</a>
   <dt id="biblio-cuda75">[CUDA7.5]
   <dd>Mark Harris. <a href="https://devblogs.nvidia.com/new-features-cuda-7-5/">New Features in CUDA 7.5</a>. URL: <a href="https://devblogs.nvidia.com/new-features-cuda-7-5/">https://devblogs.nvidia.com/new-features-cuda-7-5/</a>
   <dt id="biblio-dng">[DNG]
   <dd>Adobe. <a href="http://wwwimages.adobe.com/www.adobe.com/content/dam/acom/en/products/photoshop/pdfs/dng_spec_1.4.0.0.pdf">Digital Negative (DNG) Specification</a>. URL: <a href="http://wwwimages.adobe.com/www.adobe.com/content/dam/acom/en/products/photoshop/pdfs/dng_spec_1.4.0.0.pdf">http://wwwimages.adobe.com/www.adobe.com/content/dam/acom/en/products/photoshop/pdfs/dng_spec_1.4.0.0.pdf</a>
   <dt id="biblio-gccfp16">[GCCFP16]
   <dd><a href="https://gcc.gnu.org/onlinedocs/gcc/Half-Precision.html">Half-Precision Floating Point</a>. URL: <a href="https://gcc.gnu.org/onlinedocs/gcc/Half-Precision.html">https://gcc.gnu.org/onlinedocs/gcc/Half-Precision.html</a>
   <dt id="biblio-ieee-754-2008">[IEEE-754-2008]
   <dd><a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">IEEE Standard for Floating-Point Arithmetic</a>. 29 August 2008. URL: <a href="http://ieeexplore.ieee.org/servlet/opac?punumber=4610933">http://ieeexplore.ieee.org/servlet/opac?punumber=4610933</a>
   <dt id="biblio-intel-half-perf">[INTEL-HALF-PERF]
   <dd>Patrick Konsor. <a href="https://software.intel.com/en-us/articles/performance-benefits-of-half-precision-floats">Performance Benefits of Half Precision Floats</a>. URL: <a href="https://software.intel.com/en-us/articles/performance-benefits-of-half-precision-floats">https://software.intel.com/en-us/articles/performance-benefits-of-half-precision-floats</a>
   <dt id="biblio-llvmir">[LLVMIR]
   <dd><a href="http://releases.llvm.org/7.0.0/docs/LangRef.html#floating-point-types">LLVM Language Reference Manual</a>. URL: <a href="http://releases.llvm.org/7.0.0/docs/LangRef.html#floating-point-types">http://releases.llvm.org/7.0.0/docs/LangRef.html#floating-point-types</a>
   <dt id="biblio-openexr">[OpenEXR]
   <dd>Florian Kainz; Rob Bogart; Piotr Stanczyk. <a href="http://openexr.com/documentation/TechnicalIntroduction.pdf">Technical Introduction to OpenEXR</a>. URL: <a href="http://openexr.com/documentation/TechnicalIntroduction.pdf">http://openexr.com/documentation/TechnicalIntroduction.pdf</a>
   <dt id="biblio-opengl30">[OpenGL3.0]
   <dd>Khronos Group. <a href="https://www.khronos.org/registry/OpenGL/specs/gl/glspec30.pdf">The OpenGL (R) Graphics System: A Specification (Version 3.0 - September 23, 2008)</a>. URL: <a href="https://www.khronos.org/registry/OpenGL/specs/gl/glspec30.pdf">https://www.khronos.org/registry/OpenGL/specs/gl/glspec30.pdf</a>
   <dt id="biblio-p0192r1">[P0192R1]
   <dd>Boris Fomitchev; et al. <a href="https://wg21.link/P0192R1">Adding Fundamental Type for Short Float</a>. URL: <a href="https://wg21.link/P0192R1">https://wg21.link/P0192R1</a>
  </dl>
  <h2 class="no-num no-ref heading settled" id="issues-index"><span class="content">Issues Index</span><a class="self-link" href="#issues-index"></a></h2>
  <div style="counter-reset:issue">
   <div class="issue"> it is possible that instead of adding a new overload, the overloads could be folded into a single specified
function, the way that integer overloads of all of these are specified.<a href="#issue-e5bd59df"> ↵ </a></div>
   <div class="issue"> the definitions of the <code class="highlight"><c- n>sto</c-><c- o>*</c-></code> family depend on C functions in the <code class="highlight"><c- n>strto</c-><c- o>*</c-></code> family. Should an overload for <code class="highlight"><c- b>short</c-> <c- b>float</c-></code> be added?<a href="#issue-62214127"> ↵ </a></div>
  </div>