Berechnung eines Wertes aus Widerstandsreihe

[marabu]

Hallo Frank,

etwas kompakter - wenn dich die höheren Rechenarten nicht stören - geht es so:

Delphi-Quellcode:

uses
  Math;

function Norm(e: Extended; var dExp: Integer): Extended;
begin
  dExp := Ceil(Log10(e)) - 3;
  Result := e / Power(10, dExp);
end;

Freundliche Grüße

[_frank_]

danke dir marabu (auf log10 hätte auch kommen können ).
hab die Funktion noch bisschen modifiziert, da ich die Nachkommastellen des "Hunderterwertes" nicht benötige.

Delphi-Quellcode:

uses math;

function Norm(e: Extended; var dExp: Integer): Integer;
begin
  dExp := Ceil(Log10(e)) - 3;
  Result := round(e / Power(10, dExp));
end;

procedure TForm1.Button1Click(Sender: TObject);
var dExp: Integer;
begin
  edit2.text:=inttostr(Norm(strtofloat(edit1.text),dexp));
end;

Gruß Frank

[marabu]

Vielleicht solltest du statt Round() die Funktion Trunc() verwenden - sonst fliegst du ab 999.5 doch noch aus der Dekade raus.

Freundliche Grüße

[_frank_]

würde ich so oder so, denn der nächste widerstandswert *jeder* Reihe wäre 100 der nächsten dekade, da muss ich noch überlegen wie ich das mache...das round ist also nicht das problem selbst, ich müsste lediglich bei einem nicht gefundenen Wert die nächste dekade verwenden.

Gruß Frank

[marabu]

Durch die Log10()-Funktion wird der Eingabewert korrekt auf das nach oben halboffene Intervall [100, 1000) abgebildet. Durch die Einführung des Round() fällt das Ergebnis bei Werten zwischen [999.5, 1000) aus dem definierten Bildbereich heraus. Das würde mir aus mathematischer Sicht nicht gefallen.

Die Abbildung auf den Eingangswert der nächsten Dekade ist einfach, wenn du eine binäre Suche

function Find(value: Double; series: TDoubleDynArray; var index: Integer): Integer; auf einer beliebigen übergebenen E-Reihe implementierst. Ist der Rückgabewert gleich series.Count, dann ist der Eingangswert der richtige und dExp muss um eins inkrementiert werden.

Freundliche Grüße

[_frank_]

Hallo und frohes Neues ,
ich habe ma versucht, das Code-Beispiel von AmateurProfi im verlinkten Post zu modifizieren, leider ist da ein Syntax-Fehler drin, mit dem ich nicht wirklich klar komme.
ein weiteres Problem ist, das ich mit Teilmengen des Arrays hantieren muss/will, um nicht alle 7 reihen abtippen zu müssen sondern nur die 2 (E24 und E192).Es muss also eine Schrittweite verwendet werden.

mein Versuch:

Delphi-Quellcode:

const
  e3=0;
  e6=1;
  e12=2;
  e24=3;
  e48=4;
  e96=5;
  e192=6;

function FindValue(reihe:byte; wert:integer):integer;
const
  //r3:array[0..2] of double=(1.0,2.2,4.7); //2^0
  //r6:array[0..5] of double=(1.0,1.5,2.2,3.3,4.7,6.8);//2^1
  //r12:array[0..11] of double=(1.0,1.2,1.5,1.8,2.2,2.7,3.3,3.9,4.7,5.6,6.8,8.2); //2^2
  r24:array[0..23] of integer=(100,110,120,130,150,160,180,200,220,240,270,300,330,360,390,430,470,510,560,620,680,750,820,910);//schrittweite 8 (1,9,...) =>E3 2^3
  r192:array[0..191] of double=(
    100,101,102,104,105,106,107,109,110,111,113,114,115,117,118,120,121,123,124,126,127,129,130,132,133,135,137,138,140,142,143,145,147,149,
    150,152,154,156,158,160,162,164,165,167,169,172,174,176,178,180,182,184,187,189,191,193,196,198,
    200,203,205,208,210,213,215,218,221,223,226,229,232,234,237,240,243,246,249,
    252,255,258,261,264,267,271,274,277,280,284,287,291,294,298,
    301,305,309,312,316,320,324,328,332,336,340,344,348,
    352,357,361,365,370,374,379,383,388,392,397,
    402,407,412,417,422,427,432,437,442,448,
    453,459,464,470,475,481,487,493,499,
    505,511,517,523,530,536,542,549,
    556,562,569,576,583,590,597,
    604,612,619,626,634,642,649,
    657,665,673,681,690,698,
    706,715,723,732,741,
    750,759,768,777,787,796,
    806,816,825,835,845,
    856,866,876,887,898,
    909,920,931,942,
    953,965,976,988
  );
var first,last,actual,step:integer;
begin
   first:=0;
   last:=(3 shl reihe)-1;
   showmessage(IntToStr(last));
   step:=1 shl (7-(reihe+4));
   repeat
      actual:=(first+last) shr 1;//(last div 2)*step;//(first+last) shr 1;
      result:=r24[actual*step];
      if result<>wert then
      begin
        if result>wert then
          last:=actual-1
        else
          last:=actual+1;
      end else exit;
   until first>last;
   if first<=((3 shl reihe)-1) then result:=r24[0];
end;

beim Aufruf
showmessage(IntToStr(findValue(e6,500))); wird die schleife nicht verlassen, es sollte natürlich 680 gefunden werden.
kann die Berechnung (bzw. den Sinn) von actual am anfang der schleife nicht nachvollziehen, da der wert kleiner wird, obwohl er größer werden sollte...

kann mir da jemand helfen?

Gruß Frank

[marabu]

Alles Gute im Neuen Jahr, Frank.

Ob das eine wirklich gute Idee ist - innerhalb der binären Suche eine Schrittweite einzuführen? Ich würde das außen vor lassen:

Delphi-Quellcode:

const
  E6: array [0..5] of Integer = (100, 150, 220, 330, 470, 680);

function Find(value: Integer; series: array of Integer; var index: Integer): Boolean;
var
  iLow, iHigh, i, c: Integer;
begin
  Result := False;
  iLow := 0;
  iHigh := High(series);
  while not Result and (iLow <= iHigh) do
  begin
    i := (iLow + iHigh) shr 1;
    if series[i] < value
      then iLow := Succ(i)
      else iHigh := Pred(i);
    Result := series[i] = value;
    if Result then
      iLow := i;
  end;
  index := iLow;
end;


// Test
var
  i, r: Integer;
begin
  Find(500, E6, i);
  if i = Length(E6)
    then r := 10 * E6[0]
    else r := E6[i];
end;

Getippt und nicht getestet.

Freundliche Grüße

[_frank_]

hi,
naja, die Arrays der unteren Reihen sind ja noch überschaubar, da würde das nicht stören.
Aber die reihen e48,e96 und e192 wären meines Erachtens sinnlose schreibarbeit, wenn man Schrittweiten verwenden kann...ich würde daher schon gern mit den Schrittweiten rechnen.
Diese sollte sich aber so ähnlich realisieren lassen, wie ich es probiert habe (pseudo-index verwenden und den werte-vergleich mittels pseudo-index * schrittweite machen).

dein test ergibt übrigens den falschen Wert (1000).

Gruß Frank

[_frank_]

so funktioniert es fast...

Delphi-Quellcode:

FUNCTION FindValue(reihe:byte; wert:integer):integer;
const
  //r3:array[0..2] of double=(1.0,2.2,4.7); //2^0
  //r6:array[0..5] of double=(1.0,1.5,2.2,3.3,4.7,6.8);//2^1
  //r12:array[0..11] of double=(1.0,1.2,1.5,1.8,2.2,2.7,3.3,3.9,4.7,5.6,6.8,8.2); //2^2
  r24:array[0..23] of integer=(100,110,120,130,150,160,180,200,220,240,270,300,330,360,390,430,470,510,560,620,680,750,820,910);//schrittweite 8 (1,9,...) =>E3 2^3
  r192:array[0..191] of double=(
    100,101,102,104,105,106,107,109,110,111,113,114,115,117,118,120,121,123,124,126,127,129,130,132,133,135,137,138,140,142,143,145,147,149,
    150,152,154,156,158,160,162,164,165,167,169,172,174,176,178,180,182,184,187,189,191,193,196,198,
    200,203,205,208,210,213,215,218,221,223,226,229,232,234,237,240,243,246,249,
    252,255,258,261,264,267,271,274,277,280,284,287,291,294,298,
    301,305,309,312,316,320,324,328,332,336,340,344,348,
    352,357,361,365,370,374,379,383,388,392,397,
    402,407,412,417,422,427,432,437,442,448,
    453,459,464,470,475,481,487,493,499,
    505,511,517,523,530,536,542,549,
    556,562,569,576,583,590,597,
    604,612,619,626,634,642,649,
    657,665,673,681,690,698,
    706,715,723,732,741,
    750,759,768,777,787,796,
    806,816,825,835,845,
    856,866,876,887,898,
    909,920,931,942,
    953,965,976,988
  );
var first,last,actual,step:integer;
    found:boolean;
begin
   first:=0;
   last:=(3 shl reihe)-1;
   step:=1 shl (7-(reihe+4));
   found:=false;
   actual:=-1;
   while not found and (first<=last) do
   begin
     actual:=(first+last) shr 1;
     if r24[actual*step]<wert then
       first:=actual+1
     else
       last:=actual-1;
   end;
   if first>((3 shl reihe)-1) then
     result:=r24[0]*10
   else
     result:=r24[actual*step];
end;

nur wenn der schleifenstartwert (bei e6 220=actual 2) der richtige wäre, ist das Ergebnis falsch. z.B.
showmessage(IntToStr(findValue(e6,215))); gibt mir nicht 220 sondern 150, das dieses der nächst-tiefere wert ist.

Wie könnte man das lösen?

[marabu]

Hi,

Zitat von _frank_:

dein test ergibt übrigens den falschen Wert (1000).

bei meinem Test kommen die richtigen Werte.

Hier mein Versuch mit verschachtelten Serien:

Delphi-Quellcode:

type
  TSeries = ({e192, e96, e48,} e24, e12, e6, e3);

function Lookup(value: Integer; series: TSeries): Integer;
const
  values: array [0..23] of Integer = (
    100,110,120,130,150,160,180,200,
    220,240,270,300,330,360,390,430,
    470,510,560,620,680,750,820,910
{
    100,101,102,104,105,106,107,109,110,111,113,114,115,117,118,120,
    121,123,124,126,127,129,130,132,133,135,137,138,140,142,143,145,
    147,149,150,152,154,156,158,160,162,164,165,167,169,172,174,176,
    178,180,182,184,187,189,191,193,196,198,200,203,205,208,210,213,
    215,218,221,223,226,229,232,234,237,240,243,246,249,252,255,258,
    261,264,267,271,274,277,280,284,287,291,294,298,301,305,309,312,
    316,320,324,328,332,336,340,344,348,352,357,361,365,370,374,379,
    383,388,392,397,402,407,412,417,422,427,432,437,442,448,453,459,
    464,470,475,481,487,493,499,505,511,517,523,530,536,542,549,556,
    562,569,576,583,590,597,604,612,619,626,634,642,649,657,665,673,
    681,690,698,706,715,723,732,741,750,759,768,777,787,796,806,816,
    825,835,845,856,866,876,887,898,909,920,931,942,953,965,976,988
}
  );
var
  iLow, iHigh, iStep, i: Integer;
begin
  Result := 10 * values[0];
  iStep := 1 shl Ord(series);
  iLow := 0;
  iHigh := Pred(Length(values) div iStep);
  while iLow <= iHigh do
  begin
    i := (iLow + iHigh) shr 1;
    if values[i * iStep] < value
      then iLow := Succ(i)
      else iHigh := Pred(i);
    if values[i * iStep] = value then
      iLow := i;
  end;
  if iLow * iStep < Length(values) then
    Result := values[iLow * iStep];
end;

procedure TDemoForm.Button11Click(Sender: TObject);
var
  s: String;
begin
  s := '';
  while InputQuery('E6 search', 'value', s) do
    s := IntToStr(Lookup(StrToInt(s), E6));
end;

Du wirst erkennen, wie du es umbauen kannst, damit es mit E192 arbeitet.

Gute Nacht