/**
 * Precision
 */
let Precision = {
 /**
 * Standard epsilon, the maximum relative precision of IEEE 754 double-precision floating numbers (64 bit).
 * According to the definition of Prof. Demmel and used in LAPACK and Scilab.
 */
 doublePrecision: Math.pow(2, -53),

 /**
 * Standard epsilon, the maximum relative precision of IEEE 754 double-precision floating numbers (64 bit).
 * According to the definition of Prof. Higham and used in the ISO C standard and MATLAB.
 */
 positiveDoublePrecision: 2 * Math.pow(2, -53),

 /**
 * Value representing 10 * 2^(-53) = 1.11022302462516E-15
 */
 defaultDoubleAccuracy: Math.pow(2, -53) * 10,

 /**
 * Converts a double to a 64-bit integer representation
 */
 doubleToInt64Bits: function(value) {
 let buffer = new ArrayBuffer(8);
 let float64Array = new Float64Array(buffer);
 let int64Array = new BigInt64Array(buffer);
 float64Array[0] = value;
 return int64Array[0];
 },

 /**
 * Converts a 64-bit integer representation to a double
 */
 int64BitsToDouble: function(bits) {
 let buffer = new ArrayBuffer(8);
 let int64Array = new BigInt64Array(buffer);
 let float64Array = new Float64Array(buffer);
 int64Array[0] = bits;
 return float64Array[0];
 },

 /**
 * Increments a floating point number to the next bigger number representable by the data type.
 * @param {number} value - The value which needs to be incremented.
 * @param {number} count - How many times the number should be incremented.
 * @returns {number} The next larger floating point value.
 */
 increment: function(value, count = 1) {
 if (isNaN(value) || !isFinite(value) || count === 0) {
 return value;
 }

 // Translate the bit pattern of the double to an integer
 let intValue = this.doubleToInt64Bits(value);
 if (intValue < 0) {
 intValue -= BigInt(count);
 } else {
 intValue += BigInt(count);
 }

 // Note that BigInt(-9223372036854775808) has the same bit pattern as -0.0
 if (intValue === BigInt(-9223372036854775808)) {
 return 0;
 }

 return this.int64BitsToDouble(intValue);
 },

 /**
 * Evaluates the minimum distance to the next distinguishable number near the argument value.
 * @param {number} value - The value used to determine the minimum distance.
 * @returns {number} Relative Epsilon (positive double or NaN).
 */
 epsilonOf: function(value) {
 if (isNaN(value) || !isFinite(value)) {
 return NaN;
 }

 let signed64 = this.doubleToInt64Bits(value);
 if (signed64 === 0n) {
 signed64++;
 return this.int64BitsToDouble(signed64) - value;
 }
 if (signed64 < 0n) {
 signed64--;
 return this.int64BitsToDouble(signed64) - value;
 }
 signed64--;
 return value - this.int64BitsToDouble(signed64);
 },

 /**
 * Evaluates the minimum distance to the next distinguishable number near the argument value.
 * @param {number} value - The value used to determine the minimum distance.
 * @returns {number} Relative Epsilon (positive double or NaN).
 */
 positiveEpsilonOf: function(value) {
 return 2 * this.epsilonOf(value);
 },

 /**
 * @param {number} a
 * @param {number} b
 * @param {number} diff
 * @param {number} maximumError
 * @returns {boolean}
 */
 almostEqualNormRelative: function(a, b, diff, maximumError) {
 // If A or B are infinity (positive or negative) then
 // only return true if they are exactly equal to each other -
 // that is, if they are both infinities of the same sign.
 if (!isFinite(a) || !isFinite(b)) {
 return a === b;
 }

 // If A or B are a NAN, return false. NANs are equal to nothing,
 // not even themselves.
 if (isNaN(a) || isNaN(b)) {
 return false;
 }

 // If one is almost zero, fall back to absolute equality
 if (Math.abs(a) < this.doublePrecision || Math.abs(b) < this.doublePrecision) {
 return Math.abs(diff) < maximumError;
 }

 if ((a === 0 && Math.abs(b) < maximumError) || (b === 0 && Math.abs(a) < maximumError)) {
 return true;
 }

 return Math.abs(diff) < maximumError * Math.max(Math.abs(a), Math.abs(b));
 },

 /**
 * @param {number} a
 * @param {number} b
 * @returns {boolean}
 */
 almostEqualRelative: function(a, b) {
 return this.almostEqualNormRelative(a, b, a - b, this.defaultDoubleAccuracy);
 },

 /**
 * @param {number} a
 * @param {number} b
 * @returns {boolean}
 */
 almostEqual: function(a, b) {
 return this.almostEqualNorm(a, b, a - b, this.defaultDoubleAccuracy);
 },

 /**
 * @param {number} a
 * @param {number} b
 * @param {number} diff
 * @param {number} maximumAbsoluteError
 * @returns {boolean}
 */
 almostEqualNorm: function(a, b, diff, maximumAbsoluteError) {
 // If A or B are infinity (positive or negative) then
 // only return true if they are exactly equal to each other -
 // that is, if they are both infinities of the same sign.
 if (!isFinite(a) || !isFinite(b)) {
 return a === b;
 }

 // If A or B are a NAN, return false. NANs are equal to nothing,
 // not even themselves.
 if (isNaN(a) || isNaN(b)) {
 return false;
 }

 return Math.abs(diff) < maximumAbsoluteError;
 }
};

// 添加方法到 Number.prototype
Number.prototype.increment = function(count = 1) {
 return Precision.increment(this, count);
};

Number.prototype.epsilonOf = function() {
 return Precision.epsilonOf(this);
};

Number.prototype.positiveEpsilonOf = function() {
 return Precision.positiveEpsilonOf(this);
};

Number.prototype.almostEqualRelative = function(other) {
 return Precision.almostEqualRelative(this, other);
};

Number.prototype.almostEqual = function(other) {
 return Precision.almostEqual(this, other);
};

export { Precision };