Killogramm, Gramm und milligram

[Smeivel]

kann man nicht einfach eine Prozedur schreiben dass wenn(while) der Wert mehr als 3 Stellen vor dem Komma hat dann soll er durch 1000 dividieren?!

[TheCatcher]

Ja versuchte ich schon nur stelle ich mir zwei fragen bzw. ein Problem

a) Wie sage ich delphi das er NICHT auch die nachkomma stellen zählen soll? StrLn geht nicht
b) habe ich bei einigen Werten ein NULL zu wenig bei dem nachkomme also 6565,5 <- statt 6565,50

[Smeivel]

Also dein erstes Problem kannst du beheben in dem du schreibst dass er alles bis zum Komma zählen soll hab grad kein Delphi da das müsste aber mit Delimiter gehen ansonsten über [er soll sagen wo pos(vom ,)] und wenn die Zahl größer 3 ist dann wie gesagt. Bei deinem 2. Problem würde ich sagen solltest du eine Prozedur schreiben die das überprüft, bzw. einfügt

[Klaus01]

sollte doch nicht so schwer sein.

ist der errechnete Wert < 1 dann nehme eine Einheit kleiner als die jetzige und multipliziere den Wert mit 1000
ist der errechnete Wert > 1000 dann nehme eine Einheit größer als die jetzige und teile den Wert durch 1000

Beispiel:

4 x 15g = 60g nichts ändert sich
8 x 150g = 1200g Einheit ändert sich auf 1,2 kg
4 x 0,15 = 0,6g Einheit ändert sich auf 600 mg

Grüße
Klaus

[xZise]

Ich bin ja mal nett

Zitat von TheCatcher:

a) Wie sage ich delphi das er NICHT auch die nachkomma stellen zählen soll? StrLn geht nicht

Wenn der Wert größergleich 1000 ist.
Wenn du das als String einliest musst du das dann einfach in eine Fließkommazahl (Extended) umwandeln.

Zitat von TheCatcher:

b) habe ich bei einigen Werten ein NULL zu wenig bei dem nachkomme also 6565,5 <- statt 6565,50

Soll es immer 3 Nachkommastellen geben?
Also z.B. 1,000 g?

Dann könntest du das in einer Schleife (ich finde eine for-schleife schön ):
SValue = Wert als String ('123,45')
Value = Wert (123,45)
Nachkomma = Nachkommastellen (0,45)
Laenge = Länge der Nachkommstellen (2)

Delphi-Quellcode:

Value := StrToFloat(SValue);
//Nachkommastellen "errechnen"
Nachkomma := Value - Round(Value);

// Länge bestimmen
{ Entweder du wandelst es in einen String um und überprüfst die Länge }
Laenge := FloatToStr(Nachkomma) - 2; // - 2 wegen dem komma und der führenden null: [0,]45
{ Du könntest es auch ausrechnen (is komplizierter), werde es aber nicht hier erklären, da es über den String auch funktionieren sollte }

// Nullen "ansetzen"
for i := Laenge to 3 do
  SValue := SValue + '0';

// Aus diesem Code kann man dann auch einen einzeiler machen (ACHTUNG: Komplizierter ;) )
for i := FloatToStr(StrToFloat(SValue) - Round(StrToFloat(SValue))) - 2 to 3 do
  SValue := SValue + '0';

Zusammenfassend zu der Aufgabe: Du musst einfach nur ein bisschen rechnen lassen, allerdings nicht mit Strings. Die Strings solltest du nur verwenden, wenn du es ausgeben willst, oder (wie es bei Fall B der fall war ^^) wenn du etwas hinzufügen willst (Nullen vor/nach allen Ziffer (001,200)), was beim Integer/Extended eiskalt (^^) gelöscht werden würde.

Ich hoffe mal ich konnte weiterhelfen.

Eine Frage: Sollte es nur von Tonnen - Milligramm gehen? Oder auch darüber?

Ich möchte ungerne das fertige Programm jetzt posten, aber ich geben einen Anstoß:
(weitere Erklärung siehe oben)

Delphi-Quellcode:

// Zuerst den Wert IMMER in ein Extended umwandeln ;) Damit lässt sich alles besser berechnen
Value := StrToFloat(SValue);
if Value >= 1000 then begin // in Kilogramm
  if Value / 1000 >= 1000 then begin // in Tonnen/Megagramm
    // Umrechnung in Tonnen (aufpassen: Umwandlung Gramm >>> Tonnen ist 1 Gramm * 1.000.000 = 1 Tonne!)
  end else begin
    // Umrechnung in Kilogramm
  end;
end else if Value < 1 begin // in Milligramm
  // Umrechnung in Milligramm
end else begin // so lassen (GRamm)
  //keine Umrechnung
end;

xZise hat folgendes hinzugefügt:

Übrigends musst du es nachher wieder umwandeln und in ein Label/Edit eintragen.

[Amateurprofi]

Hallo, TheCatcher,

Ich hatte das mal so gelöst
Ursprünglich wurden 3 signifikante Ziffern ausgegeben.
So wie es jetzt ist, bis zu 18 signikanten Ziffern nach dem Dezimalpunkt. Hab ich aber nicht ausgiebig getestet.

Delphi-Quellcode:

FUNCTION Normalize(v:extended; baseunit:string):string;
type
   TNumberUnit=(nuYocto,nuZepto,nuAtta,nuFemto,nuPiko,nuNano,nuMicro,nuMilli,
                nuNone,nuKilo,nuMega,nuGiga,nuTera,nuPeta,nuExa,nuZetta,nuYotta);
const
   numberunits:Array[TNumberUnit] of char='yzafpn'#181'm kMGTPEZY';
var
   i,d:integer; nu:TNumberUnit;
begin
      nu:=nuNone;
      if v<>0 then begin
         while v<1 do begin
            v:=v*1000;
            nu:=Pred(nu);
         end;
         while v>=1000 do begin
            v:=v/1000;
            nu:=Succ(nu);
         end;
         // Einstellung auf 3 signifikante Ziffern
//         if (nu=nuNone) or (v>99.95 {>=100}) then d:=0
//            else if v>9.95 {>=10} then d:=1
//               else d:=2;
      end;
//      str(v:0:d,result);
      d:=18;
      str(v:0:d,result);
      for i:=Length(result) downto 1 do
         if result[i]='0' then dec(d) else break;
      str(v:0:d,result);
      if nu=nuNone then result:=result+' '+baseunit
         else result:=result+' '+numberunits[nu]+baseunit;
end;