BigInteger!!

Med 949^853 mener du vel potens? Har du prøvet med Math.pow() metoden?

ja, desværre... Math.pow tager kun double, det er for lidt!

BigInteger har en pow metode.
BigInteger bi = new BigInteger(..);
bi.pow(853);

Mener da, at ^ tegnet bruges til at lave right og left shit... 2 min..

post din code

Får en "NaN" når den udskrives...

shift! *g*

Den har også en mod metode:
http://java.sun.com/j2se/1.4/docs/api/java/math/BigInteger.html

magoo, nej det er << og >> du tænker på, ^er potens

BigInteger temp=(keys.beta).pow(keys.k);
temp.multiply(M);
y2=temp.mod(keys.p);

beta er 949, k er 853, M er 1299 og p er 2579

>> Disky... Du har helt ret! Det er vist min sengetid... Pinligt at jeg blander det sammen!

Jeg får 2306:

import java.math.BigInteger;

public class Big {
    public static void main(String[] args) {
        BigInteger v = new BigInteger("949");
        v = v.pow(853);
        v = v.multiply(new BigInteger("1299"));
        v = v.mod(new BigInteger("2579"));
        System.out.println(v);
    }
}

Arne:
Jeg får 2396 med dit eksempel - men det er vel en tyrk fejl fra din side ?

Det skal give 2396!! Det får en "Maple" (et matematik-program) og fag-bogen..

Ja.

Jeg ramte ved siden af.

Bamse>

Det gør den også. Det jeg ramte bare 0 da jeg sigtede efter 9 !

:-)


Prøv selv !

import java.math.BigInteger;

/**
* Created by IntelliJ IDEA.
* User: Søren Reinke
* Date: Mar 26, 2003
* Time: 9:38:38 PM
* To change this template use Options | File Templates.
*/
public class StoreTal
{
    public StoreTal()
    {
        /*
        ( 1299 * 949^853 ) mod 2579 = 2396
        */
        BigInteger tal1=new BigInteger("949");

        tal1=tal1.pow(853);
        tal1=tal1.multiply(new BigInteger("1299"));
        tal1=tal1.mod(new BigInteger("2579"));
        System.out.println("resultat = "+tal1.toString());

    }
    public static void main(String[] args)
    {
        new StoreTal();
    }
}

Som giver det forventede resultat.


bamse, dit problem er denne linie:
temp.multiply(M);

ret til
temp=temp.multiply(M);

okay... det får jeg også med jeres eksempel! Tak, men hvad hvis

v = v.pow(853);

853 er et BigInteger istedet, f.eks. k?

pow er kun med int !

Du må bruge k.intValue() !

bamse2000:

API'en fra SUN er din ven, der kan du se hvilke metoder du kan kalde på BigInteger objekter.

Eller hvis du bruger et ordentligt udviklingsværktøj som f.eks. IntelliJ så kan den vise dig det.

hm... hvor langt kan et "int" blive? jeg skal bruge store k-værdier...
Men tror jeg har fundet ud af noget... tak!

tak disky, har kigget...

2.1 milliard

Igen, api'et:
System.out.println(Integer.MIN_VALUE);  //-2^31
System.out.println(Integer.MAX_VALUE);  //2^31-1

okay, det er fordi jeg laver en opgave i cryptering, hvor k skal være et 512-bit langt primtal....

Hvad er du egentligt ved at regne ud ?

De tal du bruger er størrer end antal atomer i universet (hvis man skal tro min fysik bog)

ah :-) tak for svaret.

En special pow:

import java.math.BigInteger;

public class Big {
    public static void main(String[] args) {
        BigInteger v = new BigInteger("949");
        v = pow(v, new BigInteger("853"));
        v = v.multiply(new BigInteger("1299"));
        v = v.mod(new BigInteger("2579"));
        System.out.println(v);
    }
    private final static int scale1 = Integer.MAX_VALUE;
    private final static BigInteger scale2 = new BigInteger(Integer.toString(scale1));
    public static BigInteger pow(BigInteger b, BigInteger k) {
        BigInteger k2 = k;
        BigInteger res = new BigInteger("1");
        while(k2.compareTo(scale2) > 0) {
            res = res.multiply(b.pow(scale1));
            k2 = k2.subtract(scale2);
        }
        res = res.multiply(b.pow(k2.intValue()));
        return res;
    }
}