uk.co.real_logic.artio.fields.DecimalFloat Maven / Gradle / Ivy
Show all versions of artio-codecs Show documentation
/*
* Copyright 2015-2024 Real Logic Limited., Adaptive Financial Consulting Ltd.
*
* 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
*
* https://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.
*/
package uk.co.real_logic.artio.fields;
import uk.co.real_logic.artio.util.float_parsing.CharSequenceCharReader;
import uk.co.real_logic.artio.util.float_parsing.DecimalFloatParser;
import static uk.co.real_logic.artio.util.PowerOf10.HIGHEST_POWER_OF_TEN;
import static uk.co.real_logic.artio.util.PowerOf10.POWERS_OF_TEN;
/**
* Fix float data type. Floats are used for a variety of things, including price.
*
* Must support 15 significant digits, decimal places variable.
*
* Decimal float represents the significant digits using a value field,
* and the location of the point using the scale field.
*
* See http://fixwiki.org/fixwiki/FloatDataType for details. Examples:
*
* 55.36
* 55.3600
* 0055.36
* 0055.3600
* .995
* 0.9950
* 25
* -55.36
* -0055.3600
* -55.3600
* -.995
* -0.9950
* -25
*/
public final class DecimalFloat extends ReadOnlyDecimalFloat
{
private static final int SCALE_NAN_VALUE = -128;
private static final long VALUE_NAN_VALUE = Long.MIN_VALUE;
private static final long VALUE_MAX_VAL = 999_999_999_999_999_999L;
private static final double VALUE_MAX_VAL_AS_DOUBLE = VALUE_MAX_VAL;
private static final long VALUE_MIN_VAL = -VALUE_MAX_VAL;
private static final double VALUE_MIN_VAL_AS_DOUBLE = VALUE_MIN_VAL;
private static final int SCALE_MAX_VAL = 127;
// FRACTION_LOWER_THRESHOLD and FRACTION_UPPER_THRESHOLD are used when converting
// the fractional part of a double to ensure that discretisation errors are corrected.
// E.g. The actual number 0.123 might be held in binary as something like 0.1230000000000000001
// and actual number 0.456 might be held in binary as 0.4559999999999999999999
// The while-loop and if-statement below using the *_THRESHOLD constants will ensure the
// correct number (0.123 and 0.456) is represented in the DecimalFloat.
private static final double FRACTION_LOWER_THRESHOLD = 1e-7;
private static final double FRACTION_UPPER_THRESHOLD = 1.0 - FRACTION_LOWER_THRESHOLD;
public DecimalFloat()
{
this(0, 0);
}
public DecimalFloat(final long value)
{
this(value, 0);
}
public DecimalFloat(final long value, final int scale)
{
super(value, scale);
}
/**
* Resets the encoder to the NAN value. This can be checked using the {@link #isNaNValue()} method.
*/
public void reset()
{
this.value = VALUE_NAN_VALUE;
this.scale = SCALE_NAN_VALUE;
// Deliberately doesn't normalise, as that validates the arithmetic range.
}
public DecimalFloat set(final ReadOnlyDecimalFloat other)
{
this.value = other.value;
this.scale = other.scale;
return this;
}
/**
* Sets the value of the DecimalFloat to the same as a long value.
*
* @param value the value to set
* @return this
*/
public DecimalFloat fromLong(final long value)
{
setAndNormalise(value, 0);
return this;
}
public DecimalFloat set(final long value, final int scale)
{
setAndNormalise(value, scale);
return this;
}
/*
* Please use set(newValue, newScale) instead of value(newValue) and scale(newScale)
*/
@Deprecated
public DecimalFloat value(final long value)
{
this.value = value;
return this;
}
/*
* Please use set(newValue, newScale) instead of value(newValue) and scale(newScale)
*/
@Deprecated
public DecimalFloat scale(final int scale)
{
this.scale = scale;
return this;
}
public DecimalFloat negate()
{
this.value *= -1;
return this;
}
public DecimalFloat copy()
{
return new DecimalFloat(value, scale);
}
/**
* @return a copy that is guaranteed not to change value
*/
public ReadOnlyDecimalFloat immutableCopy()
{
return isNaNValue() ? NAN : new ReadOnlyDecimalFloat(value, scale);
}
public boolean fromDouble(final double doubleValue)
{
if (Double.isNaN(doubleValue))
{
value = VALUE_NAN_VALUE;
scale = SCALE_NAN_VALUE;
return true;
}
if (!Double.isFinite(doubleValue) ||
isOutsideLimits(doubleValue, VALUE_MIN_VAL_AS_DOUBLE, VALUE_MAX_VAL_AS_DOUBLE))
{
return false;
}
if (doubleValue == 0.0)
{
value = 0L;
scale = 0;
return true;
}
final boolean isNegative = doubleValue < 0.0;
double remainingValue = Math.abs(doubleValue);
long newValue = (long)remainingValue;
// Have to repeat the limit verification, as the test above on the doubleValue is not exact.
// It cuts the worst offenders and allows us to cast to a long,
// but it lets through bad values within about 64 of the limits.
if (isOutsideLimits(newValue, VALUE_MIN_VAL, VALUE_MAX_VAL))
{
return false;
}
int newScale = 0;
remainingValue -= newValue;
if (remainingValue == 0.0)
{
setAndNormalise(signedValue(isNegative, newValue), newScale);
return true;
}
while (canValueAcceptMoreDigits(newValue, newScale) &&
(newValue == 0L ||
!isOutsideLimits(remainingValue, FRACTION_LOWER_THRESHOLD, FRACTION_UPPER_THRESHOLD)))
{
remainingValue *= 10.0;
final double digit = Math.floor(remainingValue);
remainingValue -= digit;
newValue = newValue * 10L + (long)digit;
++newScale;
}
if (FRACTION_UPPER_THRESHOLD < remainingValue)
{
newValue++;
}
setAndNormalise(signedValue(isNegative, newValue), newScale);
return true;
}
public DecimalFloat fromString(final CharSequence string)
{
return fromString(string, 0, string.length());
}
public DecimalFloat fromString(final CharSequence string, final int start, final int length)
{
return DecimalFloatParser.extract(this, CharSequenceCharReader.INSTANCE, string, start, length);
}
public static DecimalFloat newNaNValue()
{
return ReadOnlyDecimalFloat.NAN.mutableCopy();
}
private static boolean canValueAcceptMoreDigits(final long value, final int scale)
{
return value <= POWERS_OF_TEN[HIGHEST_POWER_OF_TEN - 1] && scale < SCALE_MAX_VAL;
}
private static boolean isOutsideLimits(final long value, final long lowerBound, final long upperBound)
{
return value < lowerBound || upperBound < value;
}
private static boolean isOutsideLimits(final double value, final double lowerBound, final double upperBound)
{
return value < lowerBound || upperBound < value;
}
private static long signedValue(final boolean isNegative, final long value)
{
return isNegative ? -value : value;
}
}