bruge int/long istedet for double?

Tja.

fixed point = int med cifre + byte som angiver antal decimaler

parse: cifre = parse uden punktum, antal decimaler = tal efter punktum

add/sub: skaler tal så antal cifre er ens (*10 og +1), normal add/sub

mul: cifre = mul, antal decimaler = add

etc.

(måske)

ja det er nok den vej man skal, desværre ikke noget jeg har tid til lige nu ;)

men jeg har heldigvis fundet MathFP
http://home.rochester.rr.com/ohommes/MathFP/

smidt et svar

ok (selvom jeg ikke synes at jeg har bidraget med meget)

PS: Jeg tror iøvrigt at jeg har liggend enoget C++ fixed point kode ...

det vil jeg da godt se.

men jo du har hjulpet rigeligt, da jeg så hvor besværligt det ville være googlede jeg lige et par gange til ;)

Jge poster det i aften.

Jeg kan ikke finde det kode.

:-(

Som kompensation lavede jeg lige noget simpel kode som viser hvor simpelt det er:

public class FixedPoint {
    private int scalval;
    private byte ndec;
    private final static int[] scal = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000 };
    public FixedPoint(int val, int ndec) {
        scalval = val * scal[ndec];
        this.ndec = (byte)ndec;
    }
    public FixedPoint(String val, int ndec) {
        this(Integer.parseInt(val), ndec);
    }
    private FixedPoint(int scalval, byte ndec) {
        this.ndec = ndec;
        this.scalval = scalval;
    }
    public FixedPoint add(FixedPoint fp) {
        if(this.ndec != fp.ndec) {
            throw new RuntimeException("Different scale");
        }
        return new FixedPoint(this.scalval + fp.scalval, this.ndec);
    }
    public FixedPoint sub(FixedPoint fp) {
        if(this.ndec != fp.ndec) {
            throw new RuntimeException("Different scale");
        }
        return new FixedPoint(this.scalval - fp.scalval, this.ndec);
    }
    public FixedPoint mul(FixedPoint fp) {
        if(this.ndec != fp.ndec) {
            throw new RuntimeException("Different scale");
        }
        return new FixedPoint(this.scalval * fp.scalval / scal[this.ndec], this.ndec);
    }
    public FixedPoint div(FixedPoint fp) {
        if(this.ndec != fp.ndec) {
            throw new RuntimeException("Different scale");
        }
        return new FixedPoint(this.scalval * scal[this.ndec]/ fp.scalval, this.ndec);
    }
    public String toString() {
        return Integer.toString(scalval / scal[ndec]) + "." + Integer.toString(scalval % scal[ndec]);
    }
    public static void main(String[] args) {
        System.out.println((1.0+2.0)*3.0/4.0);
        FixedPoint one = new FixedPoint(1, 2);
        FixedPoint two = new FixedPoint(2, 2);
        FixedPoint three = new FixedPoint("3", 2);
        FixedPoint four = new FixedPoint("4", 2);
        System.out.println(one.add(two).mul(three).div(four));
    }
}

nice.. jeg er også kun lige begyndt at læse rigtigt på c++ så java er nok bedre :)
og MathFP bruger en masse bitwise operators så det forstår jeg ikke meget af, men det her eksempel ser ud til at kunne gøre det.
Mange tak for hjælpen.