Alternativ til float datatype

Jeg kender ingen compilere med 2 byte floating points.

Hvis tallene er rimeligt ens i størrelse kan du bruge 2 byte
fixed point (integer med implicit decimal point).

Svaret afhænger vel af hvilken præcision du skal have. Hvis du blot skal gemme tal med decimaler, kan du lave din egen datatype med et par funktioner til at konvertere frem og tilbage mellem float. Hvis du skal regne på din datatype, bliver det straks sværere - og så bliver der også problemer med afrundingsfejl, som kan have stor betydning i så komplekse beregninger.
En søgning på fixed-point arithmetic i google giver en del resultater.

TAX: du er godt klar over at du mister en enorm precision som kan betyde at videre behandling af dine data kan give andre resultater efter at du har gemt og hentet igen, se kaos-teori.

Jeg er klar over at jeg kan bruge en short, og blot dividere den med en fast værdi for at få værdien. Men divisioner er dyre. Derfor tænkte jeg at der måske var et alternativ.

En ide:

Man kunne bruge en short (2bit heltal), og shifte bits for at få den ind i en float's mest betydende cifre?

Det ville gå meget hurtigere end at dividere normalt.

I princippet er det vel muligt hvis du ved nok om exponenter, matrisser og hvordan de fysisk gemmes at udlede dette. Jeg tvivler dog på at floats der er presset ind i 2 byte beholder precission nok til ikke at gøre beregningerne værdiløse.

//et par defines, du må selv afgøre, hvilken præcision, der skal bruges:
//en byte til heltalsdel, en byte til brøk:
#define precision 8
#define fix2float(x) (((float)(x))>>precision)
#define float2fix(x) ((short)((x)<<precision))

stefan>

Prøv selv !

(jeg kender ingen compilere der kan shifte en float)

#include<stdlib.h>
#include<stdio.h>

//Fixed point aritmatik
typedef short freal;
#define FPP 4
#define X1_0 (1<<FPP)
#define I2X(x) ((freal)((x)<<FPP))
#define F2X(x) ((freal)((x)*X1_0))
#define X2I(x) ((int)((x)>>FPP))
#define X2F(x) ((float)(x)/X1_0)
#define XM(x,y) ((freal)(((x)*(y))>>FPP))
#define XD(x,y) ((freal)((((x))<<FPP)/(y)))


void main()
{
    freal a;   
    for(float x=-10;x<=10; x=x+0.1)
    {   
        a = F2X(x);
        printf("\n%+.5f %+.5f %d", x,  X2F(a), sizeof(freal));
    }
    getchar();
}

Det er fixed point i 16 bit med en scale på 16. Lidt usædvaneligt
med en scale som ikke er en potens af 10, men det er selvfølgeligt
nødvendigt for at kunne shifte i.s.f. at dividere.

Hvis dine tal ligger i det rigtige range (ca. -2000..2000) og
du kan leve med en regne unøgagtighed op til 37.5%, så er det fint.

arne_v: du har sikkert ret i det med at shifte en float - det giver nok ingen mening, i det hele taget er problemet nok, at der ikke er en fornuftig løsning med de givne betingelser...

Det her har muligvis relevans (selv økonomi delen er nok ikke så spændende i det her sammenhæng, men Lorentz referatet har).
Fra: http://www.e-rasmussen.dk/economics/organisation.php

En af pionererne indenfor kaos- og kompleksitetsteorien er Edward Lorentz. Han beskæftigede sig som udgangspunkt med meteorologi og var fascineret af vejrets omskiftelighed, og meteorologernes problemer med at forudsige vejret ganske få dage ud i fremtiden: Her hober fejl og unøjagtigheder sig op i systemet, hvorefter de tilsidst resulterer i uforudsigelige vejrsituationer. Lorentz opstillede en oversimplificeret vejrmodel med 3 ligninger. Ved imidlertid at ændre modellens initialværdier med 1/1000, ændrede modellens opførsel sig fuldstændigt (se bilag 1). Lorentz indså herefter, at "ethvert fysisk system, der opfører sig ikke-periodisk, er uforudsigeligt."

tax>

Er du kommet videre ?

Jeg lavede nogle forsøg med at shifte nogle bits og caste til en mindre type. Det virkede, men jeg er ikke færdig med at virdere præcisionen af metoden.

Jeg kender ikke engang området værdierne ligger i i min appliktion endnu.

Det med 2 byte floating points, må jeg prøve, men indtil videre har jeg problemer nok blot med at få det til at spille med floats alene.