so hi welcome to my talk I'm Martin
yoshinovski I am Senior software
engineer at PEX and today I I have
talked about introduction to floating
boy numbers
as users this we will not try to go
super deep into their Theory or and so
on only we will try to use them
so let me actually start with some
disclaimers first I will be using floats
as short for floating Point numbers
because saying folding by numbers over
and over and over again
is not fun
now I will be talking about IEEE 754
binary floats
Juan IE actually contains decimal floats
as well two that is a bunch of other
floats that exist and we will not touch
these because they are mostly unused
unless you are one of the poor people
who has to use IBM right
now we will not go into the forensicity
details we will look at them as users we
will look at how to use them to
accomplish our goals note
you know anything else
and I want to start with a quick quiz
so we have an assert and we say okay so
0.1 plus 0.2 should be include 0.3 let
this pass
or will this fail
so I have voices for fail yes this will
fail we have all seen this example at
some point
another example
we have 20 million as a float plus 1 is
equal to 20 million will this pass or
fail pass
okay and fail
I have one two votes for fail
it will pass
20 million plus one is equal to 20
million this makes perfect sense right
so you know what let's go overboard
debate
let's say 20 million plus one plus one
is equal to one plus one plus 20 million
again thus
is this true
or is this false
I have some of those two or false this
is flawless
but 20 million plus one plus one is not
the same as one plus one plus 20 million
so the thing is
right what the hell
but it makes perfect sense
it actually makes perfect sense
if you understand how flows work right
and I won't but after we leave here for
you to be like yeah this makes perfect
sense I know why I know how
so yeah this should make sense to you
after relief
and I spoke about understanding
the thing is our tools don't always help
us right this is simple test in cage two
because of this case there's no
important importance that we have double
that's exactly one and we say okay give
us the next largest uh next Double
that's larger than one
and we ask RB is equal
well they are not and we will be told
this failed a is equal to B has failed
they are not equal this is fine
and we will we will be told that the
numbers are 1.0 and 1.0
right the tools don't always help you I
am kind of responsible for this one
sorry
but I can change it like for its
compatibility what do you do
well
so contents what we will be actually
talking about today
I want to start with decimal floats I
said we were talking about binary float
so y decimal
because I might hear the ace at the
issue people have with understanding
floats is that we go from decimal to
Binary because we are used to Computing
stuff in decimal we do math in decimal
so we have to go to binary and we are
used to like perfect math then we go to
float we have their own rules so instead
of making these two steps we'll make one
with that symbol float we will learn how
they work why they work and then we will
go to Binary flows and we will figure
out what actually IE tells us about
floats what guarantees they give us for
math when we do it and then we actually
learn how to compare flows because after
we compute something we now need to know
whether for example we computed what we
should have whether we have hit some
threshold of notability for an event
that we have to trigger and finally we
will learn that actually uh we'll add
nothing it nothing works it all breaks
down at the end
so why are floats weird
why did we get something as severe as
floats because we have design
constraints every decision we have
provided has some design constraints
this is no different
have to be usable for computation in
real numbers and real numbers are
annoying not only are they infinite this
is easy they are uncountably infinite
this is hard for example ends they cover
whole numbers all numbers are countable
Infinity this is easy
right
then next constraint we have
the floats must support both tiny and
large numbers and it must support the in
one operation right we have this tiny
number
and is a huge number
and we must be able to multiply them
together and get an answer that makes
sense
by the way does anyone know what these
numbers are
okay these are from physics the first
one is the gravitational constant the
second one is the mass of the sun
so I'm quite little that you must
support these two in one computation you
will multiply them
if you do physics if you need to come to
something gravity you will notify these
two numbers
and the last constrain you know the one
that always makes issues we want to be
efficient in our there so the
representation has to be fixed size
computers like fixed size and has to be
relatively small you know we can't burn
too much Hardware on just floats
so what do we do about this
well before we go there let's do the
decimal floats as I promised
and actually let's do something else
first scientific notation
I hope that we have heard all heard
about it but the basic idea is that you
have some number m
you multiplied by 10 to some exponent n
right this is scientific notation we all
use it in school at some point
and then you can normalize it you can
say but I want M to always be between 1
and 10. right this means that I will
always have only single digit before the
decimal point nothing else
that's all we require
numbers that look like this
yeah we they have one useful property
it's super easy to compare them like you
see okay this turns to the power of
seven this is larger than the other two
we don't have to think any more about it
now let's say
that we want we said that we need fixed
length stuff for Hardware
so let's say that we have to say the
scientific notation has to be fixed line
right
so we say okay so we use some x one
digit for before decimal point three
digits after one digit from the exponent
well and what about negative numbers for
now let's not bother let's say that
minus sign is just stored separately
and for negative exponents the Same by
the way if you need negative exponents
so we represent small numbers like
negative exponents small numbers
and that's voting for it format just in
decimal
we just made one
okay this when we look at it the first
part the X YY is called the mantisa
these are the digits that we have of the
number that we know that are there
and that is the exponent that's the
magnitude of the number of er handling
okay
now
this little format we made can represent
numbers in this interval from uh -9
billion 999 Millions blah blah blah
the important part node is here
is the zeros
right these are zeros not nines why
because we already don't have the digits
in the mantiser we have anything else
and that's that's the like whole thing
about floats we have limited number of
digits of precision
so we then just have to round this into
something
okay
now the smallest positive number we can
represent is this as I said before
negative exponent means tiny number I am
not going to try to read this
that's too much for me
but is there another another option
can we have smaller number
in this format
well the answer is
uh yes maybe
so we can denormalize the number we can
say okay but what if we say but I
actually want to allow myself to have
zero at the start
and then finally just having the one
here
we have just gained three orders extra
then we can basically get close to the
zero notice that we have three more
zeros here
now I have absolutely zero chance of you
know of reading the number
but the trade-off we made is that we no
longer have the number normalized and
it's more complex to use it for us
now IE flow does exactly the same
trade-off it says most of the time my
month is ice normalized easy to work
with and you know you get some number in
special circumstances it's denormalized
and you can get closer to zero at the
cost of slower operations
I equals these the normal numbers
a lot and I know that historically lots
of applications used to turn them off
because they cost performance it's
getting better
but the point is this gives you extra
Precision around zero
now another interesting thing about
floats we can easily see in this format
is that the absolute difference between
two numbers that are closest to each
other
increases when the magnitude increases
but the relative difference is the same
example to explain this right we have
these two pairs of number on the top and
on the bottom and they are all like as
close as to each other as they can be
right this is just the one the
difference is one in the last place we
can represent
and when you used anything different now
in absolute numbers this is one this is
uh sorry 100
000.
this is massively different from each
other
but in relation to the original to the
two numbers we subtract it
they're exactly the same
that's what I mean the relative
difference between two closest numbers
is always the same while the absolute
difference just scales with the
magnitude of the numbers
now we made this design in like three
minutes so we have issues
right so one we have both positive and
negative zero we said we store minus
sign somewhere else
this means that we can have negative
positive zero
we have lots of representations for zero
right we have 19 actually they look like
this we just set it zero and then we
just figure out whichever exponent we
want
uh
this is a little bit of an issue
we can handle it in some ways like say
there is one canonical format for zero
or we can just assign meanings to some
of the representations like for example
we can say if we overflow our little
float if we have numbers too big we will
pick say this this representation and
say that's actually Infinity
so we can use the we can use the
encoding space that we have there and
you know negative zero has another 19
way to wrap 19 ways to represent it
was late Infinities we can use it for
errors so on so forth
and here is the part that's important
the decimal flows are just as weird as
the binary ones we started with
right we get this fun fact like 1.9
times 9 is not one
to do the computation in decimal floats
okay
ten thousand plus four
is just ten thousand
ten thousand plus four plus four it's
not the same as four plus four plus ten
thousand
okay
and this is where we have to build the
intuition for why this happens so
why is this true
well let's compute it first exactly
so we get well done ten thousand and
four okay let's go to flow to decimal
floats it's one point zero zero zero
four times standard value for
but we have only three digits after the
single point we have to do rounding and
ten thousand and four is closer to ten
thousand then to ten thousand ten
you know so
rounding we have to deal with rounding
and that's the issue
and this this applies for this as well
the issue is against in the rounding
right because I ideally one over nine is
just 0.1 repeating this is a little
notation we use for the fact that we
can't actually stop writing ever or we
will run down
but we have to round down
right to get to fixed number of days we
have to run down so we get this little
number
now if we multiply it we get 9.999 times
10 to the power of minus one minus 1.
which is definitely not one
right these two numbers are no longer
equal
because we round it off the repeating
path because we don't have anywhere to
store it
and the same goes for the last example
right summation goes left to right
so let's go through this
so this is what we started with now next
step we added 1004. ten thousand four is
ten thousand we just did this
and here four plus four is eight this is
simple
Next Step well ten thousand plus four is
still ten thousand this hasn't changed
but eight plus ten thousand pounds up we
are now at ten thousand one ten and thus
they no longer can be equal
okay
so quick recap
so once you are in floats your additions
and multiplications are not associated
you can just change order in which you
evaluate them this will change the
results
then float out of here or unintuitive in
every base
you just have to play slightly with what
is weird about them I have to use one
over nine to get out of base 10 numbers
to get the weirdness but they will
always behave weirdly
and of course the issue there is again
we want fixed its presentation for an
uncountable Infinity
are we all good with this
well then let's talk about Yeti floats
so their base is to their binary right
uh in this is like overview of how many
bits they allocate to which part Monty's
average exponent
this is not really important to remember
in most cases just I just want you to
notice that actually uh the number of
bits in exponent grows for wider floats
this is not true for all formats this is
for IEEE for example hex float IBM don't
grow these are some implications with
how they behave
and like so we have some yeah like the
smallest positive value for 32-bit float
is this 1 times 10 to the power of minus
45 this is small enough to represent the
gravitational constant with a lot of
Reserve
and you know the max value is this which
is much larger than the mass of sun yeah
safe and when we go to the 64 bits
floats so usually double in C and like
we have ridiculous range between them
okay now the cool part about ie is that
actually for a lot of operations you can
make you have guaranteed results right
if you do addition subtraction
multiplication division
and so on
you are fine you always get the same
results from this from the same
operation on the same two numbers on
different computers and platforms if
they actually follow IEEE right this is
always like little asterisk they must
follow the standard
you know so this is good
but this is different from getting
useful results
repeatable correct results are not are
not the same as useful okay
let's go back to this
right this is not correct it's repeated
like okay sorry this is correct in
floats it's repeatable in floats it's
not useful
right
so how do we fix this
well
there is this like naive idea it
actually works for in most cases right
just sum the smaller numbers first the
issue is in the round off so like the
small numbers add them up together you
get bigger number roundoff is less of an
issue
this works pretty well in a lot of cases
so you know don't knock it it's okay
like to start here
but I want to talk about better better
tricks which is consummation this is an
algorithm you can just use made by uh
the same guy who actually came up with
the IE standard
and it will fix this issue it will give
you the correct results for the example
20 million plus one plus one in like
both cases
okay
the cost is that it I think about three
times more computational expensive to
compute than just summing up the numbers
naively
and there is one more issue it doesn't
fix everything right if you get
something like this you it's kind of
silly but it shows the problem right one
plus huge number
plus one nine is a huge number should be
two
right but now if summation gives you
zero for obvious reasons like this is so
huge that this rounds here
this will do nothing and this will then
just you know subtract everything but
consummation actually runs into the same
issue it boils down to the fact that it
assumes that you're running some is
bigger than what you add in if it isn't
it will break like this
again you can fix this there are options
that cost even more computations but
will give you the actual result properly
by the way before I go to multiplication
what about subtraction
what do we do if we need to subtract
members not add them
well
is subtraction different than addition
of negative numbers
no
so there is your answer
let's go to multiplication
uh
so here's an issue there is no good way
to solve multiplication you have to do
it yourself
what you need is you get your you need
to somehow normalize your numbers your
domain you are working in down to one to
you know these nice numbers small
numbers so we don't get run away issues
with the order multiplied and
multiplying away from you
and you know after you're done with the
computation transform it back how
depends on what you are writing I will
give you an example but like another
option is to like look for different way
of computing the stuff you need
and okay so example I'd like to tell you
what is possible I used to do a lot of
work with probabilities now contributes
are small numbers sometimes you get tiny
numbers and when you start multiplying
them the magnitude of your number starts
going way down very quickly you compute
100 probabilities
it's zero
so what did we do
well you can if you multiply numbers is
the same as adding the logarithms
so we took logarithms of the
probabilities
this gave us not much nicer number
we added them all up
and then we converted the number back to
probability by taking the inverse
this is what we could do you have to do
something that depends on whatever you
are working on if you run into this
now this is what we have got guarantees
for IE does not write any guarantees on
transcendental functions you know your
signs your logarithms and so on
definition of
transunction is that it can be expressed
as a finite number of additions
subdirection multiplications uh so on
divisions facing to power okay with the
idea there are functions that you can't
really handle this way
luckily
you can get implementations of something
it's called correctly rounded math
libraries and it sometimes even works
with okay performance I'm not gonna say
good I'm gonna say okay right
uh if you if you meet repeatability in
your signs cosines logarithms and so on
download one of them use them
they have issues they are working
progress and research projects and we
will run into issues slightly
so to recap this part so basic math
operations that we are used to should be
the reproducible
you know must follow I.E standard must
follow it correctly blah blah blah
you can reduce numerical errors in your
computations use the right approach to
what you are computing
and the simplest approach is always to
use wider float right do you have issues
with 32-bit votes use 64-bit floats
don't do anything else until you did
this
now transcendentals are hard that's
where the functions reproducibility is
hard
and slow
okay
so this is a good time for questions
about this part
foreign
so now we have some numbers we probably
computed them correctly maybe not yes
maybe not but we need to compare them
because that's what we often do right we
need to test whether we compute them
correctly and so on
so
this will be fun because there are five
basic ways to compare floats
you can do bitwise comparison
you can do like direct comparison I
don't think it has like real name to it
you can do absolute margin comparison
relative Epsilon comparisons your ulp
based comparisons
and all of these
have some case where you want to use
them
and some downsides when you shouldn't
use them
so you actually should know all of them
at least have some ideality exist and
why
it's not a bit wise comparison
so it says that the two floats are equal
if they are a bit presentation is the
same just like forget Air floats now
there are bit Fields compare the bit
fields are done
this is not the same as what happens if
you write a equals equals B in your code
this is different
okay
and under bitwise comparisons you have
some fun stuff
first is that minus zero and zero are
not equal
this makes some sense it has some issues
and not a number this is special error
value
are equal but they're also not equal
because not a number has many different
ways it can be represented so if you do
bitwise comparisons
it's like it depends which
representation you actually get
so this is the most Niche comparison
like the least likely you will ever need
so let's talk about direct comparison
this actually is what happens when you
write a equals equals B
and when you use it then minus 0 and 0
are equal
okay noun is not
um never
the number is defined to not be equal to
anything including another not a number
and it's useful rarely
only if you have a pretty much exactly
the case where you have like different
implementation of the same stuff and
they should give the same result because
then you don't want any like
um you don't want any margin or error
they should give you exactly the same
stuff
it's like the main uh case where you use
them but actually most often it's a
mistake if you do this
this is why compilers will warn you and
it's super annoying especially because
you had like but in this one case I am
using it correctly no warning let's fix
it
so let's talk about absolute margin
comparison
it's equivalent to writing this you
subtract the two numbers
you take the absolute value and you
check whether it's less than margin in
other in other words you check whether
the distance between the two numbers is
less than some margin you have selected
previously
okay
now the
it has like pros and cons so the big Pro
the big benefit of this it's super easy
to read about like I can give you margin
0.5 what does it mean well two numbers
are equal
if they are within 0.5 of each other
this is easy
like my daughter can do it probably
and it does not break down around zero
right zero to zero point five this makes
perfect sense this is good
issue is that actually is the same as
direct comparisons for large numbers why
rounding again for last number 0.5
rounds to zero you are done there is no
margin
so oh yeah by the way quick quick like
fun fact these are not actually
equivalent for floats even they should
be in math equivalent uh just you know
because the first one
will reject into infinities
as not being similar or equal
while the second one accepts infinities
whether this is correct for you in I
don't know depends on what you are doing
so let's talk about relative margin
comparison
our issue previously was that for large
numbers
the absolute margin just decays to
direct comparison so let's fix it let's
introduce some relative margin some
Epsilon that this can be different from
each other right we say okay so we take
the largest number multiplied by some
small factor and that's our new margin
this scales nicely with large numbers
uh by the way there is actually an
alternate for alternative formulation
you can also use the number of the two
numbers
this behaves slightly differently
that is so important
uh the important part is that when you
do this
it's still easy to reason about right
you can say Okay 0.1 that's ten percent
so the two numbers must be within 10
percent of each other
easy enough
it does not break down for large numbers
it does nothing for zero
if one of the sides is zero or even just
very close to zero you are like
you are again
an exact comparison territory this time
the issue is basically if you have zero
and you have one like then you would
have to subtract 1 from the one to get
to zero so there's hundred percent
margin
this is why it breaks down
so let's talk about ulp comparisons or
units in the last place
basically we that is the idea that there
is distance
ulp distance and it says how did how far
from each other two numbers are in the
float representation how many steps we
have to make to get from one to another
right so
example
the distance of these two numbers is
zero because they are the same
now we change the digit in the last
place by one
so the distance between them is now one
because there is one step from one
um
this takes 100 steps now because we have
changed this 4 into this five
okay so this is the distance
uh brief aside what's the distance
between zeros they got different
positive
I don't know it depends on how you
define this just check with your library
you are using for comparisons what they
do here if you need this
now uh then the two numbers are equal if
the real predictions is less than the
the step like the fixed number that you
picked ahead of time
this is great because it handles both
zero and large numbers gracefully you
say it's within four steps okay one step
two step three step four step for both
huge numbers and Tiny numbers the
relative distance is the same
and this is actually easy to reason
about numerically because I know if I
add two numbers I get at most this much
error in the last place this is great
where does it fall down
okay I will tell you these two numbers
are within 10 ulp units what do you
actually know about the numbers
nothing
like there is limited amount of people
who can actually like think at this
level like naturally and answers I don't
know what it means I can tell you that I
am close I can tell you like what
pipeline guarantees I have but I can't
ever explain this to a customer
customer has no idea what this means
absolutely zero
so let's recap
first there is no Universal approach to
comparing floats that there is a lot of
them you have picked the one that's
right for what you are trying to do
type comparison is usually a mistake not
always but like 90 percent of time maybe
more
you need to under if you are using qlp
distance you need to understand what
your tools actually calculate as the
distance right what do they think is the
distance between negative zero and
positive zero what do they think is the
distance between the largest number you
can represent and infinity and so on
okay
so again this is good place to ask about
this part
well then let's continue
I mentioned that I actually maintain H2
so I have a brief aside
notable catch two what if you want
compare two numbers there
you can use approx
who here uses sketch two
a couple people we reused approx
you shouldn't be using Netflix sorry
this is what it looks like you say okay
something is roughly approximate to
something else
absolute margin comparison relative
margin comparisons and it's Legacy and
you shouldn't be using it
the issue is that the relative margin
comparison is like this weird not
standard comparison that's not something
you should that you can really reason
about
what you should be using is matches
because that looks that looks like this
you can say Okay I want pi to be within
some relative margin of 3.14
and then you have also with an absolute
margin right if anything ulp margin
and this is what I said you need to know
if you have received a library for this
so the distance between zeros is zero
distance between Max and infinity is one
listen between not a number and anything
is just Infinity you can't compare this
meaningfully
now let's talk about limitations
so I already mentioned like non-ie
platforms are an issue right if you
aren't on an IEEE platform you can't use
guarantees from IE standard
this is pretty easy and you know I don't
mean just some small micro that doesn't
even have floating by the unit I mean
stuff like IBM if you are using IBM by
default it uses its own floats it calls
them
X floating points extra decimal floating
point something like this
and they actually like instead of binary
digits use hex the hex digits
accelerating on digits and
they do their own thing actually if you
find yourself on IBM I think you can
tell it to actually use IE floats and
get back to like rest of the humanity
but you know you can have issues with
IEEE platforms as well
for example who here has ever had issues
because all Intel Intel CPUs had 80-bit
computational unit if you compile for
old Intel CPU and 32-bit mode you will
you will likely generate code that uses
the stack based FPU that actually
computes intermediates in 80 bits and
then stores them in 64 bits so suddenly
like your computation can have different
results based on whether it was
based on whether the code you got was
forced to store the intermediate result
back onto the stack
or not
because you will have different
Precision computation and in storage
this is terrible
if you are like targeting Intel 32-bit
please tell it to use SSE for floats
now
languages
so lot of languages for example C plus
plus and C actually like don't give you
any support for I don't know they give
you support they don't give you
guarantees about the floats they can be
IE they can be whatever they feel like
but even if you have language that says
yeah this is always IE like go
then you can find actually like compile
time and runtime behave differently
so who here uses go
nobody you are lucky actually I do have
to use it for work
every now and then so the thing about go
is that when it does math at compile
time
it tries to implement benefit math
it does dislike oh we just compute it
perfectly and then we downgraded we
round it into the float
these are some fun issue
what's your this strength we have a set
a to minus 0.0 we want to print a and
one divided by a
so what should this print
I mean what it should print is obvious
minus zero and uh minus infinity
right so what does it print
is the battery question
well it prints positive zero and plus
infinity
why
because in perfect math
there is no negative zero
that doesn't right in math negative zero
doesn't make sense
so the Google compiler goes and goes
okay so this is constant
so compile time math negative zero at
compile time this doesn't make sense
it's now zero
and so with happily stores zero positive
zero into our a and breaks everything
and but interestingly actually like go
does guarantee you that floats are in
like do use the IE standard at runtime
not a compile time
so let's go to C plus plus
let's say that we actually like write
the same code basically right we have
again some negative zero V store minus
zero there and then we take double
negative Infinity
oh sorry this is supposed to be negative
zero if we divide by uh no this is
correct sorry
uh so we should have negative zero
negative Infinity
let's so before I show what it means who
here thinks that this will print
negative zero negative Infinity
foreign
no takers and you are correct this does
do the right thing we do get minus zero
minus infinity
so what's the issue why did I say that C
plus plus also has issues here
let's change the code a little bit
notice that we edit Concepts we now say
okay but we are at compile time context
and again we write there the same thing
not another negative zero and then we
want negative Infinity
so
what do we get now
who here thinks that this will print
negative zero negative Infinity
positive zero positive Infinity
we have Capital takers
compilation error
because you can divide it by zero at
compile time even though we are in link
floats where you know this is fine this
is something you can do it just should
give you infinity
you know you can't rely on anything
these days
uh by the way like if you want to know
why the issue ball is down to so C plus
doesn't say what standard the floats
follow right
and at compile time the compiler has to
basically interpret the C plus it
supports in expert format
and the committee is not willing to say
that the compiler must be able to
emulate the floating Point model of the
target compilation platform so it just
does get so it gets to do whatever it
wants
no that's not all
still C bus pass you can actually break
IE standard easily with some compilation
Flags right if you ever say for fast
math or super fast for msvc users
all guarantees broken compiler will
start doing whatever it wants
and everything I told you about is a lie
don't rely on it
or you know just oh fast
this sounds like good we are now fast
but it implies fast enough so again
everything I told you stops working
and there is a bunch of like other
smaller flags that you can do this you
know like fun and safe math
optimizations and so on
now
this is not all
it can get worse
your external code the libraries you are
calling can also break you
just for fun
let's have like the sample of some
really evil code right it just goes and
it just stands around it sets rounding
mode and never resets it it just says
from now on all floating for its
operations will round down
and that's it suddenly everything
behaves differently
incidentally this means that like if you
ever write code like this
please first take like query what's the
current mode and then reset it
afterwards right this this is useful to
be able to change it can it's useful to
be able to say I want different rounding
and then get it
but you know it's a global don't touch
globals so you have to reset the state
afterwards
now that's pretty good
so if you want to do floating Point work
you have to know what the guarantees of
your language are
and you know also know when the
guarantees stop working
now comparoflex can actually break IEEE
guarantees so if you need a
reproducibility on floats you have to
like understand what flags you compile
with and also what Flex all of your
dependencies are compiled with
and of course external code can break
reproduciblet as well so if you like
have external dependencies you ideally
need to either audit them or you need to
like defensively reset the FPU state
that you need every time you are back in
your own code
so basically if you actually want to
reproducibility
it's a lot of work
but it's useful
to have it
okay
so
that's pretty much everything
thank you for listening
but before I move to questions I want to
give show you two more things that are
honestly amazing to me
so the first is this fact you can't
constant fault X Plus 0 into X
you can do this it it is invalid
optimization it will break correctness
try to think about why
and the other one is that you can't
constant fault even this
x times zero
you can't say this is zero is obvious
this is still invalid optimization that
you can't do
now
it's time for questions
[Applause]
okay
yeah oh sorry you didn't notice you
uh sorry can you but I will come closer
yeah
okay so the question is back to the
decimal floats I said that we have a lot
of ways to show to represent zero I will
try to go there real quick
just so it is in front of us now
right so the question was about when we
have something like this what do we do
with text representations because you
know we can use two for Infinities and
then we could say use two for total
numbers and what about the rest of them
so there are two answers here one we
cannot care because this is a toy the
actual answer so this is what IE flow
does is that you have something like
52 bits in every not a number that you
can change and you can use this to
encode more information about error so
the answer here is that you could pick
all the externals representations and
just assign them different error
conditions where you return them
okay
anything else
okay I don't think so
so again thank you for listening and
let's go enjoy the end of the conference