specs/2.2/html/OpenCL_Ext.html - external/github.com/KhronosGroup/OpenCL-Registry - Git at Google

 <!DOCTYPE html>
 <html lang="en">
 <head>
 <meta charset="UTF-8">
 <!--[if IE]><meta http-equiv="X-UA-Compatible" content="IE=edge"><![endif]-->
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <meta name="generator" content="Asciidoctor 1.5.6.1">
 <meta name="author" content="Khronos OpenCL Working Group">
 <title>The OpenCL Extension Specification</title>
 <style>
 /*! normalize.css v2.1.2 | MIT License | git.io/normalize */
 /* ========================================================================== HTML5 display definitions ========================================================================== */
 /** Correct `block` display not defined in IE 8/9. */
 article, aside, details, figcaption, figure, footer, header, hgroup, main, nav, section, summary { display: block; }

 /** Correct `inline-block` display not defined in IE 8/9. */
 audio, canvas, video { display: inline-block; }

 /** Prevent modern browsers from displaying `audio` without controls. Remove excess height in iOS 5 devices. */
 audio:not([controls]) { display: none; height: 0; }

 /** Address `[hidden]` styling not present in IE 8/9. Hide the `template` element in IE, Safari, and Firefox < 22. */
 [hidden], template { display: none; }

 script { display: none !important; }

 /* ========================================================================== Base ========================================================================== */
 /** 1. Set default font family to sans-serif. 2. Prevent iOS text size adjust after orientation change, without disabling user zoom. */
 html { font-family: sans-serif; /* 1 */ -ms-text-size-adjust: 100%; /* 2 */ -webkit-text-size-adjust: 100%; /* 2 */ }

 /** Remove default margin. */
 body { margin: 0; }

 /* ========================================================================== Links ========================================================================== */
 /** Remove the gray background color from active links in IE 10. */
 a { background: transparent; }

 /** Address `outline` inconsistency between Chrome and other browsers. */
 a:focus { outline: thin dotted; }

 /** Improve readability when focused and also mouse hovered in all browsers. */
 a:active, a:hover { outline: 0; }

 /* ========================================================================== Typography ========================================================================== */
 /** Address variable `h1` font-size and margin within `section` and `article` contexts in Firefox 4+, Safari 5, and Chrome. */
 h1 { font-size: 2em; margin: 0.67em 0; }

 /** Address styling not present in IE 8/9, Safari 5, and Chrome. */
 abbr[title] { border-bottom: 1px dotted; }

 /** Address style set to `bolder` in Firefox 4+, Safari 5, and Chrome. */
 b, strong { font-weight: bold; }

 /** Address styling not present in Safari 5 and Chrome. */
 dfn { font-style: italic; }

 /** Address differences between Firefox and other browsers. */
 hr { -moz-box-sizing: content-box; box-sizing: content-box; height: 0; }

 /** Address styling not present in IE 8/9. */
 mark { background: #ff0; color: #000; }

 /** Correct font family set oddly in Safari 5 and Chrome. */
 code, kbd, pre, samp { font-family: monospace, serif; font-size: 1em; }

 /** Improve readability of pre-formatted text in all browsers. */
 pre { white-space: pre-wrap; }

 /** Set consistent quote types. */
 q { quotes: "\201C" "\201D" "\2018" "\2019"; }

 /** Address inconsistent and variable font size in all browsers. */
 small { font-size: 80%; }

 /** Prevent `sub` and `sup` affecting `line-height` in all browsers. */
 sub, sup { font-size: 75%; line-height: 0; position: relative; vertical-align: baseline; }

 sup { top: -0.5em; }

 sub { bottom: -0.25em; }

 /* ========================================================================== Embedded content ========================================================================== */
 /** Remove border when inside `a` element in IE 8/9. */
 img { border: 0; }

 /** Correct overflow displayed oddly in IE 9. */
 svg:not(:root) { overflow: hidden; }

 /* ========================================================================== Figures ========================================================================== */
 /** Address margin not present in IE 8/9 and Safari 5. */
 figure { margin: 0; }

 /* ========================================================================== Forms ========================================================================== */
 /** Define consistent border, margin, and padding. */
 fieldset { border: 1px solid #c0c0c0; margin: 0 2px; padding: 0.35em 0.625em 0.75em; }

 /** 1. Correct `color` not being inherited in IE 8/9. 2. Remove padding so people aren't caught out if they zero out fieldsets. */
 legend { border: 0; /* 1 */ padding: 0; /* 2 */ }

 /** 1. Correct font family not being inherited in all browsers. 2. Correct font size not being inherited in all browsers. 3. Address margins set differently in Firefox 4+, Safari 5, and Chrome. */
 button, input, select, textarea { font-family: inherit; /* 1 */ font-size: 100%; /* 2 */ margin: 0; /* 3 */ }

 /** Address Firefox 4+ setting `line-height` on `input` using `!important` in the UA stylesheet. */
 button, input { line-height: normal; }

 /** Address inconsistent `text-transform` inheritance for `button` and `select`. All other form control elements do not inherit `text-transform` values. Correct `button` style inheritance in Chrome, Safari 5+, and IE 8+. Correct `select` style inheritance in Firefox 4+ and Opera. */
 button, select { text-transform: none; }

 /** 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio` and `video` controls. 2. Correct inability to style clickable `input` types in iOS. 3. Improve usability and consistency of cursor style between image-type `input` and others. */
 button, html input[type="button"], input[type="reset"], input[type="submit"] { -webkit-appearance: button; /* 2 */ cursor: pointer; /* 3 */ }

 /** Re-set default cursor for disabled elements. */
 button[disabled], html input[disabled] { cursor: default; }

 /** 1. Address box sizing set to `content-box` in IE 8/9. 2. Remove excess padding in IE 8/9. */
 input[type="checkbox"], input[type="radio"] { box-sizing: border-box; /* 1 */ padding: 0; /* 2 */ }

 /** 1. Address `appearance` set to `searchfield` in Safari 5 and Chrome. 2. Address `box-sizing` set to `border-box` in Safari 5 and Chrome (include `-moz` to future-proof). */
 input[type="search"] { -webkit-appearance: textfield; /* 1 */ -moz-box-sizing: content-box; -webkit-box-sizing: content-box; /* 2 */ box-sizing: content-box; }

 /** Remove inner padding and search cancel button in Safari 5 and Chrome on OS X. */
 input[type="search"]::-webkit-search-cancel-button, input[type="search"]::-webkit-search-decoration { -webkit-appearance: none; }

 /** Remove inner padding and border in Firefox 4+. */
 button::-moz-focus-inner, input::-moz-focus-inner { border: 0; padding: 0; }

 /** 1. Remove default vertical scrollbar in IE 8/9. 2. Improve readability and alignment in all browsers. */
 textarea { overflow: auto; /* 1 */ vertical-align: top; /* 2 */ }

 /* ========================================================================== Tables ========================================================================== */
 /** Remove most spacing between table cells. */
 table { border-collapse: collapse; border-spacing: 0; }

 meta.foundation-mq-small { font-family: "only screen and (min-width: 768px)"; width: 768px; }

 meta.foundation-mq-medium { font-family: "only screen and (min-width:1280px)"; width: 1280px; }

 meta.foundation-mq-large { font-family: "only screen and (min-width:1440px)"; width: 1440px; }

 *, *:before, *:after { -moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing: border-box; }

 html, body { font-size: 100%; }

 body { background: white; color: #222222; padding: 0; margin: 0; font-family: "Helvetica Neue", "Helvetica", Helvetica, Arial, sans-serif; font-weight: normal; font-style: normal; line-height: 1; position: relative; cursor: auto; }

 a:hover { cursor: pointer; }

 img, object, embed { max-width: 100%; height: auto; }

 object, embed { height: 100%; }

 img { -ms-interpolation-mode: bicubic; }

 #map_canvas img, #map_canvas embed, #map_canvas object, .map_canvas img, .map_canvas embed, .map_canvas object { max-width: none !important; }

 .left { float: left !important; }

 .right { float: right !important; }

 .text-left { text-align: left !important; }

 .text-right { text-align: right !important; }

 .text-center { text-align: center !important; }

 .text-justify { text-align: justify !important; }

 .hide { display: none; }

 .antialiased { -webkit-font-smoothing: antialiased; }

 img { display: inline-block; vertical-align: middle; }

 textarea { height: auto; min-height: 50px; }

 select { width: 100%; }

 object, svg { display: inline-block; vertical-align: middle; }

 .center { margin-left: auto; margin-right: auto; }

 .spread { width: 100%; }

 p.lead, .paragraph.lead > p, #preamble > .sectionbody > .paragraph:first-of-type p { font-size: 1.21875em; line-height: 1.6; }

 .subheader, .admonitionblock td.content > .title, .audioblock > .title, .exampleblock > .title, .imageblock > .title, .listingblock > .title, .literalblock > .title, .stemblock > .title, .openblock > .title, .paragraph > .title, .quoteblock > .title, table.tableblock > .title, .verseblock > .title, .videoblock > .title, .dlist > .title, .olist > .title, .ulist > .title, .qlist > .title, .hdlist > .title { line-height: 1.4; color: black; font-weight: 300; margin-top: 0.2em; margin-bottom: 0.5em; }

 /* Typography resets */
 div, dl, dt, dd, ul, ol, li, h1, h2, h3, #toctitle, .sidebarblock > .content > .title, h4, h5, h6, pre, form, p, blockquote, th, td { margin: 0; padding: 0; direction: ltr; }

 /* Default Link Styles */
 a { color: #0068b0; text-decoration: none; line-height: inherit; }
 a:hover, a:focus { color: #333333; }
 a img { border: none; }

 /* Default paragraph styles */
 p { font-family: Noto, sans-serif; font-weight: normal; font-size: 1em; line-height: 1.6; margin-bottom: 0.75em; text-rendering: optimizeLegibility; }
 p aside { font-size: 0.875em; line-height: 1.35; font-style: italic; }

 /* Default header styles */
 h1, h2, h3, #toctitle, .sidebarblock > .content > .title, h4, h5, h6 { font-family: Noto, sans-serif; font-weight: normal; font-style: normal; color: black; text-rendering: optimizeLegibility; margin-top: 0.5em; margin-bottom: 0.5em; line-height: 1.2125em; }
 h1 small, h2 small, h3 small, #toctitle small, .sidebarblock > .content > .title small, h4 small, h5 small, h6 small { font-size: 60%; color: #4d4d4d; line-height: 0; }

 h1 { font-size: 2.125em; }

 h2 { font-size: 1.6875em; }

 h3, #toctitle, .sidebarblock > .content > .title { font-size: 1.375em; }

 h4 { font-size: 1.125em; }

 h5 { font-size: 1.125em; }

 h6 { font-size: 1em; }

 hr { border: solid #dddddd; border-width: 1px 0 0; clear: both; margin: 1.25em 0 1.1875em; height: 0; }

 /* Helpful Typography Defaults */
 em, i { font-style: italic; line-height: inherit; }

 strong, b { font-weight: bold; line-height: inherit; }

 small { font-size: 60%; line-height: inherit; }

 code { font-family: Consolas, "Liberation Mono", Courier, monospace; font-weight: normal; color: #264357; }

 /* Lists */
 ul, ol, dl { font-size: 1em; line-height: 1.6; margin-bottom: 0.75em; list-style-position: outside; font-family: Noto, sans-serif; }

 ul, ol { margin-left: 1.5em; }
 ul.no-bullet, ol.no-bullet { margin-left: 1.5em; }

 /* Unordered Lists */
 ul li ul, ul li ol { margin-left: 1.25em; margin-bottom: 0; font-size: 1em; /* Override nested font-size change */ }
 ul.square li ul, ul.circle li ul, ul.disc li ul { list-style: inherit; }
 ul.square { list-style-type: square; }
 ul.circle { list-style-type: circle; }
 ul.disc { list-style-type: disc; }
 ul.no-bullet { list-style: none; }

 /* Ordered Lists */
 ol li ul, ol li ol { margin-left: 1.25em; margin-bottom: 0; }

 /* Definition Lists */
 dl dt { margin-bottom: 0.3em; font-weight: bold; }
 dl dd { margin-bottom: 0.75em; }

 /* Abbreviations */
 abbr, acronym { text-transform: uppercase; font-size: 90%; color: black; border-bottom: 1px dotted #dddddd; cursor: help; }

 abbr { text-transform: none; }

 /* Blockquotes */
 blockquote { margin: 0 0 0.75em; padding: 0.5625em 1.25em 0 1.1875em; border-left: 1px solid #dddddd; }
 blockquote cite { display: block; font-size: 0.8125em; color: #5e93b8; }
 blockquote cite:before { content: "\2014 \0020"; }
 blockquote cite a, blockquote cite a:visited { color: #5e93b8; }

 blockquote, blockquote p { line-height: 1.6; color: #333333; }

 /* Microformats */
 .vcard { display: inline-block; margin: 0 0 1.25em 0; border: 1px solid #dddddd; padding: 0.625em 0.75em; }
 .vcard li { margin: 0; display: block; }
 .vcard .fn { font-weight: bold; font-size: 0.9375em; }

 .vevent .summary { font-weight: bold; }
 .vevent abbr { cursor: auto; text-decoration: none; font-weight: bold; border: none; padding: 0 0.0625em; }

 @media only screen and (min-width: 768px) { h1, h2, h3, #toctitle, .sidebarblock > .content > .title, h4, h5, h6 { line-height: 1.4; }
   h1 { font-size: 2.75em; }
   h2 { font-size: 2.3125em; }
   h3, #toctitle, .sidebarblock > .content > .title { font-size: 1.6875em; }
   h4 { font-size: 1.4375em; } }
 /* Tables */
 table { background: white; margin-bottom: 1.25em; border: solid 1px #d8d8ce; }
 table thead, table tfoot { background: -webkit-linear-gradient(top, #add386, #90b66a); font-weight: bold; }
 table thead tr th, table thead tr td, table tfoot tr th, table tfoot tr td { padding: 0.5em 0.625em 0.625em; font-size: inherit; color: white; text-align: left; }
 table tr th, table tr td { padding: 0.5625em 0.625em; font-size: inherit; color: #6d6e71; }
 table tr.even, table tr.alt, table tr:nth-of-type(even) { background: #edf2f2; }
 table thead tr th, table tfoot tr th, table tbody tr td, table tr td, table tfoot tr td { display: table-cell; line-height: 1.4; }

 body { -moz-osx-font-smoothing: grayscale; -webkit-font-smoothing: antialiased; tab-size: 4; }

 h1, h2, h3, #toctitle, .sidebarblock > .content > .title, h4, h5, h6 { line-height: 1.4; }

 a:hover, a:focus { text-decoration: underline; }

 .clearfix:before, .clearfix:after, .float-group:before, .float-group:after { content: " "; display: table; }
 .clearfix:after, .float-group:after { clear: both; }

 *:not(pre) > code { font-size: inherit; font-style: normal !important; letter-spacing: 0; padding: 0; background-color: white; -webkit-border-radius: 0; border-radius: 0; line-height: inherit; word-wrap: break-word; }
 *:not(pre) > code.nobreak { word-wrap: normal; }
 *:not(pre) > code.nowrap { white-space: nowrap; }

 pre, pre > code { line-height: 1.6; color: #264357; font-family: Consolas, "Liberation Mono", Courier, monospace; font-weight: normal; }

 em em { font-style: normal; }

 strong strong { font-weight: normal; }

 .keyseq { color: #333333; }

 kbd { font-family: Consolas, "Liberation Mono", Courier, monospace; display: inline-block; color: black; font-size: 0.65em; line-height: 1.45; background-color: #f7f7f7; border: 1px solid #ccc; -webkit-border-radius: 3px; border-radius: 3px; -webkit-box-shadow: 0 1px 0 rgba(0, 0, 0, 0.2), 0 0 0 0.1em white inset; box-shadow: 0 1px 0 rgba(0, 0, 0, 0.2), 0 0 0 0.1em white inset; margin: 0 0.15em; padding: 0.2em 0.5em; vertical-align: middle; position: relative; top: -0.1em; white-space: nowrap; }

 .keyseq kbd:first-child { margin-left: 0; }

 .keyseq kbd:last-child { margin-right: 0; }

 .menuseq, .menuref { color: #000; }

 .menuseq b:not(.caret), .menuref { font-weight: inherit; }

 .menuseq { word-spacing: -0.02em; }
 .menuseq b.caret { font-size: 1.25em; line-height: 0.8; }
 .menuseq i.caret { font-weight: bold; text-align: center; width: 0.45em; }

 b.button:before, b.button:after { position: relative; top: -1px; font-weight: normal; }

 b.button:before { content: "["; padding: 0 3px 0 2px; }

 b.button:after { content: "]"; padding: 0 2px 0 3px; }

 #header, #content, #footnotes, #footer { width: 100%; margin-left: auto; margin-right: auto; margin-top: 0; margin-bottom: 0; max-width: 62.5em; *zoom: 1; position: relative; padding-left: 1.5em; padding-right: 1.5em; }
 #header:before, #header:after, #content:before, #content:after, #footnotes:before, #footnotes:after, #footer:before, #footer:after { content: " "; display: table; }
 #header:after, #content:after, #footnotes:after, #footer:after { clear: both; }

 #content { margin-top: 1.25em; }

 #content:before { content: none; }

 #header > h1:first-child { color: black; margin-top: 2.25rem; margin-bottom: 0; }
 #header > h1:first-child + #toc { margin-top: 8px; border-top: 1px solid #dddddd; }
 #header > h1:only-child, body.toc2 #header > h1:nth-last-child(2) { border-bottom: 1px solid #dddddd; padding-bottom: 8px; }
 #header .details { border-bottom: 1px solid #dddddd; line-height: 1.45; padding-top: 0.25em; padding-bottom: 0.25em; padding-left: 0.25em; color: #5e93b8; display: -ms-flexbox; display: -webkit-flex; display: flex; -ms-flex-flow: row wrap; -webkit-flex-flow: row wrap; flex-flow: row wrap; }
 #header .details span:first-child { margin-left: -0.125em; }
 #header .details span.email a { color: #333333; }
 #header .details br { display: none; }
 #header .details br + span:before { content: "\00a0\2013\00a0"; }
 #header .details br + span.author:before { content: "\00a0\22c5\00a0"; color: #333333; }
 #header .details br + span#revremark:before { content: "\00a0|\00a0"; }
 #header #revnumber { text-transform: capitalize; }
 #header #revnumber:after { content: "\00a0"; }

 #content > h1:first-child:not([class]) { color: black; border-bottom: 1px solid #dddddd; padding-bottom: 8px; margin-top: 0; padding-top: 1rem; margin-bottom: 1.25rem; }

 #toc { border-bottom: 0 solid #dddddd; padding-bottom: 0.5em; }
 #toc > ul { margin-left: 0.125em; }
 #toc ul.sectlevel0 > li > a { font-style: italic; }
 #toc ul.sectlevel0 ul.sectlevel1 { margin: 0.5em 0; }
 #toc ul { font-family: Noto, sans-serif; list-style-type: none; }
 #toc li { line-height: 1.3334; margin-top: 0.3334em; }
 #toc a { text-decoration: none; }
 #toc a:active { text-decoration: underline; }

 #toctitle { color: black; font-size: 1.2em; }

 @media only screen and (min-width: 768px) { #toctitle { font-size: 1.375em; }
   body.toc2 { padding-left: 15em; padding-right: 0; }
   #toc.toc2 { margin-top: 0 !important; background-color: white; position: fixed; width: 15em; left: 0; top: 0; border-right: 1px solid #dddddd; border-top-width: 0 !important; border-bottom-width: 0 !important; z-index: 1000; padding: 1.25em 1em; height: 100%; overflow: auto; }
   #toc.toc2 #toctitle { margin-top: 0; margin-bottom: 0.8rem; font-size: 1.2em; }
   #toc.toc2 > ul { font-size: 0.9em; margin-bottom: 0; }
   #toc.toc2 ul ul { margin-left: 0; padding-left: 1em; }
   #toc.toc2 ul.sectlevel0 ul.sectlevel1 { padding-left: 0; margin-top: 0.5em; margin-bottom: 0.5em; }
   body.toc2.toc-right { padding-left: 0; padding-right: 15em; }
   body.toc2.toc-right #toc.toc2 { border-right-width: 0; border-left: 1px solid #dddddd; left: auto; right: 0; } }
 @media only screen and (min-width: 1280px) { body.toc2 { padding-left: 20em; padding-right: 0; }
   #toc.toc2 { width: 20em; }
   #toc.toc2 #toctitle { font-size: 1.375em; }
   #toc.toc2 > ul { font-size: 0.95em; }
   #toc.toc2 ul ul { padding-left: 1.25em; }
   body.toc2.toc-right { padding-left: 0; padding-right: 20em; } }
 #content #toc { border-style: solid; border-width: 1px; border-color: #e6e6e6; margin-bottom: 1.25em; padding: 1.25em; background: white; -webkit-border-radius: 0; border-radius: 0; }
 #content #toc > :first-child { margin-top: 0; }
 #content #toc > :last-child { margin-bottom: 0; }

 #footer { max-width: 100%; background-color: none; padding: 1.25em; }

 #footer-text { color: black; line-height: 1.44; }

 #content { margin-bottom: 0.625em; }

 .sect1 { padding-bottom: 0.625em; }

 @media only screen and (min-width: 768px) { #content { margin-bottom: 1.25em; }
   .sect1 { padding-bottom: 1.25em; } }
 .sect1:last-child { padding-bottom: 0; }

 .sect1 + .sect1 { border-top: 0 solid #dddddd; }

 #content h1 > a.anchor, h2 > a.anchor, h3 > a.anchor, #toctitle > a.anchor, .sidebarblock > .content > .title > a.anchor, h4 > a.anchor, h5 > a.anchor, h6 > a.anchor { position: absolute; z-index: 1001; width: 1.5ex; margin-left: -1.5ex; display: block; text-decoration: none !important; visibility: hidden; text-align: center; font-weight: normal; }
 #content h1 > a.anchor:before, h2 > a.anchor:before, h3 > a.anchor:before, #toctitle > a.anchor:before, .sidebarblock > .content > .title > a.anchor:before, h4 > a.anchor:before, h5 > a.anchor:before, h6 > a.anchor:before { content: "\00A7"; font-size: 0.85em; display: block; padding-top: 0.1em; }
 #content h1:hover > a.anchor, #content h1 > a.anchor:hover, h2:hover > a.anchor, h2 > a.anchor:hover, h3:hover > a.anchor, #toctitle:hover > a.anchor, .sidebarblock > .content > .title:hover > a.anchor, h3 > a.anchor:hover, #toctitle > a.anchor:hover, .sidebarblock > .content > .title > a.anchor:hover, h4:hover > a.anchor, h4 > a.anchor:hover, h5:hover > a.anchor, h5 > a.anchor:hover, h6:hover > a.anchor, h6 > a.anchor:hover { visibility: visible; }
 #content h1 > a.link, h2 > a.link, h3 > a.link, #toctitle > a.link, .sidebarblock > .content > .title > a.link, h4 > a.link, h5 > a.link, h6 > a.link { color: black; text-decoration: none; }
 #content h1 > a.link:hover, h2 > a.link:hover, h3 > a.link:hover, #toctitle > a.link:hover, .sidebarblock > .content > .title > a.link:hover, h4 > a.link:hover, h5 > a.link:hover, h6 > a.link:hover { color: black; }

 .audioblock, .imageblock, .literalblock, .listingblock, .stemblock, .videoblock { margin-bottom: 1.25em; }

 .admonitionblock td.content > .title, .audioblock > .title, .exampleblock > .title, .imageblock > .title, .listingblock > .title, .literalblock > .title, .stemblock > .title, .openblock > .title, .paragraph > .title, .quoteblock > .title, table.tableblock > .title, .verseblock > .title, .videoblock > .title, .dlist > .title, .olist > .title, .ulist > .title, .qlist > .title, .hdlist > .title { text-rendering: optimizeLegibility; text-align: left; }

 table.tableblock > caption.title { white-space: nowrap; overflow: visible; max-width: 0; }

 .paragraph.lead > p, #preamble > .sectionbody > .paragraph:first-of-type p { color: black; }

 table.tableblock #preamble > .sectionbody > .paragraph:first-of-type p { font-size: inherit; }

 .admonitionblock > table { border-collapse: separate; border: 0; background: none; width: 100%; }
 .admonitionblock > table td.icon { text-align: center; width: 80px; }
 .admonitionblock > table td.icon img { max-width: initial; }
 .admonitionblock > table td.icon .title { font-weight: bold; font-family: Noto, sans-serif; text-transform: uppercase; }
 .admonitionblock > table td.content { padding-left: 1.125em; padding-right: 1.25em; border-left: 1px solid #dddddd; color: #5e93b8; }
 .admonitionblock > table td.content > :last-child > :last-child { margin-bottom: 0; }

 .exampleblock > .content { border-style: solid; border-width: 1px; border-color: #e6e6e6; margin-bottom: 1.25em; padding: 1.25em; background: white; -webkit-border-radius: 0; border-radius: 0; }
 .exampleblock > .content > :first-child { margin-top: 0; }
 .exampleblock > .content > :last-child { margin-bottom: 0; }

 .sidebarblock { border-style: solid; border-width: 1px; border-color: #e6e6e6; margin-bottom: 1.25em; padding: 1.25em; background: white; -webkit-border-radius: 0; border-radius: 0; }
 .sidebarblock > :first-child { margin-top: 0; }
 .sidebarblock > :last-child { margin-bottom: 0; }
 .sidebarblock > .content > .title { color: black; margin-top: 0; }

 .exampleblock > .content > :last-child > :last-child, .exampleblock > .content .olist > ol > li:last-child > :last-child, .exampleblock > .content .ulist > ul > li:last-child > :last-child, .exampleblock > .content .qlist > ol > li:last-child > :last-child, .sidebarblock > .content > :last-child > :last-child, .sidebarblock > .content .olist > ol > li:last-child > :last-child, .sidebarblock > .content .ulist > ul > li:last-child > :last-child, .sidebarblock > .content .qlist > ol > li:last-child > :last-child { margin-bottom: 0; }

 .literalblock pre, .listingblock pre:not(.highlight), .listingblock pre[class="highlight"], .listingblock pre[class^="highlight "], .listingblock pre.CodeRay, .listingblock pre.prettyprint { background: #eeeeee; }
 .sidebarblock .literalblock pre, .sidebarblock .listingblock pre:not(.highlight), .sidebarblock .listingblock pre[class="highlight"], .sidebarblock .listingblock pre[class^="highlight "], .sidebarblock .listingblock pre.CodeRay, .sidebarblock .listingblock pre.prettyprint { background: #f2f1f1; }

 .literalblock pre, .literalblock pre[class], .listingblock pre, .listingblock pre[class] { border: 1px hidden #666666; -webkit-border-radius: 0; border-radius: 0; word-wrap: break-word; padding: 1.25em 1.5625em 1.125em 1.5625em; font-size: 0.8125em; }
 .literalblock pre.nowrap, .literalblock pre[class].nowrap, .listingblock pre.nowrap, .listingblock pre[class].nowrap { overflow-x: auto; white-space: pre; word-wrap: normal; }
 @media only screen and (min-width: 768px) { .literalblock pre, .literalblock pre[class], .listingblock pre, .listingblock pre[class] { font-size: 0.90625em; } }
 @media only screen and (min-width: 1280px) { .literalblock pre, .literalblock pre[class], .listingblock pre, .listingblock pre[class] { font-size: 1em; } }

 .literalblock.output pre { color: #eeeeee; background-color: #264357; }

 .listingblock pre.highlightjs { padding: 0; }
 .listingblock pre.highlightjs > code { padding: 1.25em 1.5625em 1.125em 1.5625em; -webkit-border-radius: 0; border-radius: 0; }

 .listingblock > .content { position: relative; }

 .listingblock code[data-lang]:before { display: none; content: attr(data-lang); position: absolute; font-size: 0.75em; top: 0.425rem; right: 0.5rem; line-height: 1; text-transform: uppercase; color: #999; }

 .listingblock:hover code[data-lang]:before { display: block; }

 .listingblock.terminal pre .command:before { content: attr(data-prompt); padding-right: 0.5em; color: #999; }

 .listingblock.terminal pre .command:not([data-prompt]):before { content: "$"; }

 table.pyhltable { border-collapse: separate; border: 0; margin-bottom: 0; background: none; }

 table.pyhltable td { vertical-align: top; padding-top: 0; padding-bottom: 0; line-height: 1.6; }

 table.pyhltable td.code { padding-left: .75em; padding-right: 0; }

 pre.pygments .lineno, table.pyhltable td:not(.code) { color: #999; padding-left: 0; padding-right: .5em; border-right: 1px solid #dddddd; }

 pre.pygments .lineno { display: inline-block; margin-right: .25em; }

 table.pyhltable .linenodiv { background: none !important; padding-right: 0 !important; }

 .quoteblock { margin: 0 1em 0.75em 1.5em; display: table; }
 .quoteblock > .title { margin-left: -1.5em; margin-bottom: 0.75em; }
 .quoteblock blockquote, .quoteblock blockquote p { color: #333333; font-size: 1.15rem; line-height: 1.75; word-spacing: 0.1em; letter-spacing: 0; font-style: italic; text-align: justify; }
 .quoteblock blockquote { margin: 0; padding: 0; border: 0; }
 .quoteblock blockquote:before { content: "\201c"; float: left; font-size: 2.75em; font-weight: bold; line-height: 0.6em; margin-left: -0.6em; color: black; text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1); }
 .quoteblock blockquote > .paragraph:last-child p { margin-bottom: 0; }
 .quoteblock .attribution { margin-top: 0.5em; margin-right: 0.5ex; text-align: right; }
 .quoteblock .quoteblock { margin-left: 0; margin-right: 0; padding: 0.5em 0; border-left: 3px solid #5e93b8; }
 .quoteblock .quoteblock blockquote { padding: 0 0 0 0.75em; }
 .quoteblock .quoteblock blockquote:before { display: none; }

 .verseblock { margin: 0 1em 0.75em 1em; }
 .verseblock pre { font-family: "Open Sans", "DejaVu Sans", sans; font-size: 1.15rem; color: #333333; font-weight: 300; text-rendering: optimizeLegibility; }
 .verseblock pre strong { font-weight: 400; }
 .verseblock .attribution { margin-top: 1.25rem; margin-left: 0.5ex; }

 .quoteblock .attribution, .verseblock .attribution { font-size: 0.8125em; line-height: 1.45; font-style: italic; }
 .quoteblock .attribution br, .verseblock .attribution br { display: none; }
 .quoteblock .attribution cite, .verseblock .attribution cite { display: block; letter-spacing: -0.025em; color: #5e93b8; }

 .quoteblock.abstract { margin: 0 0 0.75em 0; display: block; }
 .quoteblock.abstract blockquote, .quoteblock.abstract blockquote p { text-align: left; word-spacing: 0; }
 .quoteblock.abstract blockquote:before, .quoteblock.abstract blockquote p:first-of-type:before { display: none; }

 table.tableblock { max-width: 100%; border-collapse: separate; }
 table.tableblock td > .paragraph:last-child p > p:last-child, table.tableblock th > p:last-child, table.tableblock td > p:last-child { margin-bottom: 0; }

 table.tableblock, th.tableblock, td.tableblock { border: 0 solid #d8d8ce; }

 table.grid-all > thead > tr > .tableblock, table.grid-all > tbody > tr > .tableblock { border-width: 0 1px 1px 0; }

 table.grid-all > tfoot > tr > .tableblock { border-width: 1px 1px 0 0; }

 table.grid-cols > * > tr > .tableblock { border-width: 0 1px 0 0; }

 table.grid-rows > thead > tr > .tableblock, table.grid-rows > tbody > tr > .tableblock { border-width: 0 0 1px 0; }

 table.grid-rows > tfoot > tr > .tableblock { border-width: 1px 0 0 0; }

 table.grid-all > * > tr > .tableblock:last-child, table.grid-cols > * > tr > .tableblock:last-child { border-right-width: 0; }

 table.grid-all > tbody > tr:last-child > .tableblock, table.grid-all > thead:last-child > tr > .tableblock, table.grid-rows > tbody > tr:last-child > .tableblock, table.grid-rows > thead:last-child > tr > .tableblock { border-bottom-width: 0; }

 table.frame-all { border-width: 1px; }

 table.frame-sides { border-width: 0 1px; }

 table.frame-topbot { border-width: 1px 0; }

 th.halign-left, td.halign-left { text-align: left; }

 th.halign-right, td.halign-right { text-align: right; }

 th.halign-center, td.halign-center { text-align: center; }

 th.valign-top, td.valign-top { vertical-align: top; }

 th.valign-bottom, td.valign-bottom { vertical-align: bottom; }

 th.valign-middle, td.valign-middle { vertical-align: middle; }

 table thead th, table tfoot th { font-weight: bold; }

 tbody tr th { display: table-cell; line-height: 1.4; background: -webkit-linear-gradient(top, #add386, #90b66a); }

 tbody tr th, tbody tr th p, tfoot tr th, tfoot tr th p { color: white; font-weight: bold; }

 p.tableblock > code:only-child { background: none; padding: 0; }

 p.tableblock { font-size: 1em; }

 td > div.verse { white-space: pre; }

 ol { margin-left: 1.75em; }

 ul li ol { margin-left: 1.5em; }

 dl dd { margin-left: 1.125em; }

 dl dd:last-child, dl dd:last-child > :last-child { margin-bottom: 0; }

 ol > li p, ul > li p, ul dd, ol dd, .olist .olist, .ulist .ulist, .ulist .olist, .olist .ulist { margin-bottom: 0.375em; }

 ul.checklist, ul.none, ol.none, ul.no-bullet, ol.no-bullet, ol.unnumbered, ul.unstyled, ol.unstyled { list-style-type: none; }

 ul.no-bullet, ol.no-bullet, ol.unnumbered { margin-left: 0.625em; }

 ul.unstyled, ol.unstyled { margin-left: 0; }

 ul.checklist { margin-left: 0.625em; }

 ul.checklist li > p:first-child > .fa-square-o:first-child, ul.checklist li > p:first-child > .fa-check-square-o:first-child { width: 1.25em; font-size: 0.8em; position: relative; bottom: 0.125em; }

 ul.checklist li > p:first-child > input[type="checkbox"]:first-child { margin-right: 0.25em; }

 ul.inline { display: -ms-flexbox; display: -webkit-box; display: flex; -ms-flex-flow: row wrap; -webkit-flex-flow: row wrap; flex-flow: row wrap; list-style: none; margin: 0 0 0.375em -0.75em; }

 ul.inline > li { margin-left: 0.75em; }

 .unstyled dl dt { font-weight: normal; font-style: normal; }

 ol.arabic { list-style-type: decimal; }

 ol.decimal { list-style-type: decimal-leading-zero; }

 ol.loweralpha { list-style-type: lower-alpha; }

 ol.upperalpha { list-style-type: upper-alpha; }

 ol.lowerroman { list-style-type: lower-roman; }

 ol.upperroman { list-style-type: upper-roman; }

 ol.lowergreek { list-style-type: lower-greek; }

 .hdlist > table, .colist > table { border: 0; background: none; }
 .hdlist > table > tbody > tr, .colist > table > tbody > tr { background: none; }

 td.hdlist1, td.hdlist2 { vertical-align: top; padding: 0 0.625em; }

 td.hdlist1 { font-weight: bold; padding-bottom: 0.75em; }

 .literalblock + .colist, .listingblock + .colist { margin-top: -0.5em; }

 .colist > table tr > td:first-of-type { padding: 0.4em 0.75em 0 0.75em; line-height: 1; vertical-align: top; }
 .colist > table tr > td:first-of-type img { max-width: initial; }
 .colist > table tr > td:last-of-type { padding: 0.25em 0; }

 .thumb, .th { line-height: 0; display: inline-block; border: solid 4px white; -webkit-box-shadow: 0 0 0 1px #dddddd; box-shadow: 0 0 0 1px #dddddd; }

 .imageblock.left, .imageblock[style*="float: left"] { margin: 0.25em 0.625em 1.25em 0; }
 .imageblock.right, .imageblock[style*="float: right"] { margin: 0.25em 0 1.25em 0.625em; }
 .imageblock > .title { margin-bottom: 0; }
 .imageblock.thumb, .imageblock.th { border-width: 6px; }
 .imageblock.thumb > .title, .imageblock.th > .title { padding: 0 0.125em; }

 .image.left, .image.right { margin-top: 0.25em; margin-bottom: 0.25em; display: inline-block; line-height: 0; }
 .image.left { margin-right: 0.625em; }
 .image.right { margin-left: 0.625em; }

 a.image { text-decoration: none; display: inline-block; }
 a.image object { pointer-events: none; }

 sup.footnote, sup.footnoteref { font-size: 0.875em; position: static; vertical-align: super; }
 sup.footnote a, sup.footnoteref a { text-decoration: none; }
 sup.footnote a:active, sup.footnoteref a:active { text-decoration: underline; }

 #footnotes { padding-top: 0.75em; padding-bottom: 0.75em; margin-bottom: 0.625em; }
 #footnotes hr { width: 20%; min-width: 6.25em; margin: -0.25em 0 0.75em 0; border-width: 1px 0 0 0; }
 #footnotes .footnote { padding: 0 0.375em 0 0.225em; line-height: 1.3334; font-size: 0.875em; margin-left: 1.2em; margin-bottom: 0.2em; }
 #footnotes .footnote a:first-of-type { font-weight: bold; text-decoration: none; margin-left: -1.05em; }
 #footnotes .footnote:last-of-type { margin-bottom: 0; }
 #content #footnotes { margin-top: -0.625em; margin-bottom: 0; padding: 0.75em 0; }

 .gist .file-data > table { border: 0; background: #fff; width: 100%; margin-bottom: 0; }
 .gist .file-data > table td.line-data { width: 99%; }

 div.unbreakable { page-break-inside: avoid; }

 .big { font-size: larger; }

 .small { font-size: smaller; }

 .underline { text-decoration: underline; }

 .overline { text-decoration: overline; }

 .line-through { text-decoration: line-through; }

 .aqua { color: #00bfbf; }

 .aqua-background { background-color: #00fafa; }

 .black { color: black; }

 .black-background { background-color: black; }

 .blue { color: #0000bf; }

 .blue-background { background-color: #0000fa; }

 .fuchsia { color: #bf00bf; }

 .fuchsia-background { background-color: #fa00fa; }

 .gray { color: #606060; }

 .gray-background { background-color: #7d7d7d; }

 .green { color: #006000; }

 .green-background { background-color: #007d00; }

 .lime { color: #00bf00; }

 .lime-background { background-color: #00fa00; }

 .maroon { color: #600000; }

 .maroon-background { background-color: #7d0000; }

 .navy { color: #000060; }

 .navy-background { background-color: #00007d; }

 .olive { color: #606000; }

 .olive-background { background-color: #7d7d00; }

 .purple { color: #600060; }

 .purple-background { background-color: #7d007d; }

 .red { color: #bf0000; }

 .red-background { background-color: #fa0000; }

 .silver { color: #909090; }

 .silver-background { background-color: #bcbcbc; }

 .teal { color: #006060; }

 .teal-background { background-color: #007d7d; }

 .white { color: #bfbfbf; }

 .white-background { background-color: #fafafa; }

 .yellow { color: #bfbf00; }

 .yellow-background { background-color: #fafa00; }

 span.icon > .fa { cursor: default; }
 a span.icon > .fa { cursor: inherit; }

 .admonitionblock td.icon [class^="fa icon-"] { font-size: 2.5em; text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.5); cursor: default; }
 .admonitionblock td.icon .icon-note:before { content: "\f05a"; color: #29475c; }
 .admonitionblock td.icon .icon-tip:before { content: "\f0eb"; text-shadow: 1px 1px 2px rgba(155, 155, 0, 0.8); color: #111; }
 .admonitionblock td.icon .icon-warning:before { content: "\f071"; color: #bf6900; }
 .admonitionblock td.icon .icon-caution:before { content: "\f06d"; color: #bf3400; }
 .admonitionblock td.icon .icon-important:before { content: "\f06a"; color: #bf0000; }

 .conum[data-value] { display: inline-block; color: #fff !important; background-color: black; -webkit-border-radius: 100px; border-radius: 100px; text-align: center; font-size: 0.75em; width: 1.67em; height: 1.67em; line-height: 1.67em; font-family: "Open Sans", "DejaVu Sans", sans-serif; font-style: normal; font-weight: bold; }
 .conum[data-value] * { color: #fff !important; }
 .conum[data-value] + b { display: none; }
 .conum[data-value]:after { content: attr(data-value); }
 pre .conum[data-value] { position: relative; top: -0.125em; }

 b.conum * { color: inherit !important; }

 .conum:not([data-value]):empty { display: none; }

 h1, h2, h3, #toctitle, .sidebarblock > .content > .title, h4, h5, h6 { border-bottom: 1px solid #dddddd; }

 .sect1 { padding-bottom: 0; }

 #toctitle { color: #00406F; font-weight: normal; margin-top: 1.5em; }

 .sidebarblock { border-color: #aaa; }

 code { -webkit-border-radius: 4px; border-radius: 4px; }

 p.tableblock.header { color: #6d6e71; }

 .literalblock pre, .listingblock pre { background: #eeeeee; }

 </style>
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.6.3/css/font-awesome.min.css">
 <style>
 /* Stylesheet for CodeRay to match GitHub theme | MIT License | http://foundation.zurb.com */
 /*pre.CodeRay {background-color:#f7f7f8;}*/
 .CodeRay .line-numbers{border-right:1px solid #d8d8d8;padding:0 0.5em 0 .25em}
 .CodeRay span.line-numbers{display:inline-block;margin-right:.5em;color:rgba(0,0,0,.3)}
 .CodeRay .line-numbers strong{color:rgba(0,0,0,.4)}
 table.CodeRay{border-collapse:separate;border-spacing:0;margin-bottom:0;border:0;background:none}
 table.CodeRay td{vertical-align: top;line-height:1.45}
 table.CodeRay td.line-numbers{text-align:right}
 table.CodeRay td.line-numbers>pre{padding:0;color:rgba(0,0,0,.3)}
 table.CodeRay td.code{padding:0 0 0 .5em}
 table.CodeRay td.code>pre{padding:0}
 .CodeRay .debug{color:#fff !important;background:#000080 !important}
 .CodeRay .annotation{color:#007}
 .CodeRay .attribute-name{color:#000080}
 .CodeRay .attribute-value{color:#700}
 .CodeRay .binary{color:#509}
 .CodeRay .comment{color:#998;font-style:italic}
 .CodeRay .char{color:#04d}
 .CodeRay .char .content{color:#04d}
 .CodeRay .char .delimiter{color:#039}
 .CodeRay .class{color:#458;font-weight:bold}
 .CodeRay .complex{color:#a08}
 .CodeRay .constant,.CodeRay .predefined-constant{color:#008080}
 .CodeRay .color{color:#099}
 .CodeRay .class-variable{color:#369}
 .CodeRay .decorator{color:#b0b}
 .CodeRay .definition{color:#099}
 .CodeRay .delimiter{color:#000}
 .CodeRay .doc{color:#970}
 .CodeRay .doctype{color:#34b}
 .CodeRay .doc-string{color:#d42}
 .CodeRay .escape{color:#666}
 .CodeRay .entity{color:#800}
 .CodeRay .error{color:#808}
 .CodeRay .exception{color:inherit}
 .CodeRay .filename{color:#099}
 .CodeRay .function{color:#900;font-weight:bold}
 .CodeRay .global-variable{color:#008080}
 .CodeRay .hex{color:#058}
 .CodeRay .integer,.CodeRay .float{color:#099}
 .CodeRay .include{color:#555}
 .CodeRay .inline{color:#000}
 .CodeRay .inline .inline{background:#ccc}
 .CodeRay .inline .inline .inline{background:#bbb}
 .CodeRay .inline .inline-delimiter{color:#d14}
 .CodeRay .inline-delimiter{color:#d14}
 .CodeRay .important{color:#555;font-weight:bold}
 .CodeRay .interpreted{color:#b2b}
 .CodeRay .instance-variable{color:#008080}
 .CodeRay .label{color:#970}
 .CodeRay .local-variable{color:#963}
 .CodeRay .octal{color:#40e}
 .CodeRay .predefined{color:#369}
 .CodeRay .preprocessor{color:#579}
 .CodeRay .pseudo-class{color:#555}
 .CodeRay .directive{font-weight:bold}
 .CodeRay .type{font-weight:bold}
 .CodeRay .predefined-type{color:inherit}
 .CodeRay .reserved,.CodeRay .keyword {color:#000;font-weight:bold}
 .CodeRay .key{color:#808}
 .CodeRay .key .delimiter{color:#606}
 .CodeRay .key .char{color:#80f}
 .CodeRay .value{color:#088}
 .CodeRay .regexp .delimiter{color:#808}
 .CodeRay .regexp .content{color:#808}
 .CodeRay .regexp .modifier{color:#808}
 .CodeRay .regexp .char{color:#d14}
 .CodeRay .regexp .function{color:#404;font-weight:bold}
 .CodeRay .string{color:#d20}
 .CodeRay .string .string .string{background:#ffd0d0}
 .CodeRay .string .content{color:#d14}
 .CodeRay .string .char{color:#d14}
 .CodeRay .string .delimiter{color:#d14}
 .CodeRay .shell{color:#d14}
 .CodeRay .shell .delimiter{color:#d14}
 .CodeRay .symbol{color:#990073}
 .CodeRay .symbol .content{color:#a60}
 .CodeRay .symbol .delimiter{color:#630}
 .CodeRay .tag{color:#008080}
 .CodeRay .tag-special{color:#d70}
 .CodeRay .variable{color:#036}
 .CodeRay .insert{background:#afa}
 .CodeRay .delete{background:#faa}
 .CodeRay .change{color:#aaf;background:#007}
 .CodeRay .head{color:#f8f;background:#505}
 .CodeRay .insert .insert{color:#080}
 .CodeRay .delete .delete{color:#800}
 .CodeRay .change .change{color:#66f}
 .CodeRay .head .head{color:#f4f}
 </style>
 <link rel="stylesheet" href="../katex/katex.min.css">
 <script src="../katex/katex.min.js"></script>
 <script src="../katex/contrib/auto-render.min.js"></script>
     <!-- Use KaTeX to render math once document is loaded, see
          https://github.com/Khan/KaTeX/tree/master/contrib/auto-render -->
 <script>
     document.addEventListener("DOMContentLoaded", function () {
         renderMathInElement(
             document.body,
             {
                 delimiters: [
                     { left: "$$", right: "$$", display: true},
                     { left: "\\[", right: "\\]", display: true},
                     { left: "$", right: "$", display: false},
                     { left: "\\(", right: "\\)", display: false}
                 ]
             }
         );
     });
 </script></head>
 <body class="book toc2 toc-left" style="max-width: 100;">
 <div id="header">
 <h1>The OpenCL Extension Specification</h1>
 <div class="details">
 <span id="author" class="author">Khronos OpenCL Working Group</span><br>
 <span id="revnumber">version 2.2-7,</span>
 <span id="revdate">Sat, 12 May 2018 13:21:27 +0000</span>
 <br><span id="revremark">from git branch: master commit: ab6da3001e9eeafaa36c18888ca7eb4ebb9768af</span>
 </div>
 <div id="toc" class="toc2">
 <div id="toctitle">Table of Contents</div>
 <ul class="sectlevel1">
 <li><a href="#optional-extensions">1. Optional Extensions</a></li>
 <li><a href="#cl_khr_fp16">2. Half Precision Floating-Point</a></li>
 <li><a href="#cl_khr_gl_sharing">3. Creating an OpenCL Context from an OpenGL Context or Share Group</a></li>
 <li><a href="#cl_khr_gl_sharing__memobjs">4. Creating OpenCL Memory Objects from OpenGL Objects</a></li>
 <li><a href="#cl_khr_gl_event-creating">5. Creating OpenCL Event Objects from OpenGL Sync Objects</a></li>
 <li><a href="#cl_khr_dx9_media_sharing">6. Creating OpenCL Memory Objects from DirectX 9 Media Surfaces</a></li>
 <li><a href="#cl_khr_d3d10_sharing">7. Creating OpenCL Memory Objects from Direct3D 10 Buffers and Textures</a></li>
 <li><a href="#cl_khr_d3d11_sharing">8. Creating OpenCL Memory Objects from Direct3D 11 Buffers and Textures</a></li>
 <li><a href="#cl_khr_gl_depth_images">9. Sharing OpenGL and OpenGL ES Depth and Depth-Stencil Images</a></li>
 <li><a href="#cl_khr_gl_msaa_sharing">10. Creating OpenCL Memory Obejcts from OpenGL MSAA Textures</a></li>
 <li><a href="#cl_khr_initialize_memory">11. Local and Private Memory Initialization</a></li>
 <li><a href="#cl_khr_terminate_context">12. Terminating OpenCL contexts</a></li>
 <li><a href="#cl_khr_spir">13. SPIR 1.2 Binaries</a></li>
 <li><a href="#cl_khr_icd-opencl">14. OpenCL Installable Client Driver (ICD)</a></li>
 <li><a href="#cl_khr_subgroups">15. Subgroups</a></li>
 <li><a href="#cl_khr_mipmap_image">16. Mipmaps</a></li>
 <li><a href="#cl_khr_egl_image">17. Creating OpenCL Memory Objects from EGL Images</a></li>
 <li><a href="#cl_khr_egl_event">18. Creating OpenCL Event Objects from EGL Sync Objects</a></li>
 <li><a href="#cl_khr_priority_hints">19. Priority Hints</a></li>
 <li><a href="#cl_khr_throttle_hints">20. Throttle Hints</a></li>
 <li><a href="#cl_khr_subgroup_named_barrier">21. Named Barriers for Subgroups</a></li>
 <li><a href="#_summary_of_changes_from_opencl_2_1">Appendix A: Summary of Changes from OpenCL 2.1</a></li>
 </ul>
 </div>
 </div>
 <div id="content">
 <div id="preamble">
 <div class="sectionbody">
 <div class="paragraph">
 <p>Copyright 2008-2018 The Khronos Group.</p>
 </div>
 <div class="paragraph">
 <p>This specification is protected by copyright laws and contains material proprietary
 to the Khronos Group, Inc. Except as described by these terms, it or any components
 may not be reproduced, republished, distributed, transmitted, displayed, broadcast
 or otherwise exploited in any manner without the express prior written permission
 of Khronos Group.</p>
 </div>
 <div class="paragraph">
 <p>Khronos Group grants a conditional copyright license to use and reproduce the
 unmodified specification for any purpose, without fee or royalty, EXCEPT no licenses
 to any patent, trademark or other intellectual property rights are granted under
 these terms. Parties desiring to implement the specification and make use of
 Khronos trademarks in relation to that implementation, and receive reciprocal patent
 license protection under the Khronos IP Policy must become Adopters and confirm the
 implementation as conformant under the process defined by Khronos for this
 specification; see <a href="https://www.khronos.org/adopters" class="bare">https://www.khronos.org/adopters</a>.</p>
 </div>
 <div class="paragraph">
 <p>Khronos Group makes no, and expressly disclaims any, representations or warranties,
 express or implied, regarding this specification, including, without limitation:
 merchantability, fitness for a particular purpose, non-infringement of any
 intellectual property, correctness, accuracy, completeness, timeliness, and
 reliability. Under no circumstances will the Khronos Group, or any of its Promoters,
 Contributors or Members, or their respective partners, officers, directors,
 employees, agents or representatives be liable for any damages, whether direct,
 indirect, special or consequential damages for lost revenues, lost profits, or
 otherwise, arising from or in connection with these materials.</p>
 </div>
 <div class="paragraph">
 <p>Vulkan is a registered trademark and Khronos, OpenXR, SPIR, SPIR-V, SYCL, WebGL,
 WebCL, OpenVX, OpenVG, EGL, COLLADA, glTF, NNEF, OpenKODE, OpenKCAM, StreamInput,
 OpenWF, OpenSL ES, OpenMAX, OpenMAX AL, OpenMAX IL, OpenMAX DL, OpenML and DevU are
 trademarks of the Khronos Group Inc. ASTC is a trademark of ARM Holdings PLC,
 OpenCL is a trademark of Apple Inc. and OpenGL and OpenML are registered trademarks
 and the OpenGL ES and OpenGL SC logos are trademarks of Silicon Graphics
 International used under license by Khronos. All other product names, trademarks,
 and/or company names are used solely for identification and belong to their
 respective owners.</p>
 </div>
 <div style="page-break-after: always;"></div>
 </div>
 </div>
 <div class="sect1">
 <h2 id="optional-extensions">1. Optional Extensions</h2>
 <div class="sectionbody">
 <div class="paragraph">
 <p>This document describes the list of optional features supported by OpenCL
 2.2.
 Optional extensions may be supported by some OpenCL devices.
 Optional extensions are not required to be supported by a conformant OpenCL
 implementation, but are expected to be widely available; they define
 functionality that is likely to move into the required feature set in a
 future revision of the OpenCL specification.
 A brief description of how OpenCL extensions are defined is provided below.</p>
 </div>
 <div class="paragraph">
 <p>For OpenCL extensions approved by the OpenCL working group, the following
 naming conventions are used:</p>
 </div>
 <div class="ulist">
 <ul>
 <li>
 <p>A unique <em>name string</em> of the form <code>"<strong>cl_khr_&lt;<em>name</em>&gt;</strong>"</code> is associated
 with each extension.
 If the extension is supported by an implementation, this string will be
 present in the implementation&#8217;s CL_PLATFORM_EXTENSIONS string or
 CL_DEVICE_EXTENSIONS string.</p>
 </li>
 <li>
 <p>All API functions defined by the extension will have names of the form
 <strong>cl&lt;<em>function_name</em>&gt;KHR</strong>.</p>
 </li>
 <li>
 <p>All enumerants defined by the extension will have names of the form
 <strong>CL_&lt;<em>enum_name</em>&gt;_KHR.</strong></p>
 </li>
 </ul>
 </div>
 <div class="paragraph">
 <p>OpenCL extensions approved by the OpenCL working group can be <em>promoted</em> to
 required core features in later revisions of OpenCL.
 When this occurs, the extension specifications are merged into the core
 specification.
 Functions and enumerants that are part of such promoted extensions will have
 the <strong>KHR</strong> affix removed.
 OpenCL implementations of such later revisions must also export the name
 strings of promoted extensions in the CL_PLATFORM_EXTENSIONS or
 CL_DEVICE_EXTENSIONS string, and support the <strong>KHR</strong>-affixed versions of
 functions and enumerants as a transition aid.</p>
 </div>
 <div class="paragraph">
 <p>For vendor extensions, the following naming conventions are used:</p>
 </div>
 <div class="ulist">
 <ul>
 <li>
 <p>A unique <em>name string</em> of the form <code>"<strong>cl_&lt;<em>vendor_name</em>&gt;_&lt;<em>name&gt;</em></strong>"</code>
 is associated with each extension.
 If the extension is supported by an implementation, this string will be
 present in the implementation&#8217;s CL_PLATFORM_EXTENSIONS string or
 CL_DEVICE_EXTENSIONS string.</p>
 </li>
 <li>
 <p>All API functions defined by the vendor extension will have names of the
 form <strong>cl&lt;<em>function_name</em>&gt;&lt;<em>vendor_name</em>&gt;</strong>.</p>
 </li>
 <li>
 <p>All enumerants defined by the vendor extension will have names of the
 form <strong>CL_&lt;<em>enum_name</em>&gt;_&lt;<em>vendor_name</em>&gt;.</strong></p>
 </li>
 </ul>
 </div>
 <div class="sect2">
 <h3 id="compiler-directives-for-optional-extensions">1.1. Compiler Directives for Optional Extensions</h3>
 <div class="paragraph">
 <p>The <strong>#pragma OPENCL EXTENSION</strong> directive controls the behavior of the OpenCL
 compiler with respect to extensions.
 The <strong>#pragma OPENCL EXTENSION</strong> directive is defined as:</p>
 </div>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code>#pragma OPENCL EXTENSION &lt;extension_name&gt; : &lt;behavior&gt;
 #pragma OPENCL EXTENSION all : &lt;behavior&gt;</code></pre>
 </div>
 </div>
 <div class="paragraph">
 <p>where <em>extension_name</em> is the name of the extension.
 The <em>extension_name</em> will have names of the form <strong>cl_khr_&lt;<em>name</em>&gt;</strong> for an
 extension approved by the OpenCL working group and will have names of the
 form <strong>cl_&lt;<em>vendor_name</em>&gt;_&lt;<em>name</em>&gt;</strong> for vendor extensions.
 The token <strong>all</strong> means that the behavior applies to all extensions supported
 by the compiler.
 The <em>behavior</em> can be set to one of the following values given by the table
 below.</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <colgroup>
 <col style="width: 25%;">
 <col style="width: 75%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>behavior</strong></th>
 <th class="tableblock halign-left valign-top"><strong>Description</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>enable</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Behave as specified by the extension <em>extension_name</em>.</p>
 <p class="tableblock">  Report an error on the <strong><code>#pragma OPENCL EXTENSION</code></strong> if the
   <em>extension_name</em> is not supported, or if <strong>all</strong> is specified.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>disable</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Behave (including issuing errors and warnings) as if the extension
   <em>extension_name</em> is not part of the language definition.</p>
 <p class="tableblock">  If <strong>all</strong> is specified, then behavior must revert back to that of the
   non-extended core version of the language being compiled to.</p>
 <p class="tableblock">  Warn on the <strong><code>#pragma OPENCL EXTENSION</code></strong> if the extension <em>extension_name</em>
   is not supported.</p></td>
 </tr>
 </tbody>
 </table>
 <div class="paragraph">
 <p>The <strong><code>#pragma OPENCL EXTENSION</code></strong> directive is a simple, low-level mechanism
 to set the behavior for each extension.
 It does not define policies such as which combinations are appropriate;
 those must be defined elsewhere.
 The order of directives matter in setting the behavior for each extension.
 Directives that occur later override those seen earlier.
 The <strong>all</strong> variant sets the behavior for all extensions, overriding all
 previously issued extension directives, but only if the <em>behavior</em> is set to
 <strong>disable</strong>.</p>
 </div>
 <div class="paragraph">
 <p>The initial state of the compiler is as if the directive</p>
 </div>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code>#pragma OPENCL EXTENSION all : disable</code></pre>
 </div>
 </div>
 <div class="paragraph">
 <p>was issued, telling the compiler that all error and warning reporting must
 be done according to this specification, ignoring any extensions.</p>
 </div>
 <div class="paragraph">
 <p>Every extension which affects the OpenCL language semantics, syntax or adds
 built-in functions to the language must create a preprocessor <code>#define</code> that
 matches the extension name string.
 This <code>#define</code> would be available in the language if and only if the
 extension is supported on a given implementation.</p>
 </div>
 <div class="paragraph">
 <p><strong>Example</strong>:</p>
 </div>
 <div class="paragraph">
 <p>An extension which adds the extension string <code>"cl_khr_3d_image_writes"</code>
 should also add a preprocessor <code>#define</code> called <strong><code>cl_khr_3d_image_writes</code></strong>.
 A kernel can now use this preprocessor <code>#define</code> to do something like:</p>
 </div>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code>#ifdef cl_khr_3d_image_writes
     // do something using the extension
 #else
     // do something else or #error!
 #endif</code></pre>
 </div>
 </div>
 </div>
 <div class="sect2">
 <h3 id="getting-opencl-api-extension-function-pointers">1.2. Getting OpenCL API Extension Function Pointers</h3>
 <div class="paragraph">
 <p>The function
 </p>
 </div>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code>void clGetExtensionFunctionAddressForPlatform(cl_platform_id platform,
                                               const char *funcname)</code></pre>
 </div>
 </div>
 <div class="paragraph">
 <p>returns the address of the extension function named by <em>funcname</em> for a
 given <em>platform</em> The pointer returned should be cast to a function pointer
 type matching the extension function&#8217;s definition defined in the appropriate
 extension specification and header file.
 A return value of <code>NULL</code> indicates that the specified function does not
 exist for the implementation or <em>platform</em> is not a valid platform.
 A non-<code>NULL</code> return value for <strong>clGetExtensionFunctionAddressForPlatform</strong>
 does not guarantee that an extension function is actually supported by the
 platform.
 The application must also make a corresponding query using
 <strong>clGetPlatformInfo</strong>(platform, CL_PLATFORM_EXTENSIONS, &#8230;&#8203;) or
 <strong>clGetDeviceInfo</strong>(device, CL_DEVICE_EXTENSIONS, &#8230;&#8203;) to determine if an
 extension is supported by the OpenCL implementation.</p>
 </div>
 <div class="paragraph">
 <p>Since there is no way to qualify the query with a
 device, the function pointer returned must work for all implementations of
 that extension on different devices for a platform.
 The behavior of calling a device extension function on a device not
 supporting that extension is undefined.</p>
 </div>
 <div class="paragraph">
 <p><strong>clGetExtensionFunctionAddressForPlatform</strong> may not be be used to query for core
 (non-extension) functions in OpenCL.
 For extension functions that may be queried using
 <strong>clGetExtensionFunctionAddressForPlatform</strong>, implementations may also choose to
 export those functions statically from the object libraries
 implementing those functions, however, portable applications cannot rely on
 this behavior.</p>
 </div>
 <div class="paragraph">
 <p>Function pointer typedefs must be declared for all extensions that add API
 entrypoints.
 These typedefs are a required part of the extension interface, to be
 provided in an appropriate header (such as cl_ext.h if the extension is an
 OpenCL extension, or cl_gl_ext.h if the extension is an OpenCL / OpenGL
 sharing extension).</p>
 </div>
 <div class="paragraph">
 <p>The following convention must be followed for all extensions affecting the
 host API:</p>
 </div>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code>#ifndef extension_name
 #define extension_name 1

 // all data typedefs, token #defines, prototypes, and
 // function pointer typedefs for this extension

 // function pointer typedefs must use the
 // following naming convention

 typedef CL_API_ENTRY return_type
             (CL_API_CALL *clExtensionFunctionNameTAG_fn)(...);

 #endif // _extension_name_</code></pre>
 </div>
 </div>
 <div class="paragraph">
 <p>where <code>TAG</code> can be <code>KHR</code>, <code>EXT</code> or <code>vendor-specific</code>.</p>
 </div>
 <div class="paragraph">
 <p>Consider, for example, the <strong>cl_khr_gl_sharing</strong> extension.
 This extension would add the following to cl_gl_ext.h:</p>
 </div>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code>#ifndef cl_khr_gl_sharing
 #define cl_khr_gl_sharing 1

 // all data typedefs, token #defines, prototypes, and
 // function pointer typedefs for this extension
 #define CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR -1000
 #define CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR 0x2006
 #define CL_DEVICES_FOR_GL_CONTEXT_KHR 0x2007
 #define CL_GL_CONTEXT_KHR 0x2008
 #define CL_EGL_DISPLAY_KHR 0x2009
 #define CL_GLX_DISPLAY_KHR 0x200A
 #define CL_WGL_HDC_KHR 0x200B
 #define CL_CGL_SHAREGROUP_KHR 0x200C

 // function pointer typedefs must use the
 // following naming convention
 typedef CL_API_ENTRY cl_int
         (CL_API_CALL *clGetGLContextInfoKHR_fn)(
             const cl_context_properties * /* properties */,
             cl_gl_context_info /* param_name */,
             size_t /* param_value_size */,
             void * /* param_value */,
             size_t * /*param_value_size_ret*/);

 #endif // cl_khr_gl_sharing</code></pre>
 </div>
 </div>
 <div style="page-break-after: always;"></div>
 </div>
 </div>
 </div>
 <div class="sect1">
 <h2 id="cl_khr_fp16">2. Half Precision Floating-Point</h2>
 <div class="sectionbody">
 <div class="paragraph">
 <p>This section describes the <strong>cl_khr_fp16</strong> extension.
 This extension adds support for half scalar and vector types as built-in
 types that can be used for arithmetic operations, conversions etc.</p>
 </div>
 <div class="sect2">
 <h3 id="cl_khr_fp16-additions-to-chapter-6-of-the-opencl-2.0-specification">2.1. Additions to Chapter 6 of the OpenCL 2.0 C Specification</h3>
 <div class="paragraph">
 <p>The list of built-in scalar, and vector data types defined in <em>tables 6.1</em>,
 and <em>6.2</em> are extended to include the following:</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <colgroup>
 <col style="width: 25%;">
 <col style="width: 75%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>Type</strong></th>
 <th class="tableblock halign-left valign-top"><strong>Description</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half2</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">A 2-component half-precision floating-point vector.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half3</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">A 3-component half-precision floating-point vector.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half4</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">A 4-component half-precision floating-point vector.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half8</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">A 8-component half-precision floating-point vector.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half16</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">A 16-component half-precision floating-point vector.</p></td>
 </tr>
 </tbody>
 </table>
 <div class="paragraph">
 <p>The built-in vector data types for <code>halfn</code> are also declared as appropriate
 types in the OpenCL API (and header files) that can be used by an
 application.
 The following table describes the built-in vector data types for <code>halfn</code> as
 defined in the OpenCL C programming language and the corresponding data type
 available to the application:</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <colgroup>
 <col style="width: 50%;">
 <col style="width: 50%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>Type in OpenCL Language</strong></th>
 <th class="tableblock halign-left valign-top"><strong>API type for application</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half2</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>cl_half2</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half3</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>cl_half3</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half4</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>cl_half4</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half8</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>cl_half8</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>half16</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>cl_half16</strong></p></td>
 </tr>
 </tbody>
 </table>
 <div class="paragraph">
 <p>The relational, equality, logical and logical unary operators described in
 <em>section 6.3</em> can be used with <code>half</code> scalar and <code>halfn</code> vector types and
 shall produce a scalar <code>int</code> and vector <code>shortn</code> result respectively.</p>
 </div>
 <div class="paragraph">
 <p>The OpenCL compiler accepts an h and H suffix on floating point literals,
 indicating the literal is typed as a half.</p>
 </div>
 <div class="sect3">
 <h4 id="cl_khr_fp16-conversions">2.1.1. Conversions</h4>
 <div class="paragraph">
 <p>The implicit conversion rules specified in <em>section 6.2.1</em> now include the
 <code>half</code> scalar and <code>halfn</code> vector data types.</p>
 </div>
 <div class="paragraph">
 <p>The explicit casts described in <em>section 6.2.2</em> are extended to take a
 <code>half</code> scalar data type and a <code>halfn</code> vector data type.</p>
 </div>
 <div class="paragraph">
 <p>The explicit conversion functions described in <em>section 6.2.3</em> are extended
 to take a <code>half</code> scalar data type and a <code>halfn</code> vector data type.</p>
 </div>
 <div class="paragraph">
 <p>The <code>as_typen()</code> function for re-interpreting types as described in <em>section
 6.2.4.2</em> is extended to allow conversion-free casts between <code>shortn</code>,
 <code>ushortn</code>, and <code>halfn</code> scalar and vector data types.</p>
 </div>
 </div>
 <div class="sect3">
 <h4 id="cl_khr_fp16-math-functions">2.1.2. Math Functions</h4>
 <div class="paragraph">
 <p>The built-in math functions defined in <em>table 6.8</em> (also listed below) are
 extended to include appropriate versions of functions that take <code>half</code>, and
 <code>half{2|3|4|8|16}</code> as arguments and return values.
 <code>gentype</code> now also includes <code>half</code>, <code>half2</code>, <code>half3</code>, <code>half4</code>, <code>half8</code>, and
 <code>half16</code>.</p>
 </div>
 <div class="paragraph">
 <p>For any specific use of a function, the actual type has to be the same for
 all arguments and the return type.</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <caption class="title">Table 1. <em>Half Precision Built-in Math Functions</em></caption>
 <colgroup>
 <col style="width: 50%;">
 <col style="width: 50%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>Function</strong></th>
 <th class="tableblock halign-left valign-top"><strong>Description</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>acos</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Arc cosine function.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>acosh</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Inverse hyperbolic cosine.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>acospi</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <strong>acos</strong> (<em>x</em>) / π.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>asin</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Arc sine function.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>asinh</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Inverse hyperbolic sine.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>asinpi</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <strong>asin</strong> (<em>x</em>) / π.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>atan</strong> (gentype <em>y_over_x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Arc tangent function.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>atan2</strong> (gentype <em>y</em>, gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Arc tangent of <em>y</em> / <em>x</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>atanh</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Hyperbolic arc tangent.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>atanpi</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <strong>atan</strong> (<em>x</em>) / π.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>atan2pi</strong> (gentype <em>y</em>, gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <strong>atan2</strong> (<em>y</em>, <em>x</em>) / π.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>cbrt</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute cube-root.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>ceil</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Round to integral value using the round to positive infinity rounding
   mode.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>copysign</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <em>x</em> with its sign changed to match the sign of <em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>cos</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute cosine.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>cosh</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute hyperbolic consine.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>cospi</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <strong>cos</strong> (π <em>x</em>).</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>erfc</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Complementary error function.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>erf</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Error function encountered in integrating the normal distribution.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>exp</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute the base- e exponential of <em>x</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>exp2</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Exponential base 2 function.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>exp10</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Exponential base 10 function.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>expm1</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <em>e<sup>x</sup></em>- 1.0.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>fabs</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute absolute value of a floating-point number.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>fdim</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><em>x</em> - <em>y</em> if <em>x</em> &gt; <em>y</em>, +0 if x is less than or equal to y.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>floor</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Round to integral value using the round to negative infinity rounding
   mode.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>fma</strong> (gentype <em>a</em>, gentype <em>b</em>, gentype <em>c</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the correctly rounded floating-point representation of the sum of
   <em>c</em> with the infinitely precise product of <em>a</em> and <em>b</em>.
   Rounding of intermediate products shall not occur.
   Edge case behavior is per the IEEE 754-2008.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>fmax</strong> (gentype x, gentype y)<br>
   gentype <strong>fmax</strong> (gentype <em>x</em>, half <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <em>y</em> if <em>x</em> &lt; <em>y</em>, otherwise it returns <em>x</em>.
   If one argument is a NaN, <strong>fmax()</strong> returns the other argument.
   If both arguments are NaNs, <strong>fmax()</strong> returns a NaN.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>fmin</strong> (gentype <em>x</em>, gentype <em>y</em>)<br>
   gentype <strong>fmin</strong> (gentype <em>x</em>, half <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <em>y</em> if <em>y</em> &lt; <em>x</em>, otherwise it returns <em>x</em>.
   If one argument is a NaN, <strong>fmin()</strong> returns the other argument.
   If both arguments are NaNs, <strong>fmin()</strong> returns a NaN.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>fmod</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Modulus.
   Returns <em>x</em> - <em>y</em> * <strong>trunc</strong> (<em>x</em>/<em>y</em>) .</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>fract</strong> (gentype <em>x</em>, gentype *<em>iptr</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <strong>fmin</strong>( <em>x</em> - <strong>floor</strong> (<em>x</em>), 0x1.ffcp-1f ).</p>
 <p class="tableblock">  <strong>floor</strong>(x) is returned in <em>iptr</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half<em>n</em> <strong>frexp</strong> (half<em>n</em> <em>x</em>, int<em>n</em> *exp)<br>
   half <strong>frexp</strong> (half <em>x</em>, int *exp)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Extract mantissa and exponent from <em>x</em>.
   For each component the mantissa returned is a float with magnitude in the
   interval [1/2, 1) or 0.
   Each component of <em>x</em> equals mantissa returned * 2<em><sup>exp</sup></em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>hypot</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute the value of the square root of <em>x</em><sup>2</sup>+ <em>y</em><sup>2</sup> without undue
   overflow or underflow.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int<em>n</em> <strong>ilogb</strong> (half<em>n</em> <em>x</em>)<br>
   int <strong>ilogb</strong> (half <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Return the exponent as an integer value.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half<em>n</em> <strong>ldexp</strong> (half<em>n</em> <em>x</em>, int<em>n</em> <em>k</em>)<br>
   half<em>n</em> <strong>ldexp</strong> (half<em>n</em> <em>x</em>, int <em>k</em>)<br>
   half <strong>ldexp</strong> (half <em>x</em>, int <em>k</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Multiply <em>x</em> by 2 to the power <em>k</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>lgamma</strong> (gentype <em>x</em>)<br>
   half<em>n</em> <strong>lgamma_r</strong> (half<em>n</em> <em>x</em>, int<em>n</em> *<em>signp</em>)<br>
   half <strong>lgamma_r</strong> (half <em>x</em>, int *<em>signp</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Log gamma function.
   Returns the natural logarithm of the absolute value of the gamma function.
   The sign of the gamma function is returned in the <em>signp</em> argument of
   <strong>lgamma_r</strong>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>log</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute natural logarithm.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>log2</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute a base 2 logarithm.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>log10</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute a base 10 logarithm.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>log1p</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute log<sub>e</sub>(1.0 + <em>x</em>) .</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>logb</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute the exponent of <em>x</em>, which is the integral part of
   log<em><sub>r</sub></em>|<em>x</em>|.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>mad</strong> (gentype <em>a</em>, gentype <em>b</em>, gentype <em>c</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>mad</strong> computes <em>a</em> * <em>b</em> + <em>c</em>.
   The function may compute <em>a</em> * <em>b</em> + <em>c</em> with reduced accuracy
   in the embedded profile.  See the SPIR-V OpenCL environment specification
   for details. On some hardware the mad instruction may provide better
   performance than expanded computation of <em>a</em> * <em>b</em> + <em>c</em>.</p>
 <p class="tableblock">  Note: For some usages, e.g. <strong>mad</strong>(a, b, -a*b), the half precision
   definition of <strong>mad</strong>() is loose enough that almost any result is allowed
   from <strong>mad</strong>() for some values of a and b.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>maxmag</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <em>x</em> if |<em>x</em>| &gt; |<em>y</em>|, <em>y</em> if |<em>y</em>| &gt; |<em>x</em>|, otherwise
   <strong>fmax</strong>(<em>x</em>, <em>y</em>).</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>minmag</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <em>x</em> if |<em>x</em>| &lt; |<em>y</em>|, <em>y</em> if |<em>y</em>| &lt; |<em>x</em>|, otherwise
   <strong>fmin</strong>(<em>x</em>, <em>y</em>).</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>modf</strong> (gentype <em>x</em>, gentype *<em>iptr</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Decompose a floating-point number.
   The <strong>modf</strong> function breaks the argument <em>x</em> into integral and fractional
   parts, each of which has the same sign as the argument.
   It stores the integral part in the object pointed to by <em>iptr</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half<em>n</em> <strong>nan</strong> (ushort<em>n</em> <em>nancode</em>)<br>
   half <strong>nan</strong> (ushort <em>nancode</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns a quiet NaN.
   The <em>nancode</em> may be placed in the significand of the resulting NaN.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>nextafter</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Computes the next representable half-precision floating-point value
   following <em>x</em> in the direction of <em>y</em>.
   Thus, if <em>y</em> is less than <em>x</em>, <strong>nextafter</strong>() returns the largest
   representable floating-point number less than <em>x</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>pow</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <em>x</em> to the power <em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half<em>n</em> <strong>pown</strong> (half<em>n</em> <em>x</em>, int<em>n</em> <em>y</em>)<br>
   half <strong>pown</strong> (half <em>x</em>, int <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <em>x</em> to the power <em>y</em>, where <em>y</em> is an integer.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>powr</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <em>x</em> to the power <em>y</em>, where <em>x</em> is &gt;= 0.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>remainder</strong> (gentype <em>x</em>, gentype <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute the value <em>r</em> such that <em>r</em> = <em>x</em> - <em>n</em>*<em>y</em>, where <em>n</em> is the
   integer nearest the exact value of <em>x</em>/<em>y</em>.
   If there are two integers closest to <em>x</em>/<em>y</em>, <em>n</em> shall be the even one.
   If <em>r</em> is zero, it is given the same sign as <em>x</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half<em>n</em> <strong>remquo</strong> (half<em>n</em> <em>x</em>, half<em>n</em> <em>y</em>, int<em>n</em> *<em>quo</em>)<br>
   half <strong>remquo</strong> (half <em>x</em>, half <em>y</em>, int *<em>quo</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">The <strong>remquo</strong> function computes the value r such that <em>r</em> = <em>x</em> - <em>k</em>*<em>y</em>,
   where <em>k</em> is the integer nearest the exact value of <em>x</em>/<em>y</em>.
   If there are two integers closest to <em>x</em>/<em>y</em>, <em>k</em> shall be the even one.
   If <em>r</em> is zero, it is given the same sign as <em>x</em>.
   This is the same value that is returned by the <strong>remainder</strong> function.
   <strong>remquo</strong> also calculates the lower seven bits of the integral quotient
   <em>x</em>/<em>y</em>, and gives that value the same sign as <em>x</em>/<em>y</em>.
   It stores this signed value in the object pointed to by <em>quo</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>rint</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Round to integral value (using round to nearest even rounding mode) in
   floating-point format.
   Refer to section 7.1 for description of rounding modes.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half<em>n</em> <strong>rootn</strong> (half<em>n</em> <em>x</em>, int<em>n</em> <em>y</em>)<br>
   half <strong>rootn</strong> (half <em>x</em>, int <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <em>x</em> to the power 1/<em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>round</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Return the integral value nearest to <em>x</em> rounding halfway cases away from
   zero, regardless of the current rounding direction.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>rsqrt</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute inverse square root.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>sin</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute sine.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>sincos</strong> (gentype <em>x</em>, gentype *<em>cosval</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute sine and cosine of x.
   The computed sine is the return value and computed cosine is returned in
   <em>cosval</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>sinh</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute hyperbolic sine.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>sinpi</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <strong>sin</strong> (π <em>x</em>).</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>sqrt</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute square root.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>tan</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute tangent.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>tanh</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute hyperbolic tangent.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>tanpi</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute <strong>tan</strong> (π <em>x</em>).</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>tgamma</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute the gamma function.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>trunc</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Round to integral value using the round to zero rounding mode.</p></td>
 </tr>
 </tbody>
 </table>
 <div class="paragraph">
 <p>The <strong>FP_FAST_FMA_HALF</strong> macro indicates whether the <strong>fma()</strong> family of
 functions are fast compared with direct code for half precision
 floating-point.
 If defined, the <strong>FP_FAST_FMA_HALF</strong> macro shall indicate that the <strong>fma()</strong>
 function generally executes about as fast as, or faster than, a multiply and
 an add of <strong>half</strong> operands</p>
 </div>
 <div class="paragraph">
 <p>The macro names given in the following list must use the values specified.
 These constant expressions are suitable for use in #if preprocessing
 directives.</p>
 </div>
 <div class="listingblock">
 <div class="content">
 <pre class="CodeRay highlight"><code>#define HALF_DIG            3
 #define HALF_MANT_DIG       11
 #define HALF_MAX_10_EXP     +4
 #define HALF_MAX_EXP        +16
 #define HALF_MIN_10_EXP     -4
 #define HALF_MIN_EXP        -13
 #define HALF_RADIX          2
 #define HALF_MAX            0x1.ffcp15h
 #define HALF_MIN            0x1.0p-14h
 #define HALF_EPSILON        0x1.0p-10h</code></pre>
 </div>
 </div>
 <div class="paragraph">
 <p>The following table describes the built-in macro names given above in the
 OpenCL C programming language and the corresponding macro names available to
 the application.</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <colgroup>
 <col style="width: 50%;">
 <col style="width: 50%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>Macro in OpenCL Language</strong></th>
 <th class="tableblock halign-left valign-top"><strong>Macro for application</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_DIG</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_DIG</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_MANT_DIG</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_MANT_DIG</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_MAX_10_EXP</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_MAX_10_EXP</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_MAX_EXP</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_MAX_EXP</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_MIN_10_EXP</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_MIN_10_EXP</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_MIN_EXP</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_MIN_EXP</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_RADIX</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_RADIX</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_MAX</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_MAX</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_MIN</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_MIN</strong></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>HALF_EPSILSON</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>CL_HALF_EPSILON</strong></p></td>
 </tr>
 </tbody>
 </table>
 <div class="paragraph">
 <p>The following constants are also available.
 They are of type <code>half</code> and are accurate within the precision of the <code>half</code>
 type.</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <colgroup>
 <col style="width: 50%;">
 <col style="width: 50%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>Constant</strong></th>
 <th class="tableblock halign-left valign-top"><strong>Description</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_E_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of e</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_LOG2E_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of log<sub>2</sub>e</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_LOG10E_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of log<sub>10</sub>e</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_LN2_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of log<sub>e</sub>2</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_LN10_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of log<sub>e</sub>10</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_PI_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of π</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_PI_2_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of π / 2</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_PI_4_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of π / 4</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_1_PI_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of 1 / π</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_2_PI_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of 2 / π</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_2_SQRTPI_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of 2 / √π</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_SQRT2_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of √2</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><strong>M_SQRT1_2_H</strong></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Value of 1 / √2</p></td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="sect3">
 <h4 id="cl_khr_fp16-common-functions">2.1.3. Common Functions</h4>
 <div class="paragraph">
 <p>The built-in common functions defined in <em>table 6.12</em> (also listed below)
 are extended to include appropriate versions of functions that take <code>half</code>,
 and <code>half{2|3|4|8|16}</code> as arguments and return values.
 gentype now also includes <code>half</code>, <code>half2</code>, <code>half3</code>, <code>half4</code>, <code>half8</code> and
 <code>half16</code>.
 These are described below.</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <caption class="title">Table 2. <em>Half Precision Built-in Common Functions</em></caption>
 <colgroup>
 <col style="width: 50%;">
 <col style="width: 50%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>Function</strong></th>
 <th class="tableblock halign-left valign-top"><strong>Description</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>clamp</strong> (<br>
   gentype <em>x</em>, gentype <em>minval</em>, gentype <em>maxval</em>)</p>
 <p class="tableblock">  gentype <strong>clamp</strong> (<br>
   gentype <em>x</em>, half <em>minval</em>, half <em>maxval</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <strong>min</strong>(<strong>max</strong>(<em>x</em>, <em>minval</em>), <em>maxval</em>).</p>
 <p class="tableblock">  Results are undefined if <em>minval</em> &gt; <em>maxval</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>degrees</strong> (gentype <em>radians</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Converts <em>radians</em> to degrees,<br>
   i.e. (180 / π) * <em>radians</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>max</strong> (gentype <em>x</em>, gentype <em>y</em>)<br>
   gentype <strong>max</strong> (gentype <em>x</em>, half <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <em>y</em> if <em>x</em> &lt; <em>y</em>, otherwise it returns <em>x</em>.
   If <em>x</em> and <em>y</em> are infinite or NaN, the return values are undefined.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>min</strong> (gentype <em>x</em>, gentype <em>y</em>)<br>
   gentype <strong>min</strong> (gentype <em>x</em>, half <em>y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns <em>y</em> if <em>y</em> &lt; <em>x</em>, otherwise it returns <em>x</em>.
   If <em>x</em> and <em>y</em> are infinite or NaN, the return values are undefined.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>mix</strong> (gentype <em>x</em>, gentype <em>y</em>, gentype <em>a</em>)<br>
   gentype <strong>mix</strong> (gentype <em>x</em>, gentype <em>y</em>, half <em>a</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the linear blend of <em>x</em> and <em>y</em> implemented as:</p>
 <p class="tableblock">  <em>x</em> + (<em>y</em> - <em>x)</em> * <em>a</em></p>
 <p class="tableblock">  <em>a</em> must be a value in the range 0.0 &#8230;&#8203; 1.0.
   If <em>a</em> is not in the range 0.0 &#8230;&#8203; 1.0, the return values are undefined.</p>
 <p class="tableblock">  Note: The half precision <strong>mix</strong> function can be implemented using contractions such as <strong>mad</strong> or <strong>fma</strong>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>radians</strong> (gentype <em>degrees</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Converts <em>degrees</em> to radians, i.e. (π / 180) * <em>degrees</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>step</strong> (gentype <em>edge</em>, gentype <em>x</em>)<br>
   gentype <strong>step</strong> (half <em>edge</em>, gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns 0.0 if <em>x</em> &lt; <em>edge</em>, otherwise it returns 1.0.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>smoothstep</strong> (<br>
   gentype <em>edge0</em>, gentype <em>edge1</em>, gentype <em>x</em>)</p>
 <p class="tableblock">  gentype <strong>smoothstep</strong> (<br>
   half <em>edge0</em>, half <em>edge1</em>, gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns 0.0 if <em>x</em> &lt;= <em>edge0</em> and 1.0 if <em>x</em> &gt;= <em>edge1</em> and performs
   smooth Hermite interpolation between 0 and 1 when <em>edge0</em> &lt; <em>x</em> &lt; <em>edge1</em>.
   This is useful in cases where you would want a threshold function with a
   smooth transition.</p>
 <p class="tableblock">  This is equivalent to:</p>
 <p class="tableblock">  gentype <em>t</em>;<br>
   <em>t</em> = clamp ((<em>x</em> - <em>edge0</em>) / (<em>edge1</em> - <em>edge0</em>), 0, 1);<br>
   return <em>t</em> * <em>t</em> * (3 - 2 * <em>t</em>);<br></p>
 <p class="tableblock">  Results are undefined if <em>edge0</em> &gt;= <em>edge1</em>.</p>
 <p class="tableblock">  Note: The half precision <strong>smoothstep</strong> function can be implemented using contractions such as <strong>mad</strong> or <strong>fma</strong>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>sign</strong> (gentype <em>x</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns 1.0 if <em>x</em> &gt; 0, -0.0 if <em>x</em> = -0.0, +0.0 if <em>x</em> = +0.0, or -1.0 if
   <em>x</em> &lt; 0.
   Returns 0.0 if <em>x</em> is a NaN.</p></td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="sect3">
 <h4 id="cl_khr_fp16-geometric-functions">2.1.4. Geometric Functions</h4>
 <div class="paragraph">
 <p>The built-in geometric functions defined in <em>table 6.13</em> (also listed below)
 are extended to include appropriate versions of functions that take <code>half</code>,
 and <code>half{2|3|4}</code> as arguments and return values.
 gentype now also includes <code>half</code>, <code>half2</code>, <code>half3</code> and <code>half4</code>.
 These are described below.</p>
 </div>
 <div class="paragraph">
 <p>Note: The half precision geometric functions can be implemented using
 contractions such as <strong>mad</strong> or <strong>fma</strong>.</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <caption class="title">Table 3. <em>Half Precision Built-in Geometric Functions</em></caption>
 <colgroup>
 <col style="width: 50%;">
 <col style="width: 50%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>Function</strong></th>
 <th class="tableblock halign-left valign-top"><strong>Description</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half4 <strong>cross</strong> (half4 <em>p0</em>, half4 <em>p1</em>)<br>
   half3 <strong>cross</strong> (half3 <em>p0</em>, half3 <em>p1</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the cross product of <em>p0.xyz</em> and <em>p1.xyz</em>.
   The <em>w</em> component of the result will be 0.0.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half <strong>dot</strong> (gentype <em>p0</em>, gentype <em>p1</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Compute the dot product of <em>p0</em> and <em>p1</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half <strong>distance</strong> (gentype <em>p0</em>, gentype <em>p1</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the distance between <em>p0</em> and <em>p1</em>.
   This is calculated as <strong>length</strong>(<em>p0</em> - <em>p1</em>).</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half <strong>length</strong> (gentype <em>p</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Return the length of vector x, i.e.,<br>
   sqrt( <em>p.x</em><sup>2</sup> + <em>p.y</em><sup>2</sup> + &#8230;&#8203; )</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">gentype <strong>normalize</strong> (gentype <em>p</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns a vector in the same direction as <em>p</em> but with a length of 1.</p></td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="sect3">
 <h4 id="cl_khr_fp16-relational-functions">2.1.5. Relational Functions</h4>
 <div class="paragraph">
 <p>The scalar and vector relational functions described in <em>table 6.14</em> are
 extended to include versions that take <code>half</code>, <code>half2</code>, <code>half3</code>, <code>half4</code>,
 <code>half8</code> and <code>half16</code> as arguments.</p>
 </div>
 <div class="paragraph">
 <p>The relational and equality operators (&lt;, &lt;=, &gt;, &gt;=, !=, ==) can be used
 with <code>halfn</code> vector types and shall produce a vector <code>shortn</code> result as
 described in <em>section 6.3</em>.</p>
 </div>
 <div class="paragraph">
 <p>The functions <strong>isequal</strong>, <strong>isnotequal</strong>, <strong>isgreater</strong>, <strong>isgreaterequal</strong>,
 <strong>isless</strong>, <strong>islessequal</strong>, <strong>islessgreater</strong>, <strong>isfinite</strong>, <strong>isinf</strong>, <strong>isnan</strong>,
 <strong>isnormal</strong>, <strong>isordered</strong>, <strong>isunordered</strong> and <strong>signbit</strong> shall return a 0 if the
 specified relation is <em>false</em> and a 1 if the specified relation is true for
 scalar argument types.
 These functions shall return a 0 if the specified relation is <em>false</em> and a
 -1 (i.e. all bits set) if the specified relation is <em>true</em> for vector
 argument types.</p>
 </div>
 <div class="paragraph">
 <p>The relational functions <strong>isequal</strong>, <strong>isgreater</strong>, <strong>isgreaterequal</strong>, <strong>isless</strong>,
 <strong>islessequal</strong>, and <strong>islessgreater</strong> always return 0 if either argument is not
 a number (NaN).
 <strong>isnotequal</strong> returns 1 if one or both arguments are not a number (NaN) and
 the argument type is a scalar and returns -1 if one or both arguments are
 not a number (NaN) and the argument type is a vector.</p>
 </div>
 <div class="paragraph">
 <p>The functions described in <em>table 6.14</em> are extended to include the <code>halfn</code>
 vector types.</p>
 </div>
 <table class="tableblock frame-all grid-all spread">
 <caption class="title">Table 4. <em>Half Precision Relational Functions</em></caption>
 <colgroup>
 <col style="width: 50%;">
 <col style="width: 50%;">
 </colgroup>
 <thead>
 <tr>
 <th class="tableblock halign-left valign-top"><strong>Function</strong></th>
 <th class="tableblock halign-left valign-top"><strong>Description</strong></th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isequal</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>isequal</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the component-wise compare of <em>x</em> == <em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isnotequal</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>isnotequal</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the component-wise compare of <em>x</em> != <em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isgreater</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>isgreater</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the component-wise compare of <em>x</em> &gt; <em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isgreaterequal</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>isgreaterequal</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the component-wise compare of <em>x</em> &gt;= <em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isless</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>isless</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the component-wise compare of <em>x</em> &lt; <em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>islessequal</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>islessequal</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the component-wise compare of <em>x</em> &lt;= <em>y</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>islessgreater</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>islessgreater</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Returns the component-wise compare of (<em>x</em> &lt; <em>y</em>) || (<em>x</em> &gt; <em>y</em>) .</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"></td>
 <td class="tableblock halign-left valign-top"></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isfinite</strong> (half)<br>
   short<em>n</em> <strong>isfinite</strong> (half<em>n</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Test for finite value.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isinf</strong> (half)<br>
   short<em>n</em> <strong>isinf</strong> (half<em>n</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Test for infinity value (positive or negative) .</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isnan</strong> (half)<br>
   short<em>n</em> <strong>isnan</strong> (half<em>n</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Test for a NaN.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isnormal</strong> (half)<br>
   short<em>n</em> <strong>isnormal</strong> (half<em>n</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Test for a normal value.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isordered</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>isordered</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Test if arguments are ordered.
   <strong>isordered</strong>() takes arguments <em>x</em> and <em>y</em>, and returns the result
   <strong>isequal</strong>(<em>x</em>, <em>x</em>) &amp;&amp; <strong>isequal</strong>(<em>y</em>, <em>y</em>).</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>isunordered</strong> (half <em>x</em>, half <em>y</em>)<br>
   short<em>n</em> <strong>isunordered</strong> (half<em>n x</em>, half<em>n y</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Test if arguments are unordered.
   <strong>isunordered</strong>() takes arguments <em>x</em> and <em>y</em>, returning non-zero if <em>x</em> or
   <em>y</em> is a NaN, and zero otherwise.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">int <strong>signbit</strong> (half)<br>
   short<em>n</em> <strong>signbit</strong> (half<em>n</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Test for sign bit.
   The scalar version of the function returns a 1 if the sign bit in the half
   is set else returns 0.
   The vector version of the function returns the following for each
   component in half<em>n</em>: -1 (i.e all bits set) if the sign bit in the half
   is set else returns 0.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"></td>
 <td class="tableblock halign-left valign-top"></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half<em>n</em> <strong>bitselect</strong> (half<em>n a</em>, half<em>n b</em>, half<em>n c</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Each bit of the result is the corresponding bit of <em>a</em> if the
   corresponding bit of <em>c</em> is 0.
   Otherwise it is the corresponding bit of <em>b</em>.</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-left valign-top"><p class="tableblock">half<em>n</em> <strong>select</strong> (half<em>n a</em>, half<em>n b</em>, short<em>n</em> <em>c</em>)<br>
   half<em>n</em> <strong>select</strong> (half<em>n a</em>, half<em>n b</em>, ushort<em>n</em> <em>c</em>)</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">For each component,<br>
   <em>result[i]</em> = if MSB of <em>c[i]</em> is set ? <em>b[i]</em> : <em>a[i]</em>.<br></p></td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="sect3">
 <h4 id="cl_khr_fp16-vector-data-load-and-store-functions">2.1.6. Vector Data Load and Store Functions</h4>
 <div class="paragraph">
 <p>