Zur Übersicht - INFO - Neueste 50 Beiträge - Neuer Beitrag - Suchen - FAQ - Zum CC1-Forum - Zum CC-Pro-Forum

Re: Array Datensatz kopieren Kategorie: Programmierung (von Detlef - 9.11.2020 18:22)
Als Antwort auf Re: Array Datensatz kopieren von André H. - 30.10.2020 17:26
Ich nutze:
C-Control II Station, OSOPT V3.1
Hallo André

ich habe nun meine Datenbankfunktion mit Index und Array fertiggestellt.
Dpos ist die aktuelle, Dfirst die erste und Dlast die letzte Position im Index.

Folgende Frage hätte ich da aber noch. Wenn ich die richtige Schreibposition gefunden habe, muss
ich ja alle Datens√§tze darunter um 1 Pos nach unten verschieben oder alle Datens√§tze dar√ľber um
1 Pos nach oben. Das sind dann iterativ ziemlich viele 1Byte Kopiervorgänge.
Kann man das auch irgendwie eleganter machen, bsbw. 4 oder 8 Byte mit einem Befehl um 1Byte
verschieben? Dein "CopyDatensatz" Vorschlag m√ľsste das ja auch schon leisten k√∂nnen, oder?

Beste Gruesse,

Detlef  


int Dpos, Dfirst, Dlast;

int idxDS[MaxHist+1];      // Index auf DS sortiert nach time

type schedule              // Datensatz f√ľr √?berwachung
{ long time;
   int aktor;
   int modi;
   int wert;
}

schedule DS[MaxHist];    // Tabelle DS mit [MaxHist] Eintr√§gen

/*****************************************************************************/
/* Rahmenbedingungen f√ľr Optimierung:                                        */
/* - gelesen und gel√∂scht wird nur vorn.                                     */
/* - Eingetragen wird nach gr√∂√?ter Wahrscheinlichkeit:                       */
/* - Zuerst hinten, dann an vorheriger Position, danach vorn                 */
/* - danach in der Tabelle korrekte Position suchen                          */
/* - getestet, fehlerfrei! Version 1.0                                       */
/*   jue, 06.11.2020                                                         */
/*****************************************************************************/
function DS_write(long timer, int aktor, int wert, int modi)
 {
 int pos,posx,posy,new;

 // Die Schreibposition nach Wahrscheinlichkeit suchen. Zuerst hinten,
 // dann an vorheriger Position, dann vorn ansonsten innerhalb der Tabelle
 if DS[idxDS[Dlast]].time < timer Dpos=Dlast+1;
 else if DS[idxDS[Dpos]].time < timer and DS[idxDS[Dpos+1]].time > timer Dpos=Dpos+1;
 else if DS[idxDS[Dfirst]].time > timer Dpos=Dfirst-1;
 else
   {
   posx=Dfirst; posy=Dlast;
   do  // mittig unterhalb oder oberhalb aktueller Pos. suchen
     {
     if timer < DS[idxDS[Dpos]].time {posy=Dpos; Dpos=(posx+Dpos)/2;}
     else {posx=Dpos; Dpos=((posy+Dpos)/2);}
     }
   while timer < DS[idxDS[Dpos]].time or timer > DS[idxDS[Dpos+1]].time;
   }
 // nachdem Schreibposition gefunden, nun den neuen DS eintragen
 if (Dpos-Dfirst) <= (Dlast-Dpos)      //  nach vorn umsortieren
   {
   if Dfirst > 0   {new=idxDS[Dfirst-1]; pos=Dfirst;}
   else {new=idxDS[Dfirst];  pos=Dfirst+1;}
   while pos <= Dpos {idxDS[pos-1]=idxDS[pos]; pos=pos+1;}
   Dfirst=Dfirst-1;                    // Index nach vorn erweitern
   idxDS[pos-1]=new;
   }
 else                                  // nach hinten umsortieren
   {
   if Dlast < MaxHist {new=idxDS[Dlast+1]; pos=Dlast;}
   else {new=idxDS[Dlast];  pos=Dlast-1;}
   while pos > Dpos {idxDS[pos+1]=idxDS[pos]; pos=pos-1;}
   Dlast=Dlast+1;                      // Index nach hinten verl√§ngern
   idxDS[pos+1]=new;
   }
 DS[new].time =timer;      // Datensatz schreiben
 DS[new].aktor=aktor;
 DS[new].wert =wert;
 DS[new].modi = modi;
 }



> Hallo Detlef,
>
> wenn nicht unbedingt erforderlich, sollte man nicht ständig umkopieren,
> sondern eher ein Index-Array erstellen in denen nur die Indizies sortiert werden.
>
> Aber nun erstmal Punkt f√ľr Punkt:
> Die Definition des eigenen Datentyps.
> Du hast einen Datentyp Datensatz definiert, der vier Arrays mit jeweils
> 50  Elementen hat. Ich denke, da√? Du das so nicht definieren wolltest,
> sondern ein Datensatz je ein Feld time, aktor, modi und wert haben soll.
> Dvon dann 50 Datensätze.
> Die Definition mu√? dann folgenderma√?en aussehen:
>
> type Datensatz
> { long time;
>   int aktor;
>   int modi;
>   int wert;
> }
>
> Datensatz test[50];
>

>
> Der nächste Punkt ist das Kopieren von eigenen Datentypen.
> Das geht leider nicht mit einfacher Zuweisung.
> F√ľr das OS sind eigene Datentypen einfach nur Arrays.
> Zum Kopieren mu√? man die Funktion copypos des Moduls mem.c2
> etwas mi√?brauchen, indem man eine eigene Funktion zusammenstellt.
> Das w√ľrde dann so aussehen:
>
> inline function copyDatensatz ( Datensatz dest[], int destpos, Datensatz src[], int srcpos, int len )
> {
>  inline vmcodes.VM_INLINE_SYSCALL+mem.Segment;
>  inline mem._COPY;
> }
>

>
> Beim Aufruf mu√?  man aber etwas rechnen oder eine Hilfsfunktoin verwenden.
> Ein Datensatz besteht hier aus 10 Byte. (long(4) + 3x int(2))
> Will man nun test[25] auf test[20] kopieren, schaut das so aus:
>
> copyDatensatz(Datensatz, 20*10, Datensatz, 25*10, 10);
>

> Wichtig dabei ist immer, da√? hier in Byte gerechnet werden mu√?.
> Als Anmerkung: Bei zusammengesetzten Datentypen - besonders bei
> mehr Mehrdimensionalen - immer auf die Gr√∂√?e achten.
> "Datensatz" ist eindimensional und hat hier 500 Byte, also kein Problem.
>
>
> Statt nun im Array selbst umzukopieren kann man sich auch ein Index-Array anlegen,
> welches man zum Sortieren nutzt.
> Der Vorteil ist, wenn man verschiedene Sortierungen ben√∂tigt, mu√? man nicht immer
> am Datensatz umkopieren, sondern man kann verschiende Index-Arrays nutzen.
>
>
> Datensatz test[50]; // 50 Datensätze
> byte Index[50]; //Arrays mit Index-Positionen, je nach Sortierung
>

> Wir brauchen hier zwar 50 Byte mehr RAM, sind aber flexibler in der Nutzung.
>
> Unsortiert weisen wir Index[] die Werte 0 bis 49 als Initialisieung zu:
> for i = 0 ... 49 Index[i]=i;
> Der Zugriff auf Datensatz erfolgt immer so:
> Datensatz[Index[Position]]
>
> Wenn nun Position 25 mit 20 getauscht werden soll, braucht man die Werte
> nur Index zuweisen:
> Index[20]=25;
> Index[25]=20;

> Und schon sind die Positionen bei Zugriff √ľber Datensatz[Index[Position]] getauscht.
>
>
>
> MfG André H.
>
>
> > Guten Morgen!
> >
> > Ich habe mal Zeit f√ľr eine Optimierung der Haussteuerung und br√§uchte etwas Unterst√ľtzung.
> >
> > Ich möchte "datenbankähnlich" Einträge in einem Array sortieren/indizieren.
> >
> > Dazu habe ich zwei Fragen:
> >
> > 1. Hat sich jemand damit schonmal befasst?
> >
> > 2. Folgende Detailfunktion w√ľrde mich schon weiterbringen:
> >
> >
> > Type Datensatz
> > { long time[50];
> >   int aktor[50];
> >   int modi [50];
> >   int wert [50];
> > }
> >
> > Datensatz test;
> >
> > function copy()
> > {
> > test[20] = test[25];  // ich m√∂chte also einen DS im Array "test" an eine andere Position kopieren
> >
> > }
> >
> >
> >

> >
> > F√ľr konstruktive Hilfe w√§re ich sehr dankbar.
> >
> > Beste Gr√ľ√?e
> >
> > Detlef
> >  
> >
> >
> >
> >
> >


    Antwort schreiben


Antworten: