| /*------------------------------------------------------------------------- |
| * drawElements Quality Program Tester Core |
| * ---------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Adjustable-precision floating point operations. |
| *//*--------------------------------------------------------------------*/ |
| 'use strict'; |
| goog.provide('framework.common.tcuFloatFormat'); |
| |
| goog.require('framework.common.tcuInterval'); |
| goog.require('framework.delibs.debase.deMath'); |
| |
| goog.scope(function() { |
| |
| var tcuFloatFormat = framework.common.tcuFloatFormat; |
| var deMath = framework.delibs.debase.deMath; |
| var tcuInterval = framework.common.tcuInterval; |
| |
| /** |
| * @param {tcuFloatFormat.YesNoMaybe} choice |
| * @param {tcuInterval.Interval} no |
| * @param {tcuInterval.Interval} yes |
| * @return {tcuInterval.Interval} |
| */ |
| tcuFloatFormat.chooseInterval = function(choice, no, yes) { |
| switch (choice) { |
| case tcuFloatFormat.YesNoMaybe.NO: return no; |
| case tcuFloatFormat.YesNoMaybe.YES: return yes; |
| case tcuFloatFormat.YesNoMaybe.MAYBE: return no.operatorOrBinary(yes); |
| default: throw new Error('Impossible case'); |
| } |
| }; |
| |
| /** |
| * @param {number} maxExp |
| * @param {number} fractionBits |
| * @return {number} |
| */ |
| tcuFloatFormat.computeMaxValue = function(maxExp, fractionBits) { |
| return deMath.deLdExp(1, maxExp) + deMath.deLdExp(Math.pow(2, fractionBits) - 1, maxExp - fractionBits); |
| }; |
| |
| /** |
| * @enum {number} |
| */ |
| tcuFloatFormat.YesNoMaybe = { |
| NO: 0, |
| MAYBE: 1, |
| YES: 2 |
| }; |
| |
| /** |
| * @constructor |
| * @param {number} minExp |
| * @param {number} maxExp |
| * @param {number} fractionBits |
| * @param {boolean} exactPrecision |
| * @param {tcuFloatFormat.YesNoMaybe=} hasSubnormal |
| * @param {tcuFloatFormat.YesNoMaybe=} hasInf |
| * @param {tcuFloatFormat.YesNoMaybe=} hasNaN |
| */ |
| tcuFloatFormat.FloatFormat = function(minExp, maxExp, fractionBits, exactPrecision, hasSubnormal, hasInf, hasNaN) { |
| // /** @type{number} */ var exponentShift (int exp) const; |
| // Interval clampValue (double d) const; |
| |
| /** @type {number} */ this.m_minExp = minExp; // Minimum exponent, inclusive |
| /** @type {number} */ this.m_maxExp = maxExp; // Maximum exponent, inclusive |
| /** @type {number} */ this.m_fractionBits = fractionBits; // Number of fractional bits in significand |
| /** @type {tcuFloatFormat.YesNoMaybe} */ this.m_hasSubnormal = hasSubnormal === undefined ? tcuFloatFormat.YesNoMaybe.MAYBE : hasSubnormal; // Does the format support denormalized numbers? |
| /** @type {tcuFloatFormat.YesNoMaybe} */ this.m_hasInf = hasInf === undefined ? tcuFloatFormat.YesNoMaybe.MAYBE : hasInf; // Does the format support infinities? |
| /** @type {tcuFloatFormat.YesNoMaybe} */ this.m_hasNaN = hasNaN === undefined ? tcuFloatFormat.YesNoMaybe.MAYBE : hasNaN; // Does the format support NaNs? |
| /** @type {boolean} */ this.m_exactPrecision = exactPrecision; // Are larger precisions disallowed? |
| /** @type {number} */ this.m_maxValue = tcuFloatFormat.computeMaxValue(maxExp, fractionBits); |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.getMinExp = function() { |
| return this.m_minExp; |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.getMaxExp = function() { |
| return this.m_maxExp; |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.getMaxValue = function() { |
| return this.m_maxValue; |
| }; |
| |
| /** |
| * @return {number} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.getFractionBits = function() { |
| return this.m_fractionBits; |
| }; |
| |
| /** |
| * @return {tcuFloatFormat.YesNoMaybe} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.hasSubnormal = function() { |
| return this.m_hasSubnormal; |
| }; |
| |
| /** |
| * @return {tcuFloatFormat.YesNoMaybe} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.hasInf = function() { |
| return this.m_hasInf; |
| }; |
| |
| /** |
| * @param {number} x |
| * @param {number} count |
| * @return {number} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.ulp = function(x, count) { |
| var breakdown = deMath.deFractExp(Math.abs(x)); |
| /** @type {number} */ var exp = breakdown.exponent; |
| /** @type {number} */ var frac = breakdown.significand; |
| |
| if (isNaN(frac)) |
| return NaN; |
| else if (!isFinite(frac)) |
| return deMath.deLdExp(1.0, this.m_maxExp - this.m_fractionBits); |
| else if (frac == 1.0) { |
| // Harrison's ULP: choose distance to closest (i.e. next lower) at binade |
| // boundary. |
| --exp; |
| } else if (frac == 0.0) |
| exp = this.m_minExp; |
| |
| // ULP cannot be lower than the smallest quantum. |
| exp = Math.max(exp, this.m_minExp); |
| |
| /** @type {number} */ var oneULP = deMath.deLdExp(1.0, exp - this.m_fractionBits); |
| // ScopedRoundingMode ctx (DE_ROUNDINGMODE_TO_POSITIVE_INF); |
| |
| return oneULP * count; |
| }; |
| |
| /** |
| * Return the difference between the given nominal exponent and |
| * the exponent of the lowest significand bit of the |
| * representation of a number with this format. |
| * For normal numbers this is the number of significand bits, but |
| * for subnormals it is less and for values of exp where 2^exp is too |
| * small to represent it is <0 |
| * @param {number} exp |
| * @return {number} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.exponentShift = function(exp) { |
| return this.m_fractionBits - Math.max(this.m_minExp - exp, 0); |
| }; |
| |
| /** |
| * @param {number} d |
| * @param {boolean} upward |
| * @return {number} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.round = function(d, upward) { |
| var breakdown = deMath.deFractExp(d); |
| /** @type {number} */ var exp = breakdown.exponent; |
| /** @type {number} */ var frac = breakdown.significand; |
| |
| var shift = this.exponentShift(exp); |
| var shiftFrac = deMath.deLdExp(frac, shift); |
| var roundFrac = upward ? Math.ceil(shiftFrac) : Math.floor(shiftFrac); |
| |
| return deMath.deLdExp(roundFrac, exp - shift); |
| }; |
| |
| /** |
| * Return the range of numbers that `d` might be converted to in the |
| * floatformat, given its limitations with infinities, subnormals and maximum |
| * exponent. |
| * @param {number} d |
| * @return {tcuInterval.Interval} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.clampValue = function(d) { |
| /** @type {number} */ var rSign = deMath.deSign(d); |
| /** @type {number} */ var rExp = 0; |
| |
| // DE_ASSERT(!isNaN(d)); |
| |
| var breakdown = deMath.deFractExp(d); |
| rExp = breakdown.exponent; |
| if (rExp < this.m_minExp) |
| return tcuFloatFormat.chooseInterval(this.m_hasSubnormal, new tcuInterval.Interval(rSign * 0.0), new tcuInterval.Interval(d)); |
| else if (!isFinite(d) || rExp > this.m_maxExp) |
| return tcuFloatFormat.chooseInterval(this.m_hasInf, new tcuInterval.Interval(rSign * this.getMaxValue()), new tcuInterval.Interval(rSign * Number.POSITIVE_INFINITY)); |
| |
| return new tcuInterval.Interval(d); |
| }; |
| |
| /** |
| * @param {number} d |
| * @param {boolean} upward |
| * @param {boolean} roundUnderOverflow |
| * @return {number} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.roundOutDir = function(d, upward, roundUnderOverflow) { |
| var breakdown = deMath.deFractExp(d); |
| var exp = breakdown.exponent; |
| |
| if (roundUnderOverflow && exp > this.m_maxExp && (upward == (d < 0.0))) |
| return deMath.deSign(d) * this.getMaxValue(); |
| else |
| return this.round(d, upward); |
| }; |
| |
| /** |
| * @param {tcuInterval.Interval} x |
| * @param {boolean} roundUnderOverflow |
| * @return {tcuInterval.Interval} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.roundOut = function(x, roundUnderOverflow) { |
| /** @type {tcuInterval.Interval} */ var ret = x.nan(); |
| |
| if (!x.empty()) { |
| var a = new tcuInterval.Interval(this.roundOutDir(x.lo(), false, roundUnderOverflow)); |
| var b = new tcuInterval.Interval(this.roundOutDir(x.hi(), true, roundUnderOverflow)); |
| ret.operatorOrAssignBinary(tcuInterval.withIntervals(a, b)); |
| } |
| return ret; |
| }; |
| |
| //! Return the range of numbers that might be used with this format to |
| //! represent a number within `x`. |
| /** |
| * @param {tcuInterval.Interval} x |
| * @return {tcuInterval.Interval} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.convert = function(x) { |
| /** @type {tcuInterval.Interval} */ var ret = new tcuInterval.Interval(); |
| /** @type {tcuInterval.Interval} */ var tmp = x; |
| |
| if (x.hasNaN()) { |
| // If NaN might be supported, NaN is a legal return value |
| if (this.m_hasNaN != tcuFloatFormat.YesNoMaybe.NO) |
| ret.operatorOrAssignBinary(new tcuInterval.Interval(NaN)); |
| |
| // If NaN might not be supported, any (non-NaN) value is legal, |
| // _subject_ to clamping. Hence we modify tmp, not ret. |
| if (this.m_hasNaN != tcuFloatFormat.YesNoMaybe.YES) |
| tmp = tcuInterval.unbounded(); |
| } |
| |
| // Round both bounds _inwards_ to closest representable values. |
| if (!tmp.empty()) |
| ret.operatorOrAssignBinary( |
| this.clampValue(this.round(tmp.lo(), true)).operatorOrBinary( |
| this.clampValue(this.round(tmp.hi(), false)))); |
| |
| // If this format's precision is not exact, the (possibly out-of-bounds) |
| // original value is also a possible result. |
| if (!this.m_exactPrecision) |
| ret.operatorOrAssignBinary(x); |
| |
| return ret; |
| }; |
| |
| /** |
| * @param {number} x |
| * @return {string} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.floatToHex = function(x) { |
| if (isNaN(x)) |
| return 'NaN'; |
| else if (!isFinite(x)) |
| return (x < 0.0 ? '-' : '+') + ('inf'); |
| else if (x == 0.0) // \todo [2014-03-27 lauri] Negative zero |
| return '0.0'; |
| |
| return x.toString(10); |
| // TODO |
| // var breakdown = deMath.deFractExp(deAbs(x)); |
| // /** @type{number} */ var exp = breakdown.exponent; |
| // /** @type{number} */ var frac = breakdown.significand; |
| // /** @type{number} */ var shift = this.exponentShift(exp); |
| // /** @type{number} */ var bits = deUint64(deLdExp(frac, shift)); |
| // /** @type{number} */ var whole = bits >> m_fractionBits; |
| // /** @type{number} */ var fraction = bits & ((deUint64(1) << m_fractionBits) - 1); |
| // /** @type{number} */ var exponent = exp + m_fractionBits - shift; |
| // /** @type{number} */ var numDigits = (this.m_fractionBits + 3) / 4; |
| // /** @type{number} */ var aligned = fraction << (numDigits * 4 - m_fractionBits); |
| // /** @type{string} */ var oss = ''; |
| |
| // oss + (x < 0 ? '-' : '') |
| // + '0x' + whole + '.' |
| // + std::hex + std::setw(numDigits) + std::setfill('0') + aligned |
| // + 'p' + std::dec + std::setw(0) + exponent; |
| //return oss; |
| }; |
| |
| /** |
| * @param {tcuInterval.Interval} interval |
| * @return {string} |
| */ |
| tcuFloatFormat.FloatFormat.prototype.intervalToHex = function(interval) { |
| if (interval.empty()) |
| return interval.hasNaN() ? '{ NaN }' : '{}'; |
| |
| else if (interval.lo() == interval.hi()) |
| return ((interval.hasNaN() ? '{ NaN, ' : '{ ') + |
| this.floatToHex(interval.lo()) + ' }'); |
| else if (interval == tcuInterval.unbounded(true)) |
| return '<any>'; |
| |
| return ((interval.hasNaN() ? '{ NaN } | ' : '') + |
| '[' + this.floatToHex(interval.lo()) + ', ' + this.floatToHex(interval.hi()) + ']'); |
| }; |
| |
| /** |
| * @return {tcuFloatFormat.FloatFormat} |
| */ |
| tcuFloatFormat.nativeDouble = function() { |
| return new tcuFloatFormat.FloatFormat(-1021 - 1, // min_exponent |
| 1024 - 1, // max_exponent |
| 53 - 1, // digits |
| true, // has_denorm |
| tcuFloatFormat.YesNoMaybe.YES, // has_infinity |
| tcuFloatFormat.YesNoMaybe.YES, // has_quiet_nan |
| tcuFloatFormat.YesNoMaybe.YES); // has_denorm |
| }; |
| |
| }); |
