Module sp_arithmetic::fixed_point

Decimal Fixed Point implementations for Substrate runtime. Similar to types that implement PerThing, these are also fixed-point types, however, they are able to represent larger fractions:

#[test]
fn fixed_u64() {
	// The difference between this and perthings is perthings operates within the relam of [0,
	// 1] In cases where we need > 1, we can used fixed types such as FixedU64

	let rational_1 = FixedU64::from_rational(10, 5); //" 200%" aka 2.
	let rational_2 = FixedU64::from_rational_with_rounding(5, 10, Rounding::Down); // "50%" aka 0.50...

	assert_eq!(rational_1, (2u64).into());
	assert_eq!(rational_2.into_perbill(), Perbill::from_float(0.5));
}

Fixed Point Types in Practice

If one needs to exceed the value of one (1), then FixedU64 (and its signed and u128 counterparts) can be utilized. Take for example this very rudimentary pricing mechanism, where we wish to calculate the demand / supply to get a price for some on-chain compute:

#[test]
fn fixed_u64_block_computation_example() {
	// Calculate a very rudimentary on-chain price from supply / demand
	// Supply: Cores available per block
	// Demand: Cores being ordered per block
	let price = FixedU64::from_rational(5u128, 10u128);

	// 0.5 DOT per core
	assert_eq!(price, FixedU64::from_float(0.5));

	// Now, the story has changed - lots of demand means we buy as many cores as there
	// available.  This also means that price goes up! For the sake of simplicity, we don't care
	// about who gets a core - just about our very simple price model

	// Calculate a very rudimentary on-chain price from supply / demand
	// Supply: Cores available per block
	// Demand: Cores being ordered per block
	let price = FixedU64::from_rational(19u128, 10u128);

	// 1.9 DOT per core
	assert_eq!(price, FixedU64::from_float(1.9));
}

For a much more comprehensive example, be sure to look at the source for broker (the “coretime”) pallet.

Fixed Point Types in Practice

Just as with PerThing, you can also perform regular mathematical expressions:

#[test]
fn fixed_u64_operation_example() {
	let rational_1 = FixedU64::from_rational(10, 5); // "200%" aka 2.
	let rational_2 = FixedU64::from_rational(8, 5); // "160%" aka 1.6.

	let addition = rational_1 + rational_2;
	let multiplication = rational_1 * rational_2;
	let division = rational_1 / rational_2;
	let subtraction = rational_1 - rational_2;

	assert_eq!(addition, FixedU64::from_float(3.6));
	assert_eq!(multiplication, FixedU64::from_float(3.2));
	assert_eq!(division, FixedU64::from_float(1.25));
	assert_eq!(subtraction, FixedU64::from_float(0.4));
}

Structs

• FixedI64
  A fixed point number representation in the range. Fixed Point 64 bits signed, range = [-9223372036.854775808, 9223372036.854775807]
• FixedI128
  A fixed point number representation in the range. Fixed Point 128 bits signed, range = [-170141183460469231731.687303715884105728, 170141183460469231731.687303715884105727]
• FixedU64
  A fixed point number representation in the range. Fixed Point 64 bits unsigned, range = [0.000000000, 18446744073.709551615]
• FixedU128
  A fixed point number representation in the range. Fixed Point 128 bits unsigned, range = [0.000000000000000000, 340282366920938463463.374607431768211455]

Traits

• FixedPointNumber
  Something that implements a decimal fixed point number.
• FixedPointOperand
  Integer types that can be used to interact with FixedPointNumber implementations.