A példaprogramok a Java és a matematika című fejezethez kapcsolódnak, az ott leírt programrészletek teljes programjait tartalmazza.
Láthatóvá tesszük a java.math csomag
tartalmát, deklarálunk és létrehozunk BigDecimal
típusú változókat és értékeiket
kiíratjuk.
import java.math.*; // ez minden példához kell
...
BigDecimal a = new BigDecimal(1.23); // létrehozunk egy változót
System.out.println(a); // kiíratjuk az értékét
a = new BigDecimal("-123.456"); // új értékadás
A teljes program: BigDec.java |
Két BigDecimal osztályba tartozó változót
elosztva egymással előfordulhat, hogy az eredmény
végtelen tizedestört, amit csak bizonyos pontosággal
tudunk ábrázolni. Így a divide metódust
használva mindig gondoskodnunk kell arról, hogy milyen kerekítési
eljárást használjon a program.
BigDecimal a = new BigDecimal("10.00");
print(a.divide(new BigDecimal("3"),10,BigDecimal.ROUND_DOWN));
// Az eredmény : 3.3333333333
print(a.divide(new BigDecimal("3"), 10, BigDecimal.ROUND_CEILING));
// Az eredmény : 3.3333333334
A teljes program: divide.java |
A példában a SetScale és a round
eljárások
használatát mutatjuk be.
BigDecimal a = new BigDecimal("1.23");
//A skálázó érték növelése
System.out.println(a.setScale(3)); //Az eredmény : 1.230
//Skálázó érték csökkentése
round(".5", 0, BigDecimal.ROUND_CEILING); //Az eredmény :1
round(".5", 0, BigDecimal.ROUND_DOWN); //Az eredmény : 0
A teljes program: SetScaled.java |
A tizedespontot mozgató operátorok segítségével
lehetőség van a szám pontosságának megőrzése
mellett a szám nagyságrendjének változtatására.
BigDecimal a = new BigDecimal("1.00");
//A tizedespontot balra mozgató operátor
a = a.movePointLeft(1); //a értéke : 0.100
a = a.movePointLeft(-2); //a értéke : 10.0
//A tizedespontot jobbra mozgató operátor
a = a.movePointRight(1); //a értéke : 100
a = a.movePointRight(-3); //a értéke : 0.100
A teljes program: Movepoint.java |
A BigDecimal osztály a valós értékeket
adott pontosággal ábrázolja, így az egyenlő
értékekű, de eltérő skálázó
faktorral rendelkező számokat nem tekinti egyenlőnek.
a = new BigDecimal("1.23");
b = new BigDecimal("1.230");
System.out.println(a.equals(b)); //Az eredmény : false
System.out.println(a.compareTo(b));
//Az eredmény : 0, azaz a és b, mint két string egyenlőek
A teljes program: equal.java |
Létrehozunk BigInteger osztályba tartozó változókat,
értékeiket modosítjuk és kiíratjuk.
BigInteger a = new BigInteger(new byte[]{0x1, 0}); // a értéke : 256
a = new BigInteger(new byte[]{(byte)128}); // a értéke :-128
a = new BigInteger(1, new byte[]{(byte)128}); // a értéke : 128
a = new BigInteger(0, new byte[]{(byte)0}); // a értéke : 0
a = new BigInteger(0, new byte[]{}); // a érétke : 0
a = new BigInteger(-1, new byte[]{(byte)128}); // a értéke :-128
a = new BigInteger(0, new Random()); // a értéke : 0
a = new BigInteger(1, new Random()); // a értéke : 1
a = new BigInteger(32, new Random()); // a értéke : pl. 17950393
A teljes program: BigInt.java |
A BigInteger osztályt kiegészítették
a legnagyobb közös osztót kiszámoló művelettel.
import java.math.*;
import java.util.Random;
class Main {
//A program két szám legnagyobb közös osztóját adja vissza eredményül.
public static void main(String[] args) {
System.out.println(BigInteger.valueOf(0).gcd(BigInteger.valueOf(0)); // 0
System.out.println(BigInteger.valueOf(1).gcd(BigInteger.valueOf(0)); // 1
Random rnd = new Random();
while (true) {
BigInteger a = new BigInteger(64, rnd);
BigInteger b = new BigInteger(64, rnd);
System.out.println("gcd("+a+","+b+")="+a.gcd(b));
}
}
}
A program fáljban: GCD.java |
A program a billentyűzetről beolvas két értéket,
és a két szám közötti értékek
közül kiírja az 1-(0.5)20 valószínűséggel
prím értékeket
import java.math.*;
class Main {
public static void main(String[] args) {
int start = Integer.parseInt(args[0]);
int len = start + Integer.parseInt(args[1]);
for (int i=start; i < len; i++) {
// Leellenőrizzük, hogy prím-e.
if (BigInteger.valueOf(i).isProbablePrime(20)) {
System.out.print(i + " ");
}
}
System.out.println();
}
}
A program fájlban: IsProbablePrim.java |
A fájl a kulcsok generálását és
tárolását oldja meg.
// Létrehozzuk az osztályváltozókat // A nyilvános kulcs private BigInteger p; // A titkos kulcs private BigInteger s; // A moduló értéke private BigInteger N; // Véletlen számként generát prím private BigInteger x; // Véletlen számként generált prím private BigInteger y; // Az osztály konstruktor, mely precision nagyságú p és q prímet generál,
// mely az N moduló kiszámítására használ.
public Keys() {
x = new BigInteger(64, 99, new Random());
y = new BigInteger(64, 99, new Random());
s = new BigInteger(64, 99, new Random());
// Moduló kiszámításához egy 1-0,5^100 valószínűséggel prímet állítunk elő
while(!x.isProbablePrime(100)) {
x = new BigInteger(64, 99, new Random());
}
// Moduló kiszámításához egy 1-0,5^100 valószínűséggel prímet állítunk elő
while(!y.isProbablePrime(100)) {
y = new BigInteger(64, 99, new Random());
}
// A titkos kulcs előállítása, ami 1-0,5^100 valószínűséggel prím
while(!s.isProbablePrime(100)) {
s = new BigInteger(64, 99, new Random());
}
// A nyilvános kulcs előállítása
p = s.modInverse(x.subtract(ONE).multiply(y.subtract(ONE)));
// A moduló előállítása
N = x.multiply(y);
} //getKey() metódus vége
A teljes fájl: Keys.java |
A fájl a szöveg kódolását illetve
annak dekódolását oldja meg.
// Szövegek kódolása
public static BigInteger[] encrypt(String message,
BigInteger publickey, BigInteger modulo) {
byte[] temp;
// Beolvassuk az üzenetet
byte[] digits = message.getBytes();
BigInteger[] bigdigits = new BigInteger[digits.length];
for (int i = 0; i < bigdigits.length; i++) {
temp = new byte[1];
temp[0] = digits[i];
bigdigits[i] = new BigInteger(temp);
}
BigInteger[] encrypted = new BigInteger[bigdigits.length];
try {
for(int j = 0; j < bigdigits.length; j++)
encrypted[j] = bigdigits[j].modPow(publickey, modulo);
}
catch(Exception e) {
return null;
}
return encrypted;
}
// A dekódoló eljárás
public static String decrypt(BigInteger[] encrypted,
BigInteger privatekey, BigInteger modulo) {
BigInteger[] decrypted = new BigInteger[encrypted.length];
try {
for(int i = 0; i < decrypted.length; i++)
decrypted[i] = new BigInteger(encrypted[i].toString()).modPow(privatekey,
modulo);
}
catch(Exception e) {
return null;
}
char[] array = new char[decrypted.length];
for(int j = 0; j < array.length; j++)
array[j] = (char)(decrypted[j].intValue());
return new String(array);
}
A teljes fájl: RSA.java |
| A fájl a felhasználói felületet tartalmazza,
amely tartalmaz egy szövegmezőt az üzeneteink fogadására
és két további szövegmezőt, amelyek a
titkos és a nyilvános kulcsok használatát teszik
lehetővé.
Az applet továbbá tartalmaz három nyomógombot az első új kulcsok generálását teszi lehetővé, a másik két nyomógomb az üzenetek kódolását és visszafejtését teszik lehetővé. // A grafikus felhasználói felület eleme
//Cimkék
private Label titlelabel = new Label("RSA algoritmussal kódoló applet");
private Label statuslabel = new Label("Állapot: ");
private Label messagelabel = new Label("Üzenet:");
private Label publickeylabel = new Label("Nyilvános kulcs:");
private Label privatekeylabel = new Label("Titkos kulcs:");
//Szövegmezők
private TextField publickeyfield = new TextField(40);
private TextField privatekeyfield = new TextField(40);
private TextArea textarea = new TextArea("", 8, 40, TextArea.SCROLLBARS_VERTICAL_ONLY);
//Nyomógombok
private Button encryptbutton = new Button("Kódolás");
private Button decryptbutton = new Button("Dekódolás");
private Button generatebutton = new Button("Új kulcsok");
private Button setpublicbutton = new Button("Nyilvános kulcs beolvasása");
private Button setprivatebutton = new Button("Titkos kulcs beolvasása");
A teljes fájl: RSAClient.java |