Schleife für StringReplace

[Stevens]

Hallo Leute


Schreibe gerade ein Programm mit dem Ich Messwerte auslese.
Den Messbereich stellt das Messgerät automtatisch im Bereich von E+06 bis E-09 ein.
Die Werte werden im Format z.B. 1,200 E-06 ausgegeben.
Dazu möchte Ich die Exponenten- Werte durch die Bezeichnung z.B. µ ersetzen.

Mein Quellcode für einen Exp.- Faktor sieht jetzt so aus:

Panel1.Caption := (StringReplace(Panel1.Caption,'E-06',Chr(181),[rfreplaceall])); Soweit, so gut nur.....
Wie muss Ich jetzt eine Schleife oder Abfrage realisieren, damit alle Faktoren von
E+06 bis E-09 durchlaufen werden.

Hab keine Idee!

[himitsu]

Erstens, da war ein Komma zu viel

Delphi-Quellcode:

S := Panel1.Caption;
S := StringReplace('E-06', Chr(181), [rfreplaceall]);
S := StringReplace('E-03', Chr(...), [rfreplaceall]);
...
S := StringReplace('E+09', 'M', [rfreplaceall]);
Panel1.Caption := S;

Delphi-Quellcode:

Const TheChar: Array[-2..3] of Char = ('µ', ..., 'M');

S := Panel1.Caption;
For i := -2{*3=-6} to 3{*3=+9} do
S := StringReplace('E' + Format([i*3] ...), TheChar(i), [rfreplaceall]);
Panel1.Caption := S;

Für FORMAT hab ich gerade keine Definition ... schau mal in die OH und stell ein Muster zusammen, was ein Vorzeichen voranstellt und danach die Zahl zweistellig mit führrender Null.

Delphi-Quellcode:

Const TheSign: Array[Boolean] of Char = ('+', '-');
  TheChar: Array[-2..3] of Char = ('µ', ..., 'M');

S := Panel1.Caption;
For i := -2{*3=-6} to 3{*3=+9} do
  S := StringReplace('E' + TheSign[i < 0] + IntToStr(Abs(i * 3) div 10) + IntToStr(Abs(i * 3) mod 10), TheChar(i), [rfreplaceall]);
Panel1.Caption := S;

solange du zwischen -10 und 10 bleibst, kannst du IntToStr(Abs(i * 3) div 10) durch '0' ersetzen, da es dann ja eh immer 0 sein wird.

[marabu]

Herzlich willkommen in der Delphi-PRAXiS, Stevens.

Hier noch eine kleine Funktion, welche die technische Notation im Bereich E-9 bis E6 von Exponentialschreibweise auf Symbolschreibweise umstellt. Ohne Prüfcode - nur zur Verdeutlichung der Vorgehensweise:

Delphi-Quellcode:

function EngUnit(s: String): String;
const
  S_UNITS = 'nµm kM';
var
  i, exp: Integer;
begin
  i := Pos('E', s);
  exp := StrToInt(Copy(s, Succ(i), 3)) div 3 + 4;
  Result := Trim(Copy(s, 1, Pred(i)) + S_UNITS[exp]);
end;

Freundliche Grüße vom marabu

[Stevens]

Danke, hat super geklappt!

[Stevens]

Fortsetzung folgt



Die Expotential- in Symbolschreibweise hat ja super geklappt.
Nun bin Ich an meinem Projekt auf ein anderes Hindernis gestossen

Die Messwerte die Ich auslese zeigt mir das Programm korrekt an, nur.....
Diese Werte muss Ich mit einem frei einstellbaren Faktor multiplizieren( z.B. 0,4)
D.h. bei einem Wert von 1,2 mF * 0,4 erscheint das Ergebnis von 0,48 mF, was ja stimmt und funktioniert aber nicht gerade schön ist.
Die Ergebnisse sollten bei einem 0,xx- Wert in dem nächst niedrigeren Exponenten angezeigt werden, was in diesem Beispiel 480 µF währen.



Wäre gut wenn einer mir weiter helfen kann, sonst werde noch Ich verrückt!!

[Klaus01]

Kannst Du nicht den Ganzzahlanteil des Ergebnisses mit int
abfragen, ist int < 0 dann mußt Du den Exponenten prüfen und den
nächst niedrigeren nehmen ist int > 1000 dann solltest Du den nächst
höheren Exponenten wählen.

Grüße
Klaus

[mbamler]

Zitat von Stevens:

Fortsetzung folgt



Die Expotential- in Symbolschreibweise hat ja super geklappt.
Nun bin Ich an meinem Projekt auf ein anderes Hindernis gestossen

Die Messwerte die Ich auslese zeigt mir das Programm korrekt an, nur.....
Diese Werte muss Ich mit einem frei einstellbaren Faktor multiplizieren( z.B. 0,4)
D.h. bei einem Wert von 1,2 mF * 0,4 erscheint das Ergebnis von 0,48 mF, was ja stimmt und funktioniert aber nicht gerade schön ist.
Die Ergebnisse sollten bei einem 0,xx- Wert in dem nächst niedrigeren Exponenten angezeigt werden, was in diesem Beispiel 480 µF währen.



Wäre gut wenn einer mir weiter helfen kann, sonst werde noch Ich verrückt!!

Na na - immer geschmeidig beleiben
Die Lösung kann ich dir nicht präsentieren aber ....

ich würde den Log zur Basis 10 auf den Ergebniswert berechnen (z.B. Log10 von 0,48 = -0.3188)
So lange das Ergenis der Operation kleiner 0 ist
würde ich "deinen" Wert mit 1000 multiplizieren - gleichzeitig die Einheit von m auf y wechseln
(Bei anderen Einheitenwechsel entsprechend - du brauchst also eine Liste von Einheiten, die du bei jeder Multiplikation durchgehst)

anderes Beispiel Entfernungen (hier bei Multiplikation mit 10)

480 mm log10 = 2,6 ist größer 0 - also durch 10 TEILEN und Einheit eine 10er Protenz niedriger (vom mm auf cm)
48 cm log10 = 1,6 ist größer 0 - also durch 10 TEILEN und .... (von cm auf dm)
4,8 dm log10 = 0,68 ... (von dm auf m)
0,48 m
...usw...

hoffe ich habe dich auf eine Idee gebracht

Gruß
Matthias

[marabu]

Eine kleine Code-Spende:

Delphi-Quellcode:

const
  S_UNITS = 'pnµm kMGT';

function FloatToSym(value: Extended): String;
var
  i, sign: Integer;
  log: Extended;
begin
  log := Ln(value) / Ln(10);
  sign := 1 - Ord(log < 0) shl 1;
  i := 0;
  while (log < 0) or not (log < 3) do
  begin
    Inc(i, sign);
    log := log - sign * 3;
  end;
  value := Exp(log * Ln(10));
  Result := Format('%g%s', [value, S_UNITS[i + Pos(' ', S_UNITS)]]);
end;

function SymToFloat(s: String): Extended;
var
  i, index: Integer;
begin
  Result := 0;
  for i := 1 to Length(s) do
    if not TryStrToFloat(Copy(s, 1, i), Result) then
    begin
      index := Pos(s[i], S_UNITS);
      if index > 0 then
      begin
        Result := Exp(ln(Result) + (index - Pos(' ', S_UNITS)) * 3 * Ln(10));
        Exit;
      end;
    end;
end;

Grüße vom marabu

[Stevens]

1000 Dank. Ist echt Top!

Werde es am Freitag sofort einbauen.
Jetzt läuft wahrscheinlich ein potentieller Verrückter weniger rum.
Sind eh schon genug da!

[stoxx]

Hi !
ähm, die Funktion ist ja Wahnsinn .. warum macht ihr die Sache so kompliziert ?
Jede Einheit stellt doch nur einen simplen Faktor für den eigentlichen Wert dar.
Lösung also:
Der Wert wird einfach solange in einer Schleife in die neue Einheit umgerechnet bis eine Zahl größer 1 rauskommt.
Wahnsin was ihr da macht *Kopfschüttel* .. die Funktion FloatToSym ist ja echt ein Hammer !
Man braucht doch für umrechnungen keinen Logarithmus ...