public Returnstack convertToBin(String zahl)
{
Returnstack result = new Returnstack();
Returnstack interimresult = convertToDez (zahl);
result.addStep("In Dezimal umwandeln.\n");
result+=interimresult;
result.addStep("Zwischenergebnis: " + interimresult.getResult ());
interimresult = new Dezimal().convertToBin(interimresult.getResult());
result.addStep("\n Von Dezimal in Binaer umwandeln.\n");
result+=interimresult;
result.setResult(interimresult.getResult());
return result;
}
public Returnstack convertToDez(String zahl)
{
Returnstack result = new Returnstack();
int dezzahl = 0;
for (int i = 0; i < zahl.Length; i++) {
int zwergebnis= table(zahl [zahl.Length-1-i])*(int)(Math.Pow(16,i));
result.addStep((zahl [zahl.Length-1-i]).ToString()+": " + (table(zahl [zahl.Length-1-i])).ToString()+"*"+((int)(Math.Pow(16,i))).ToString() );
dezzahl += zwergebnis;
}
result.addStep("__________________________");
result.setResult(dezzahl.ToString());
return result;
}
public Returnstack convertToDez(String zahl)
{
Returnstack result = new Returnstack ();
int z = 0;
for (int i = 0; i < zahl.Length; i++) {
int help = int.Parse (zahl[zahl.Length-1-i].ToString ());
z += help * (int)Math.Pow (2, i);
result.addStep(help+" *2^"+i+" = "+(help * (int)Math.Pow (2, i)));
}
result.addStep("__________________________");
result.setResult(z.ToString());
return result;
}
public Returnstack convertTo(String wert)
{
if(!this.analyse (wert)){
Returnstack result = new Returnstack("Falsche Syntax!\nEs sind nur die Zeichen '0-9' und ',' erlaubt.");
result.addStep("Analyse ergabe Fehler in der Syntax.");
return result;
}
this.getParts (wert);
String[] splited = wert.Split (',');
Returnstack erg = new Dezimal ().convertToBin (splited [0]);
if (this.parts == 2) {
Double zwerg = Double.Parse ("0," + splited [1]);
erg += ",";
while (zwerg!=1) {
zwerg = zwerg * 2;
if (zwerg > 1) {
zwerg -= 1;
erg += "1";
} else {
if (zwerg == 1) {
erg += "1";
break;
}
erg += "0";
}
}
}
return erg;
}
public Returnstack convertTo(String wert)
{
Returnstack result = new Returnstack ();
if (!this.analyse (wert)) {
result = new Returnstack ("Falsche Syntax!\nEs sind nur die Zeichen '0-9' und '-' erlaubt.");
result.addStep ("Analyse ergabe Fehler in der Syntax.");
return result;
}
Returnstack dezimal = new Dezimal ().convertToBin (wert);
String steps = "";
for (int i = 0; i< dezimal.getSteps().Length; i++) {
steps += dezimal.getSteps () [i] + "|";
}
if (wert [0] == '-') {
wert = wert.Remove (0, 1);
result.setResult ("1" + new Dualoperationen ().invert (dezimal.getResult ()));
} else {
result.setResult (dezimal.getResult ());
}
result.addStep (steps);
return result;
}
public Returnstack convertFrom(String wert)
{
Returnstack result = new Returnstack ();
if (!this.analyse (wert)) {
result = new Returnstack ("Falsche Syntax!\nEs sind nur die Zeichen '0-1' erlaubt.");
result.addStep("Analyse ergabe Fehler in der Syntax.");
return result;
}
String vorzeichen = "";
if (wert [0] == '1') {
wert = wert.Remove (0, 1);
vorzeichen = "-";
}
Returnstack dezimal = new Binaer ().convertToDez (new Dualoperationen ().invert (wert));
String steps = "";
for (int i = 0; i< dezimal.getSteps().Length; i++) {
steps += dezimal.getSteps() [i] + "|";
}
result.setResult (vorzeichen + dezimal.getResult ());
result.addStep (steps);
return result;
}
public Returnstack convertToBin(String zahl)
{
Returnstack result = new Returnstack ();
result.addStep ("Schreibe : von rechts(oben) ---> links(unten)\n\n ");
int dezzahl = int.Parse (zahl);
zahl = "";
while (dezzahl!= 0) {
zahl = dezzahl % 2 + zahl;
result.addStep (dezzahl + "/ 2 = " + (dezzahl / 2).ToString () + " ---> R: " + (dezzahl % 2).ToString ());
dezzahl = dezzahl / 2;
}
result.addStep ("_________________________");
result.setResult (zahl);
return result;
}
public Returnstack convertToHex(String zahl)
{
String z = "";
Returnstack result = new Returnstack();
result.addStep("[Info] Binaerzahlen ließt man von rechts -> links.");
result.addStep("Vier Stellen einer Binaerzahl ergeben eine Stelle einer Hexzahl. ");
result.addStep("Berechnung:");
result.addStep("Hexstelle = binSt[1]*2^0 + binSt[2]*2^1 + binSt[3]*2^2 + binSt[4]*2^3");
result.addStep("Wenn 9 < Hexstelle < 16 werden die Zahlen durch die Buchstaben A-F ersetzt. ");
result.addStep("Hexstelle kann nicht <= 16 sein, da 1111(Bin) = 15 (Dez)");
result.addStep("Oben ist rechts, unten links");
result.addStep("\n\n");
for (int i = 0; i < zahl.Length; i+=4) {
int x = 0;
String binzahl ="";
for (int j = 0; j <=3; j++) {
if (i + j < zahl.Length) {
binzahl= zahl [zahl.Length-1-i - j].ToString()+"*2^"+j.ToString()+" "+binzahl;
x += Convert.ToInt32 (zahl [zahl.Length-1-i - j].ToString ()) * (int)Math.Pow (2, j);
} else
break;
}
String synonym ;
switch (x) {
case 10:
synonym = "A";
break;
case 11:
synonym = "B";
break;
case 12:
synonym = "C";
break;
case 13:
synonym = "D";
break;
case 14:
synonym = "E";
break;
case 15:
synonym= "F";
break;
default:
synonym = x.ToString ();
break;
}
z = synonym + z;
result.addStep(binzahl+" = "+synonym+" ("+x.ToString()+")");
}
result.setResult(z);
return result;
}
public Returnstack convertFrom(String wert)
{
if(!this.analyse (wert)){
Returnstack result = new Returnstack("Falsche Syntax!\nEs sind nur die Zeichen '0-1' erlaubt.");
result.addStep("Analyse ergabe Fehler in der Syntax.");
return result;
}
return new Binaer ().convertToDez (wert);
}
public Returnstack convertToHex(String zahl)
{
Returnstack result = new Returnstack ();
result.addStep ("Schreibe : von rechts(unten) ---> links(oben)\n ");
int dezzahl = int.Parse (zahl);
String binzahl = "";
while (dezzahl!= 0) {
String synonym;
switch (dezzahl % 16) {
case 10:
synonym = "A";
break;
case 11:
synonym = "B";
break;
case 12:
synonym = "C";
break;
case 13:
synonym = "D";
break;
case 14:
synonym = "E";
break;
case 15:
synonym = "F";
break;
default:
synonym = (dezzahl % 16).ToString ();
break;
}
binzahl = synonym + binzahl;
result.addStep (dezzahl + "/ 16 = " + (dezzahl / 16).ToString () + " ---> R: " + synonym + "(" + (dezzahl % 16).ToString () + ")");
dezzahl = dezzahl / 16;
}
result.addStep ("_________________________");
result.setResult (binzahl);
return result;
}
public static Returnstack operator +(Returnstack a, String b)
{
Returnstack result = new Returnstack ();
String aresult = a.getResult ();
if (a == null) {
aresult = "";
}
result.setResult (aresult + b);
result.addStep (a.getSteps ());
return result;
}
public Returnstack convertFrom(String wert)
{
Returnstack result = new Returnstack ();
if (!this.analyse (wert)) {
result = new Returnstack ("Falsche Syntax!\nEs sind nur die Zeichen '0-1' erlaubt.");
result.addStep ("Analyse ergabe Fehler in der Syntax.");
return result;
}
if (wert [0] == '1') {
wert = wert.Remove (0, 1);
result += "-";
}
result += new Binaer ().convertToDez (wert).getResult ();
return result;
}
public Returnstack convertTo(String wert)
{
Returnstack result = new Returnstack ();
if (!this.analyse (wert)) {
result = new Returnstack ("Falsche Syntax!\nEs sind nur die Zeichen '0-9' und '-' erlaubt.");
result.addStep ("Analyse ergabe Fehler in der Syntax.");
return result;
}
if (wert [0] == '-') {
wert = wert.Remove (0, 1);
result += "1";
}
result += new Dezimal ().convertToBin (wert);
return result;
}
private Returnstack convert(String type)
{
Returnstack convert = new Returnstack ();
convert.addStep ("Prüfen der ausgangs Parameter;");
if (wert == "") {
convert.setResult ("Kein Wert");
return convert;
}
if (bias == "") {
convert.setResult ("Missing Bias");
return convert;
}
if (new Regex ("[^0-9]").Match (this.bias).Success) {
convert.setResult ("Wrong Syntax");
return convert;
}
switch (type) {
case "to":
if (new Regex ("[^0-9\\-]").Match (this.wert).Success) {
convert.setResult ("Wrong Syntax");
return convert;
}
String erg = ((int)(Double.Parse (wert) + Double.Parse (bias))).ToString ();
convert = new Dezimal ().convertToBin (erg);
return convert;
case "from":
if (new Regex ("[^0-1]").Match (this.wert).Success) {
convert.setResult ("Wrong Syntax");
return convert;
}
convert = new Binaer ().convertToDez (wert);
convert.setResult (((int)(Double.Parse (convert.getResult ()) - Double.Parse (bias))).ToString ());
return convert;
default :
return convert;
}
}
public Returnstack convertFrom(String wert)
{
if (!this.analyse (wert)) {
Returnstack result = new Returnstack ("Falsche Syntax!\nEs sind nur die Zeichen '0-1' erlaubt.");
result.addStep ("Analyse ergabe Fehler in der Syntax.");
return result;
}
Returnstack convert ;
if (wert [0] == '1') {
wert = wert.Remove (0, 1);
convert = new Binaer ().convertToDez (new Dualoperationen ().invert (wert));
convert.setResult( "-" + (int.Parse (convert.getResult ()) + 1).ToString ());
} else {
convert = new Binaer ().convertToDez (wert);
}
return convert;
}
public Returnstack convertFrom(String wert)
{
if(!this.analyse (wert)){
Returnstack result = new Returnstack("Falsche Syntax!\nEs sind nur die Zeichen '0-1' und ',' erlaubt.");
result.addStep("Analyse ergabe Fehler in der Syntax.");
return result;
}
this.getParts (wert);
String[] splited = wert.Split (',');
Returnstack part1 = new Binaer ().convertToDez (splited [0]);
if (this.parts == 2) {
Returnstack part2 = new Binaer ().convertToDez (splited [1]);
part2.setResult ((Double.Parse (part2.getResult ()) / (int)Math.Pow (2, splited [1].Length)).ToString ().Split (',') [1]);
part1 += "," + part2.getResult ();
} else
part1 += ",0";
return part1;
}
public Returnstack convertTo(String wert)
{
if (!this.analyse (wert)) {
Returnstack result = new Returnstack ("Falsche Syntax!\nEs sind nur die Zeichen '0-9' und '-' erlaubt.");
result.addStep ("Analyse ergabe Fehler in der Syntax.");
return result;
}
int vorzeichen = 0;
if (wert [0] == '-') {
wert = wert.Remove (0, 1);
vorzeichen = 1;
}
Returnstack convert = new Dezimal ().convertToBin (wert) ;
if(vorzeichen == 1){
convert.setResult( "1" + new Dualoperationen ().addieren (new Dualoperationen ().invert (convert.getResult ()), "1"));
} else {
convert.setResult( "0" + convert.getResult ());
}
return convert;
}