struct Float::Printer::DiyFP

Overview

This "Do It Yourself Floating Point" struct implements a floating-point number with a UIht64 significand and an Int32 exponent. Normalized DiyFP numbers will have the most significant bit of the significand set. Multiplication and Subtraction do not normalize their results. DiyFP is not designed to contain special Floats (NaN and Infinity).

Defined in:

float/printer/diy_fp.cr

Constant Summary

MASK32 = 4294967295_u32
SIGNIFICAND_SIZE = 64

Constructors

Class Method Summary

Instance Method Summary

Instance methods inherited from struct Struct

==(other : self) : Bool ==, hash(hasher) hash, inspect(io : IO) : Nil inspect, pretty_print(pp) : Nil pretty_print, to_s(io) to_s

Instance methods inherited from struct Value

==(other) ==, dup dup

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other)
===
, =~(other) =~, class class, dup dup, hash(hasher)
hash
hash
, inspect(io : IO)
inspect
inspect
, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json
to_json
, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ")
to_pretty_json
, to_s
to_s(io : IO)
to_s
, to_yaml(io : IO)
to_yaml
to_yaml
, try(&block) try, unsafe_as(type : T.class) forall T unsafe_as

Constructor methods inherited from class Object

from_json(string_or_io, root : String) : self
from_json(string_or_io) : self
from_json
, from_yaml(string_or_io) : self from_yaml

Constructor Detail

def self.new(frac, exp : Int16) #

[View source]
def self.new(frac, exp) #

[View source]

Class Method Detail

def self.from_f(d : Float64 | Float32) #

[View source]
def self.from_f_normalized(v : Float64 | Float32) #

Normalize such that the most signficiant bit of frac is set


[View source]

Instance Method Detail

def *(other : DiyFP) #

Returns a new DiyFP caculated as self * other.

Simply "emulates" a 128 bit multiplication. However: the resulting number only contains 64 bits. The least significant 64 bits are only used for rounding the most significant 64 bits.

This result is not normalized.


[View source]
def -(other : DiyFP) #

Returns a new DiyFP caculated as self - other.

The exponents of both numbers must be the same and the frac of self must be greater than the other.

This result is not normalized.


[View source]
def exp : Int32 #

exponent


[View source]
def exp=(exp : Int32) #

exponent


[View source]
def frac : UInt64 #

Also known as the significand


[View source]
def frac=(frac : UInt64) #

Also known as the significand


[View source]
def new(frac : Int32, exp) #

[View source]
def normalize #

[View source]