Thanks for the quick answer.
And for the code optimizing, its only a short extract of a gps program.
I know there's much more optimizing needed...
I'll do it later ^^

Now i've a problem with sin-function, e.g. in line 15.
why isn't it possible to convert it with float(...)?

double n = a/sqrt(1-e2*sq(sin(float(br/180*PI))));

1. double br_grad=47;
2. double br_min=39;
3. double br_sek=19.33;
4. double la_grad=10;
5. double la_min=4;
6. double la_sek=3.97;
7. double hohe= 4.21;
8. int syst=5;
9. final double a= 6378137;
10. final double b= 6356752.314;
11. final double a2= a*a;
12. final double e2= (a2-b*b)/(a2);
13. double br= br_grad + br_min/60 + br_sek/3600;
14. double la= la_grad + la_min/60 + la_sek/3600;
15. double n = a/sqrt(1-e2*sq(sin(br/180*PI)));
16. double x = (n+hohe)*cos(br/180*PI)*cos(la/180*PI);
17. double y = (n+hohe)*cos(br/180*PI)*sin(la/180*PI);
18. double z = (n*sq(b)/sq(a)+hohe)*sin(br/180*PI);
19. double[][] tp=new double[5][8];//Tabelle4 eingeben (ohne Region)
20. for(int i=0; i<5; i++) {
21.   tp[i][0]=i+1;
22. }
23. tp[0][1]=582.0;
24. tp[0][2]=105.0;
25. tp[0][3]=414.0;
26. tp[0][4]=-1.040;
27. tp[0][5]=-0.350;
28. tp[0][6]=3.080;
29. tp[0][7]=8.300;
30. tp[1][1]=598.1;
31. tp[1][2]=73.7;
32. tp[1][3]=418.2;
33. tp[1][4]=-0.202;
34. tp[1][5]=-0.045;
35. tp[1][6]=2.455;
36. tp[1][7]=6.700;
37. tp[2][1]=584.8;
38. tp[2][2]=67.0;
39. tp[2][3]=400.3;
40. tp[2][4]=-0.105;
41. tp[2][5]=-0.013;
42. tp[2][6]=2.378;
43. tp[2][7]=10.290;
44. tp[3][1]=590.5;
45. tp[3][2]=69.5;
46. tp[3][3]=411.6;
47. tp[3][4]=0.796;
48. tp[3][5]=0.052;
49. tp[3][6]=3.601;
50. tp[3][7]=8.300;
51. tp[4][1]=597.1;
52. tp[4][2]=71.4;
53. tp[4][3]=412.1;
54. tp[4][4]=-0.894;
55. tp[4][5]=-0.068;
56. tp[4][6]=1.563;
57. tp[4][7]=7.580;
58. double[][] dm=new double[3][3];//Tabelle3 DrehMatrix
59. dm[0][0]=1.0;
60. dm[0][1]=(-tp[syst-1][6])*PI/180/3600;
61. dm[0][2]=-((-tp[syst-1][5])*PI/180/3600);
62. dm[1][0]=-dm[0][1];
63. dm[1][1]=1.0;
64. dm[1][2]=(-tp[syst-1][4])*PI/180/3600;
65. dm[2][0]=-dm[0][2];
66. dm[2][1]=-dm[1][2];
67. dm[2][2]=1.0;
68. double[] rv=new double[3];//Tabelle 3 Rotierte Vektoren
69. for(int i=0; i<3; i++) {
70.   rv[i]=x*dm[i][0]+y*dm[i][1]+z*dm[i][2];
71. }
72. double[] mb=new double[3];//Tabelle 3 Maßstab berücksichtigen
73. for(int i=0; i<3; i++) {
74.   mb[i]=rv[i]*(pow(-tp[syst-1][7], -6)+1);
75. }
76. double[] ta=new double[3];//Tabelle 3 Translationen anbringen
77. for(int i=0; i<3; i++) {
78.   ta[i]=mb[i]+(tp[syst-1][1]*dm[i][0]+tp[syst-1][2]*dm[i][1]+tp[syst-1][2]*dm[i][2]);
79. }
80. double veka=6377397.155; //Tabelle 5
81. double vekbv=6356078.962;
82. double veke2=(veka*veka-vekbv*vekbv)/(veka*veka);
83. double veks=sqrt(sq(ta[0])+sq(ta[1]));
84. double vekt=atan(ta[2]*veka/(veks*vekbv));
85. double vekb=(atan((ta[2]+veke2*sq(veka)/vekbv*pow(sin(vekt),3))/(veks-veke2*veka*pow(cos(vekt),3))))*180/PI;
86. double vekl=(atan(ta[1]/ta[0]))*180/PI;
87. double ben= (veka-vekbv)/(veka+vekbv);//Tabelle 6 Variablen
88. double bealpha= (veka+vekbv)/2*(1+1/4*sq(ben)+1/64*pow(ben,4));
89. double bebeta=-3/2*ben+9/16*pow(ben,3)-3/32*pow(ben,5);
90. double begamma= 15/16*sq(ben)-15/32*pow(ben,4);
91. double bedelta= -35/48*pow(ben,3)+105/256*pow(ben,5);
92. double beepsilon= 315/512*pow(ben,4);
93. double l0;
94. if(abs(vekl-6)<1.5) {
95.   l0=5;
96. }
97. else if(abs(vekl-9)<1.5) {
98.   l0=9;
99. }
100. else if(abs(vekl-12)<1.5) {
101.   l0=12;
102. }
103. else {
104.   l0=15;
105. }
106. double bei=(vekl-l0)*PI/180;
107. double beb=vekb*PI/180;
108. double beng=veka/sqrt(1-veke2*sq(sin(beb)));
109. double bens=sqrt(sq(veka)/sq(vekbv)*veke2*sq(cos(beb)));
110. double bet=tan(beb);
111. double bebl=bealpha*(beb+bebeta*sin(2*beb)+begamma*sin(4*beb)+bedelta*sin(6*beb)+beepsilon*sin(8*beb));
112. double beh1=bet/2*beng*sq(cos(beb))*sq(bei);
113. double beh2=bet/24*beng*pow(cos(beb),4)*(5-sq(bet)+9*sq(bens)+4*pow(bens,4))*pow(bei,4);
114. //double beh3=bet/720*beng*pow(cos(beb),6)*(61-58*sq(bet)+270*sq(bens)-330*sq(bet)*sq(bens))*pow(bei,6);
115. //double beh4=bet/40320*beng*pow(cos(beb),8)*(1385-3111*sq(bet)+543*pow(bet,4)-pow(bet,6))*pow(bei,8);
116. double hochwert=bebl+beh1+beh2;
117. double ber1=beng*cos(bet)*bei;
118. double ber2=beng/6*pow(cos(beb),3)*(1-sq(bet)+sq(bens))*pow(bei,3);
119. double rechtswert=ber1+ber2+500000+l0/3*1000000;
120. println(hochwert+" "+rechtswert);

Don't forget the little d at the end of the constants, as Processing automatically convert them to float (as opposed to Java behavior).
And Processing math functions act on floats as well. If you want more precision, use Math.cos() and similar.