double-Wert aus einzelnen Ziffern erzeugen

[Kollisionskurs]

Hallo zusammen,

ich hab ein etwas exotisches Problem. In meiner Applikation kann der Anwender einen Zählerstand (wie an einem Stromzähler - siehe Screenshot) eingeben bzw. werden die einzelnen Stellen des Zählerstandes mittels Grafiken abgebildet. Somit klickt er an der jeweiligen Stelle die Grafik an und kann somit den nummerischen Wert ändern.

http://www.ip-symcon.de/forum/attachments/f52/8015d1272437369-zahlen-bildern-stromzaehler_1.jpg

Diesen Wert merke ich mir in einer Arraylist vom Typ Integer. Die Vor- und Nachkommastellen sind mir bekannt. Jetzt muss ich allerdings (bereits währrend der Eingabe des Anwenders) aus den Werten in der Arraylist den tatsächlichen Zählerstand berechnen bzw. ich muss mir einen double-Wert bilden.

Beispiel:

Wenn der Zähler 4 Vorkomma und 2 Nachkomma Stellen hat, zeichne ich logischerweisse 6 Bilder.
Jetzt beginnt der Anwender mit der Eingabe. Er ändert die letzte Nachkommastelle bzw. tippt er eine 8 ein:

Somit steht in meiner Arraylist:

array[0] = 0
array[1] = 0
array[2] = 0
array[3] = 0
array[4] = 0
array[5] = 8

Ändert er jetzt noch die erste Stelle bzw. tippt er eine 5.:

array[0] = 5
array[1] = 0
array[2] = 0
array[3] = 0
array[4] = 0
array[5] = 8

usw.

Nach jeder Eingabe lande ich in meiner Schleife mit der Arraylist und den Infos über die Dezimalstellen...bisher tue ich mich extrem schwer jetzt daraus einen gültigen double Wert zu erzeugen bzw. diesen zu durchlaufen.

Habt Ihr eine Idee....jeder Tipp hilft!

Danke im Voraus!

 

[Camill]

Habe ich es richtig verstanden - die sechs Werte aus dem Array sollen zu einem Double Wert "zusammengefasst" werden?

 

[TKausL]

array[0] = 0;
array[1] = 0;
array[2] = 0;
array[3] = 0;
array[4] = 0;
array[5] = 8;
double stand = 0;

for(int i = 0; i < 6; i++){
    stand += array[i]*Math.pow(10, 3-i);
}

Müsste eigentlich stimmen...

Edit: Getestet, stimmt.
Oder du baust dir einen String zusammen und Castest den.

 

[Kollisionskurs]

Servus,

vielen Dank. Der Wert wird über die Potenzierung korrekt ermittelt - und das in einem Einzeiler...da hätte ich mir wieder einen abgewürgt. Allerdings habe ich Probleme mit der Nachkommastelle bzw. sollte ich diese ja quasi dynamisch verschieben können - die Information über die Anzahl an Nachkommastellen übergebe ich meiner Berechnungs-Methode.
In der beliebig großen Arraylist ist ja immer der komplette Zählerstand erhalten.

public double calculateReadingValue(ArrayList<Integer> _numbers, int numDecimals) {
		double counter = 0;
		for(int i = 0; i < _numbers.size(); i++) {
			counter += _numbers.get(i) * Math.pow(10, 3-i);
		}
		return counter;
	}

Beispiel: der Anwender gibt einen Zählerstand von 9999999,99 (9 Stellen) ein.
Somit steht in meiner List:

array[0] = 9;
array[1] = 9;
array[2] = 9;
array[3] = 9;
array[4] = 9;
array[5] = 9;
array[6] = 9;
array[7] = 9;
array[8] = 9;

als Ergebnis erhalte ich jetzt 9999,99999 - was ja auch rein rechnerisch stimmt. Allerdings eben nicht mehr zu meinem Zählerstand passt.

Das müsste ich doch noch irgendwie eleganter lösen können, oder?

Grüße

 

[TKausL]

Ersetze

Math.pow(10, 3-i);

Durch

Math.pow(10, array.length-(i+nachkommastellen+1));

ungetestet.

 

[SlaterB]

offensichtlich hängt Math.pow(10, 3-i) mit der Interpretation zusammen,
hast du überhaupt nicht überlegt, warum da 3 steht? 3 hatte im Beispiel von TKausL mit der Anzahl der Nachkommastellen zu tun,
nicht direkt, denn es waren ja nur 2, teste was dort eingetragen werden muss, was bei anderen Werten passiert,
inwiefern du letzlich deine Variable einbauen kannst/ musst,

ein Kopf ist zum Denken da, nie vergessen, nicht nur zum Postings schreiben
(edit: ok, Denken wieder einstellen)

 

[Andi_CH]

Das müsste ich doch noch irgendwie eleganter lösen können, oder?

Ja

	static double intArrToDouble(int[] intArr) {
		double result = 0;
		for(int i = 0; i < intArr.length; i++) {
			result = result * 10 + intArr[i];
		}
		result /= 100;
		return result;
	}

Die Ziffer 3 im vorhergehenden Code ist schlecht, denn so ist der Code nicht wiederverwendbar.
Lieber allgemein formulieren - das heisst für beliebige Array-Längen.

In meinem Code steht noch 100 drin. Auch das ist auch suboptimal.
Da lohnt es sich darüber nachzudenken, ob auch der Faktor (die Position an der der "." steht) als Paramter übergeben, im Klassenkopf als Konstante deklariert werden soll oder ob es ok ist so.
(Das ist einerseits Geeschmackssacke, andererseits auch Projektabhängig)

 

[Kollisionskurs]

so...lieber spät als nie - musste die Programmierung wieder ein paar Tage auf Eis legen.

Vielen Dank für die Hilfestellungen - hat einwandfrei funktioniert inkl. Lernfaktor:

         /*
         * Liefert den Zählerstand abhängig vom gesetzten Wert (Tag-Object) in der ImageView
         * array[0] = 9; <br>
	 * array[1] = 9; <br>
	 * array[2] = 9; <br>
	 * array[3] = 9; <br>
	 * array[4] = 9; <br>
	 * array[5] = 9; <br>
         * Beispiel: 2 Nachkommastellen = 9999,99 <br>
	 * 1 exponent = 3  (6 - 3)  ->  (9 * Math.pow(10, 3))  = 9000 (value+=9000) <br>
	 * 2 exponent = 2  (6 - 4)  ->  (9 * Math.pow(10, 2))  = 900  (value+=9900) <br>
	 * 3 exponent = 1  (6 - 5)  ->  (9 * Math.pow(10, 1))  = 90   (value+=9990) <br>
	 * 4 exponent = 0  (6 - 6)  ->  (9 * Math.pow(10, 3))  = 9 	  (value+=9999) <br>
	 * 5 exponent = -1 (6 - 7)  ->  (9 * Math.pow(10, -1)) = 0,9  (value+=9999,9) <br>
	 * 6 exponent = -2 (6 - 8)  ->  (9 * Math.pow(10, -2)) = 0,09 (value+=9999,99) <br>
	 *<br>
        */
public double getValueDependOnImageViews(ArrayList<ImageView> _imageViews, int numDecimals) 
{
		double value = 0;
		for(int i = 0; i < _imageViews.size(); i++) {
	                int exponent = _imageViews.size() - (i + numDecimals + 1);
			int tagValue = Integer.valueOf((String) _imageViews.get(i).getTag()); 
			value += (tagValue * Math.pow(10, exponent));
		}
		return value;
	}

Jetzt kann ich quasi aus den Bildinformationen den Wert ermitteln. Allerdings muss das auch aus der anderen Richtung funktionieren bzw. aus dem Wert die einzelnen Bildpositionen setzen:

         /*
         * Setzt die Bilder (inkl. Tag) in Relation zum eingegeben Zählerstand
         */
public ArrayList<ImageView> getImageViewsDependOnValue
					(ArrayList<ImageView> _imageViews, double _value, int _numDecimals) {
	for (int i = 0; i < _imageViews.size(); i++) {
		int exponent = _imageViews.size() - (i + _numDecimals + 1);
		double digit = _value / Math.pow(10, exponent);
		int lastDigit = (int) Math.round(Math.floor(digit));
						
		_imageViews.get(i).setTag(lastDigit);
	        _imageViews.get(i).setImageDrawable(getDrawableDependOnTag(lastDigit));
		_value -= (lastDigit * Math.pow(10, exponent));
		}
		return _imageViews;
	}

Sollte passen....Verbesserungsvorschläge sind immer willkommen

Grüße