16 bit binary representation of unsigned float

Question

3.80/5 (3 votes)

See more:

hi guys;
how do get 16 bit binary representation of unsigned float;
14bit matinssa and 2bit exponent.

I am aware of the IEEE 754 half-precision but it is 10bit to 5 bit 1bit sign

Posted 26-Feb-15 1:09am

Haileab Gebrezgiabher

Add a Solution

4 solutions

Solution 3

[EDIT]
After the many comments in all the solution's threads, I come to the conclusion that this is not a solution to the question.
I leave it nonetheless stand since it shows the approach to build your own class and convert forth and back for calculating and only *store* the value in that particular format.
[/EDIT]

You might consider to make a value type with all the bells and whistles like NaN and Inf handling but calculate all in doubles. E.g.

C#

// encoding: no sign, exp = 2 bits, significand = 14 bits
// exp = 0:    0.significand * 2^0
// exp = 1..3: 1.significand * 2^(exp-1) --> bias = 1
// special values: 0x0000u = zero
//                 0x0001u = NaN
//                 0x0002u = Inf
// there are no negative exponents --> max number = 0xFFFFu --> (2-2^-14)*2^2 = 8-2^-12 = 7.99975586
//                                 --> min number = 0x0003u --> (3*2^-14)*2^0 = 3*2^-14 = 0.00018311
struct F142
{
    private UInt16 _raw;

    private const UInt16 _zero = (UInt16)0x0000u;
    private const UInt16 _naN = _zero + 1;
    private const UInt16 _inf = _zero + 2;
    private const UInt16 _min = _zero + 3;
    private const UInt16 _max = (UInt16)0xFFFFu;

    private const UInt16 _significandMask = (UInt16)0x3FFFu;
    private const UInt16 _unit = _significandMask + 1;

    private const double _dMin = 3.0 / _unit;
    private const double _dMax = 8.0 - 8.0 / _unit;

    private UInt16 Exp { get { return (UInt16)((_raw >> 14) & 0x3); } }

    private void SetFromDouble(double d)
    {
        if (double.IsNaN(d)) _raw = _naN;
        else if (double.IsPositiveInfinity(d)) _raw = _inf;
        else if (double.IsNegativeInfinity(d)) _raw = _naN;
        else if (d < 0.0) _raw = _naN;
        else if (d > _dMax) _raw = _inf;
        else if (d < _dMin) _raw = _zero;
        else
        {
            _raw = _unit;
            while (d >= 2.0 && _raw < 3*_unit)
            {
                _raw += _unit;
                d /= 2.0;
            }
            if (d < 1.0) _raw = _zero;
            else d -= 1.0;
            _raw |= (UInt16)(d*_unit);
        }
    }
    private F142(UInt16 raw) { _raw = raw; }

    public F142(double d) { _raw = 0; SetFromDouble(d); }
    public static readonly F142 Min = new F142(_min);
    public static readonly F142 Max = new F142(_max);
    public bool IsNaN { get { return _raw == _naN; } }
    public bool IsInf { get { return _raw == _inf; } }
    public bool IsZero { get { return _raw == _zero; } }
    public static F142 FromDouble(double d) { return new F142(d); }
    public double ToDouble()
    {
        if (IsNaN) return double.NaN;
        if (IsInf) return double.PositiveInfinity;
        if (IsZero) return 0.0;
        double d = (_raw & _significandMask);
        d /= _unit;
        if (Exp > 0) d += 1.0;
        for (UInt16 i = 1; i < Exp; ++i)
        {
            d *= 2.0;
        }
        return d;
    }
}

Using like this:

C#

F142 res = new F142(3.0/2.0);
F142 nan1 = new F142(0.0 / 0.0);
F142 nan2 = new F142(-5.0);
F142 inf1 = new F142(17.0);
F142 inf2 = new F142(17.0/0.0);

Cheers
Andi

Posted 26-Feb-15 11:37am

Andreas Gieriet

Updated 27-Feb-15 11:25am

v2

Comments

Haileab Gebrezgiabher 27-Feb-15 4:20am

Dear Andi thanks

you have lost me here; i c the filters, the NaN, Inf and zero, i will definitely take your advise there but apart for that could not follow you; may be i will try to run it and see. do i expect a binary value out or a decimal value ?

Andreas Gieriet 27-Feb-15 5:22am

I interpret your question such that
- you work in C#
- have a requirement for a 16 bit floating point value
- 2 bit exponent, 14 bit significand, no sign-bit
I assumed you have similar encoding like a IEEE 754, but
- other number of bits per part (see above: 0,2,14)
- other bias (1)
My suggestion is to only store the numbers in that special format, but calculating to be done in double type. Otherwise, you would have to create a whole bunch of operators and operation (i.e. operator overload or functions for multiply, divide, add, sub, etc... plus a math library for trigonometric and other functions, etc.).
So, the simple solution:
- define a value type that stores these 16 bits
- define two conversions (from/to double) for this value type
- for convenience, add a constructor of this type taking a doublevalue
- handle all the Inf/NaN, etc. special situations
- handle all out-of-range situations --> NaN, Inf
I did not know your interpretation of the exponent and the significand and the special values. So, I did assume something and documented in the type definition.

No, I have no IEC62055-41 spec at hand. but maybe you can provide the relevant text snipped and tell more about the use case (e.g. only transport and print, or also calculate (and what is the expected error concept: out-of-range, not-a-number, etc.?).
Cheers
Andi

Haileab Gebrezgiabher 27-Feb-15 6:18am

please don't get me wrong i am just looking for clarity; as to the doc i do understand i am great full you spending ur time to help out;

as to the doc don't mind sharing the portion for the discussion purpose(copyright issues) i dont see attachment or other tools i can use on this forum

in any case this is what is required

say i want a single binary string representation of 25.6 in 16bit 2bit exponent and 14 bit mantissa;
this is suppose to give me 0000 0001 0000 0000
and another example 1638.3 == 0011 1111 1111 1111

Andreas Gieriet 27-Feb-15 8:19am

You need to read the specs carefully. This is a protocol definition that splits the whole "floating point" number into a s,e4,e3,e2 part plus a e1,e0,m13...m0 part. Combined, you have a floating point number of 20 bits: sign-bit, 5 exponent bits, 14 mantissa bits. The meaning of that number is defined too in that spec.
I.e. whatever you calculate in some program, you have to convert into that bit pattern to transfer it.
Cheers
Andi

Solution 1

Two bit exponent?
Are you sure?
That's not a lot of range 10^0 to 10^3 only.

AFAIK there is no "standard" implementation of a float using that resolution: you will have to implement it yourself.

Posted 26-Feb-15 1:19am

OriginalGriff

Comments

Haileab Gebrezgiabher 26-Feb-15 7:28am

thx men; that is very fast response

I know what you mean, but the task is to represent the exponent with 2 bit; bit 15 being the most significant of the exponent bit bit 13 is of the mantissa ...

I figured that much about the standards, was wondering if someone can point me to the right direction,

Andreas Gieriet 27-Feb-15 4:20am

Why 10^0...10^3? Shouldn't it be 2^0...2^3 (or even 0...2^0...<2^4)?
Andi

Haileab Gebrezgiabher 27-Feb-15 5:00am

this i think is the exponent ... the exponent as a number is expressed in base ten basically OriginalGriff is talking about the range of the exponent is from 0 to 3 inclusive

Andreas Gieriet 27-Feb-15 5:28am

Yes, understood: two bits only allow for four values 0..3.
In floating point binary encoding, the exponent is as I know it always to the base of two, if the significand is also to the base two. Other encodings may be applied, but then the significand and the exponent must be to the same base - otherwise you had holes/overlap in your number ranges.
So: either all is to the base 2 or to some other base (e.g. 10).
Maybe you could provide a unambiguous and complete spec of what this floating point encoding is to be.
Cheers
Andi

Andreas Gieriet 27-Feb-15 17:34pm

The format as given in that mentioned IEC62055-41 document is capable to store values from 0 to 18201624 with a precision of 4 decimal digits (with some odd gaps between the exponents). See my comment in solution 2.
For currencies, that "floating point" representation is extended to one sign bit, five exponent bits (0 ... 10^31) and still 14 bits mantissa (4 digits precision).
Cheers
Andi

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Andreas Gieriet · Accepted Answer · 2015-02-28T02:46:00

[EDIT]
Modified such that it scales to units.
[/EDIT]

The following should work for a IEC62055-41 unsigned 2-bit-exponent 14-bit-mantissa fixed point value:

C#

public enum As
{
    Raw,      // raw number     - unit = 1.0
    Energy,   // kWh            - unit = 0.1
    Power,    // W              - unit = 1.0
    Water,    // m3             - unit = 0.1
    Gas,      // m3             - unit = 1.0
    Time,     // min            - unit = 1.0
    Currency, // local currency - unit = 0.00001
}

public struct FixU_2_14
{
    private UInt16 _raw;

    public UInt16 Bits { get { return _raw; } }

    public double this[As unit]
    {
        get
        {
            double mantissa = _raw & 0x3FFF;
            double n = 1.0;
            double m = 0.0;
            for (int i = (_raw >> 14) & 0x3; i > 0; --i)
            {
                n *= 10.0;
                m *= 10;
                m++;
            }
            double value = n * mantissa + m * 16384;
            switch (unit)
            {
                case As.Energy:
                case As.Water: return value / 10.0;
                case As.Currency: return value / 10000.0;
                default: return value;
            }
        }
    }
    public FixU_2_14(double value, As unit)
    {
        if (double.IsInfinity(value) || double.IsNaN(value))
        {
            throw new ArgumentOutOfRangeException("value", value.ToString());
        }
        switch (unit)
        {
            case As.Energy:
            case As.Water: value *= 10; break;
            case As.Currency: value *= 10000; break;
            default: break;
        }
        if (value < 0.0 || value > 1111.0 * 16384.0 - 1000.0)
        {
            throw new ArgumentOutOfRangeException("value", value.ToString());
        }
        _raw = 0;
        double n = 1.0;
        double m = 0.0;
        double max = 0.0;
        UInt16 exp = 0;
        while (true)
        {
            max = n * 16383 + m * 16384;
            if (max >= value) break;
            n *= 10;
            m *= 10;
            m++;
            exp++;
        }
        value -= m * 16384;
        value /= n;
        _raw = (UInt16)((exp << 14) | (int)value & ((1 << 14) - 1));
    }
}

Some usages:

C#

static void WriteFix(double d, As unit)
{
    string us = string.Format("{0}", "["+unit.ToString()+"]");
    FixU_2_14 fp = new FixU_2_14(d, unit);
    double dd = fp[unit];
    Console.WriteLine("{0,9} {4,-10} -> 0x{1:x4} = {2,9} {4,-10} (Delta = {3,3})", d, fp.Bits, dd, d - dd, us);
}
...
WriteFix(0.0, As.Raw);
WriteFix(1.0, As.Water);
WriteFix(2.0, As.Currency);
WriteFix(25.6, As.Energy);
WriteFix(1638.3, As.Energy);
WriteFix(16384, As.Water);
WriteFix(18201624, As.Gas);
for (int i = 1; i <= 18; i++) WriteFix(1000000 * i, As.Gas);

This results in

       0 [Raw]      -> 0x0000 =         0 [Raw]      (Delta =   0)
       1 [Water]    -> 0x000a =         1 [Water]    (Delta =   0)
       2 [Currency] -> 0x4169 =    1.9994 [Currency] (Delta = 0.000599999999999934)
    25.6 [Energy]   -> 0x0100 =      25.6 [Energy]   (Delta =   0)
  1638.3 [Energy]   -> 0x3fff =    1638.3 [Energy]   (Delta =   0)
   16384 [Water]    -> 0x7999 =   16383.4 [Water]    (Delta = 0.600000000000364)
18201624 [Gas]      -> 0xffff =  18201624 [Gas]      (Delta =   0)
 1000000 [Gas]      -> 0xa005 =    999924 [Gas]      (Delta =  76)
 2000000 [Gas]      -> 0xc0b5 =   1999624 [Gas]      (Delta = 376)
 3000000 [Gas]      -> 0xc49d =   2999624 [Gas]      (Delta = 376)
 4000000 [Gas]      -> 0xc885 =   3999624 [Gas]      (Delta = 376)
 5000000 [Gas]      -> 0xcc6d =   4999624 [Gas]      (Delta = 376)
 6000000 [Gas]      -> 0xd055 =   5999624 [Gas]      (Delta = 376)
 7000000 [Gas]      -> 0xd43d =   6999624 [Gas]      (Delta = 376)
 8000000 [Gas]      -> 0xd825 =   7999624 [Gas]      (Delta = 376)
 9000000 [Gas]      -> 0xdc0d =   8999624 [Gas]      (Delta = 376)
10000000 [Gas]      -> 0xdff5 =   9999624 [Gas]      (Delta = 376)
11000000 [Gas]      -> 0xe3dd =  10999624 [Gas]      (Delta = 376)
12000000 [Gas]      -> 0xe7c5 =  11999624 [Gas]      (Delta = 376)
13000000 [Gas]      -> 0xebad =  12999624 [Gas]      (Delta = 376)
14000000 [Gas]      -> 0xef95 =  13999624 [Gas]      (Delta = 376)
15000000 [Gas]      -> 0xf37d =  14999624 [Gas]      (Delta = 376)
16000000 [Gas]      -> 0xf765 =  15999624 [Gas]      (Delta = 376)
17000000 [Gas]      -> 0xfb4d =  16999624 [Gas]      (Delta = 376)
18000000 [Gas]      -> 0xff35 =  17999624 [Gas]      (Delta = 376)

Cheers
Andi

Sergey Alexandrovich Kryukov · Accepted Answer · 2015-02-26T03:26:00

Solution 2

You are right, IEEE 754 is 1 sign bit, 5 bits for exponent, other bits for mantissa:
http://en.wikipedia.org/wiki/Half-precision_floating-point_format[^],
http://en.wikipedia.org/wiki/Floating_point[^].

14-bit mantissa and 2-bit exponent could be your or someone else's fantasy and can hardly be efficient representation for most general numeric chores, but yes, I can imagine its use for some special applications. But what's the problem? Handling such would come at costs (first of all, you will have to check up that all input values are in valid ranges for this type, in all operations; bitwise operations are faster).

First, you create two bit masks and keep them 3 << 14 is the mask for exponent (0-3 values, shifted to most-significant end), its complement will be the mantissa mask. To create your number, check the ranges of mantissa and exponent, and then OR them together, it will be (exponent >> 14) | mantissa. To extract mantissa and exponent, AND the number with mantissa and exponent masks. Then, for mantissa, also shift it >> 14, the get mantissa value. Then use normal floating point arithmetic to get the resulting value, if you need it.

—SA

Posted 26-Feb-15 3:26am

Sergey Alexandrovich Kryukov

Comments

Haileab Gebrezgiabher 26-Feb-15 12:37pm

Dear SA, thank you for your response, you are very right my reaction when saw the spec was not short of what you mentioned, however the spec was very specific on that regard; and you are right again it is a very specific application.

I saw you explanations it makes perfect sense; i see some light at the end of the tunnel thanks. please allow me to play with the idea you gave and get back to you all.

Sergey Alexandrovich Kryukov 26-Feb-15 12:42pm

As I already said, I can imagine that this spec is good for something. For example one of HDR (high dynamic range) image formats has a custom floating-point pixel format.

Will you accept my answer formally now? If you need some more detail, please feel free to ask, I'll answer in all cases.

—SA

Haileab Gebrezgiabher 26-Feb-15 13:33pm

sorry i didn't mark it as so i am actually trying it as we speak. any detail will always help, i can see you are proficient on the matter. will mark it answered now.

and thank you Sergey !

Sergey Alexandrovich Kryukov 26-Feb-15 15:21pm

Nothing to sorry about; everything goes write. Thank you for accepting it, but, if you have further issues, feel free to ask your questions, possibly the follow-up questions in this space. We did not consider the interpretation of mantissa and exponent (signed or non-signed, which also translates in having fractional numbers, what is the signer representation if you need it; it all should be somehow mentioned in your specs and can be treated differently). I'll gladly help and foresee no big problems.
—SA

Haileab Gebrezgiabher 27-Feb-15 4:13am

hi thx;
the sign is always positive any negative value is filtered out from the interface before it comes to the equation.

we are measuring the transfer of energy value. here is the mathematical equation:

where e is exponent;
m is mantissa;
t is transferred energy;

t = (10^e * m) for e =0;

t = (10^e * m) + sigma of{e, n=1} (2^14 * 10^(n-1)) for e>0;

Andreas Gieriet 27-Feb-15 4:19am

Why is the exponent to the base of 10 instead of 2? Binary representations of floating point numbers usually base all on 2: the mantissa is binary number as well as the exponent is a binary number to the base 2.
I'm confused.
Cheers
Andi

Sergey Alexandrovich Kryukov 27-Feb-15 8:37am

I would assume this is on the spec, as the inquirer mentioned before. It's not "usually", the whole thing.
—SA

Andreas Gieriet 27-Feb-15 12:09pm

You are right.
I skimmed through part of that spec. It is not about calculating anything, it's about transferring some physical and monetary values in some protocol that even splits some values into 4 bits somewhere and 16 bits elsewhere. The raw floating point values then get scaled to some base unit (e.g. 10^-5 currency units, etc.), depending their usage (some tag say what it is).
Cheers
Andi

Sergey Alexandrovich Kryukov 27-Feb-15 15:15pm

Right, that's the point. This is the second time where I met non-standard numeric type representation (not counting stupid hardware interfaces not using 2s-complement integer representation, not even ones' complement, but using a separate sign bit, hence having separate -0 and + 0 :-). That is one of HDR (Hight Dynamic Range) bit formats, where it was, I think, quite reasonable...
—SA

Andreas Gieriet 27-Feb-15 5:38am

BTW: what means [(10)] in your text above?
Do you know this: "There are exactly 10 kind of people: those who know binary encoding and those who don't." ;-)

Sergey Alexandrovich Kryukov 27-Feb-15 8:43am

All right, it tells you what is the value represented by you 14+2 bit format. You extract mantissa and exponent the way I suggested and use this formula to get value. As the exponent is always non-negative, you always get integer values. So, basically, this 14+2 representation is the way to store integer values, which is weird.
However, I did not understand "sigma of" part. What is n?
—SA

Haileab Gebrezgiabher 27-Feb-15 11:21am

hi all;

t=((10^e)*m)+∑((2^14)*(10)^(n-1))

sigma i mean ∑; apologies for the confusion

its upper value is e and lower value is 1 hence (n=1)
now, this formula is somehow suppose to give us the binary values and it does not say any more than that except i must use it.

now according to the spec this formula is somehow to make it easy for me to represent the value using binary notation.

here the mathematical part i have done
example represent 25.6;

25.6 => 0.256 * 10^2
m = 256
e = 2

now
t = ((10^2) * 256) + (2^14 * 10^0) + (2^14 * 10^1) ==> here i have expanded ∑((2^14)*(10)^(n-1))

t = 25600 + 16384 + 163840

now i have tried
converting them individually to binary and '&' them ;
adding them and converting them
take the intermediate values ... etc it seems i am missing something

now i am trying to make sense out of these values and how the formula actually works so i can double check values with the working code (i am busy trying Sergey suggestion for now) for any unforeseen calculation errors.

NB Andreas the spec is a two paragraph text and the formula i gave you and it is exactly what i described here, i am more than willing to share it i just cant find a way to do it here on the discussion forum

hope this makes sense

Sergey Alexandrovich Kryukov 27-Feb-15 11:28am

All right, I hope you are close to the solution. I would advise you to define the structure representing this numeric type, with methods. One method should return "semantic" value of the structure. You can use this as any value type, it will occupy only 16 bits, if you avoid other fields (some intermediate fields like masks could be static).
—SA

Andreas Gieriet 27-Feb-15 16:45pm

This STS ASSOCIATION COMMENT FORM gives some hint on the number schema. Who invents such a scheme?! There must be some reason... not obvious, though. It has obviously some value overlaps between exponent steps (see table 7)!

If you make a table for the 4 exponents (0,1,2,3), then you get the value formula. E.g.
exponent = E: value = N x mantissa + M x 16384
exponent = 0: value = 1 x mantissa + 0 x 16384
exponent = 1: value = 10 x mantissa + 1 x 16384
exponent = 2: value = 100 x mantissa + 11 x 16384
exponent = 3: value = 1000 x mantissa + 111 x 16384
...

Caution: the values get scaled by the given units
- electrical energy = [0.1 kW]
- water = [0.1 m3]
- gas = [1 m3]
- time = [minute]
- currency = [0.00001 currency]

To convert from an arbitrary value to this encoding, you must calculate the boundaries for the exponents. For each exponent to the next, there is a overlap of N numbers, where N is the fist factor in the formulas above, e.g. for exponent = 0: N = 1, ..., exponent 3: N = 1000, etc.

The minimum and maximum values per exponent are
exponent = E, min = M x 16384, max = N x 16383 + min
exponent = 0: min = 0 x 16384, max = 1 x 16383 + 0 x 16384
exponent = 1: min = 1 x 16384, max = 10 x 16383 + 1 x 16384
exponent = 2: min = 11 x 16384, max = 100 x 16383 + 11 x 16384
exponent = 3: min = 111 x 16384, max = 1000 x 16383 + 111 x 16384
...

With these boundaries, you can calculate into which boundary your current value goes and calculate the exponent and from there the mantissa. The values in the overlap seem to be rounded up to the next exponent. The overlaps do not cause any harm since the precision is anyways 4 decimal digits only and the overlap increase linearly with the exponent.

Cheers
Andi

Haileab Gebrezgiabher 28-Feb-15 4:41am

Dear Andi;

you are quite right, it is STS , standard transfer specification (sts.org.za) invented in south africa and adopted by IEC. I didnt think it is relevant but now i see that it may have some academic value for us to share it. It is basically for prepayment electricity. Apart from it being very peculiar and different, it is very stable and one can see they have put so much good work on it. Few days ago I thought is was wiered but now i am convinced that they had a very good reason i just cant wait to discover. It may lead to a different thinking all together. In any case i want to bring the following to your attention as a matter of discussion:
@SA

thank you i am trying some times i get so close to it and it falls apart again ... lol but getting there

@Andi

the scaling values you said ... (electrical, gas etc ..) yes you are right but we don't need to bother for that it is already will be taken care of by another process after the transfer value is calculated. it does not have to be encoded in to the value we are trying to calculate.

therefore it still holds that the value is 2bit exponent + 14bit matinssa no sign (everything positive)

as to the table you have pointed it out perfectly clear! in fact it also corresponds with what the formula (the one i gave earlier) is trying to do; After your question about the formula the other day, i tried the derivation and i came up with similar table you put up here and i found another supporting document NRS009,

exponent------transfer_amount_range--------maximum error
0---------- 0000000 to 00016383-----------0.000
1-----------0016384 to 00180214-----------0.061%
2-----------0180224 to 01818524-----------0.055%
3-----------1818624 to 18201624-----------0.055%

this table is given as accepted error values reference (also by the IEC document) but i want to use it to confirm the values you deduced and the patter you discovered.

my last point;
you commented that the solution you gave (solution 3) as 'not correct', actually it is the closest i have come to what Sergey suggested, infact i used your way of doing it on the filtering the input values, and masking, we may need to work on the return and usage.

the return = exponent(&)matinsa (16bit)

here is similar approach i found as well
http://www.yoda.arachsys.com/csharp/DoubleConverter.cs

guys as much as i am pressed for time and have tones of other things to put together i am enjoying this conversation.

i wanted to upload the IEC document (relevant section) for academic discussion purpose here on the form, how does one go about doing that?

AND thank you all for the indispensable knowledge you giving me and guiding my thinking process

Andreas Gieriet 28-Feb-15 5:50am

No direct solution. You may store it into any publicly accessible repository of your choice and add a link to that in this forum.
Cheers
Andi

Haileab Gebrezgiabher 28-Feb-15 6:21am

i c, will try that

Andreas Gieriet 28-Feb-15 6:49am

BTW: strictly speaking, this is not a *floating point* representation. It only allows to store integral numbers (in given units).

And: the STS document I referred to adds 4 more bits: 3 additional bits for the exponent and one sign bit - this is for currencies: currency values can be negative (pay-back) and larger (exponent 0...31, but the unit is 0.00001 currency unit).

Maybe you are only interested in the physical values, then the 14-2 values are fine.

Cheers
Andi

Haileab Gebrezgiabher 28-Feb-15 7:10am

yes you can say that, and yes you are right all i am requiring is the 'physical value' as you put it, the whole project need far more than what we discussing and i am done for most part it is this little tweak that is holding me back, in fact the final result of what we discussing is going to go in to Hex value for transfer as a parameter to another process and i have figured out to get there in a different way but my assignment is to adhere to the specs given for approval, don't want to take chances plus it is a chance to learn something.

Haileab Gebrezgiabher 27-Feb-15 4:28am

same here; dear Andi i am hopping that some one can see what i am missing. i just don't have the courage to say it is wrong equation as it comes from the well established IEC standard document. not sure if you aware it is IEC62055-41 pp 38

Andreas Gieriet 27-Feb-15 5:40am

No. Can you provide the relevant part? I will not buy a standard document to answer a Q&A question - I hope you understand ;-)
Cheers
Andi