Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* 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
*
*
* 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
};
});