Wertereihe mit Zeitstempeln in Raster teilen

[Fralle]

Hallo,

ich habe eine Reihe von Werten (ca. 250) mit Zeitstempeln. Hier ein Beispielauszug:

06.07.2011 15:01:03.750 1.4327
06.07.2011 15:01:02.250 1.43265
06.07.2011 15:00:53.250 1.43275
06.07.2011 15:00:52.750 1.4327
06.07.2011 15:00:49.750 1.43265
06.07.2011 15:00:48.750 1.4326
06.07.2011 15:00:46.750 1.4327
06.07.2011 15:00:43.250 1.43265
06.07.2011 15:00:41.250 1.4326
06.07.2011 15:00:35.250 1.43255
06.07.2011 15:00:34.250 1.4325

Die Zeitstempel sind beliebig und haben unregelmäßige Abstände (einzige Einschränkung: sie sind immer auf Viertelsekunden gerundet).
Aus diesem Array möchte ich nun ein weiteres Objektarray generieren. Jedes Objekt dieses neuen Arrays soll immer einen bestimmten Zeitabschnitt (z.b. 10 Sekunden) abdecken und folgende vier Werte seines Zeitabschnitts speichern: erster, letzter, höchster, niedrigster.
Die 10-Sekunden-Abschnitte sollen immer geraden Werten entsprechen, also:

06.07.2011 15:00:00
06.07.2011 15:00:10
06.07.2011 15:00:20
06.07.2011 15:00:30
06.07.2011 15:00:40

Ist das verständlich erklärt?

Momentan habe ich noch keinen richtigen Ansatz, außer dass ich mit dem Date-Konstruktor und bspw. mit Number(date)%10000 leicht die Intervallgrenzen rausfiltern kann.

Könnt Ihr mir helfen eine Funktion zu entwickeln, die aus dem einfachen Array dieses Objektarray generieren kann?

[thomas_E]

Könnt Ihr mir helfen eine Funktion zu entwickeln, die aus dem einfachen Array dieses Objektarray generieren kann?

wo genau liegt dein Problem?
beim parsen des Strings in ein Date-Objekt?
beim erstellen des Arrays?
beim Filtern eines Intervalls?
beim filtern der 4 Werte eines Intervalls?

wo kommen diese Zeilen her? aus PHP? XML?
wieso dieses Format? (ich persönlich war schon immer ein Freund von UNIX-Timestamps)

[Fralle]

Zitat von thomas_E

wo genau liegt dein Problem?

Ich suche erstmal die grundsätzliche Herangehensweise, also die Struktur der Funktion und nicht die Syntax im Einzelnen.

Zitat von thomas_E

beim parsen des Strings in ein Date-Objekt?

Nein, kein Problem

Zitat von thomas_E

beim erstellen des Arrays?

var raster_array:Array = new Array();
raster_array[i] = new Object();
raster_array[i].letzter = xy;
raster_array[i].erster = xy;
raster_array[i].hoch = xy;
raster_array[i].tief = xy;
??
Sollte auch kein Problem sein...

Zitat von thomas_E

beim Filtern eines Intervalls?

Ich habe eine Funktion, die den Zeitstempel in ein Date-Objekt umwandeln kann und dieses als Number zurück gibt. Mit dieser Zahl und dieser einfachen Formel: new Date(zeit - zeit % intervms) (wobei die Var 'intervms' die Intervall-Größe in Millisekunden darstellt) oder ähnlich sollte ich das Intervall bestimmen können. Wie dieses Konstrukt in der Funktion untergebracht werden muss, weiss ich noch nicht.

Zitat von thomas_E

beim filtern der 4 Werte eines Intervalls?

Sollte auch nicht zu schwierig sein, ergibt sich teilweise auch weil bspw. gilt: der erste des neuen Intervalls ist immer der letzte des vorausgegangenen.

Zitat von thomas_E

wo kommen diese Zeilen her? aus PHP? XML?
wieso dieses Format? (ich persönlich war schon immer ein Freund von UNIX-Timestamps)

Ursprünglich ist es ein XML-File eines Webservice, das wird aber schon verarbeitet und in ein Array gebracht, welches ich als Grundlage für dieses weitere Array nehmen wollte...
Wie genau sehen die UNIX-Timestamps aus?

[thomas_E]

Ich suche erstmal die grundsätzliche Herangehensweise, also die Struktur der Funktion und nicht die Syntax im Einzelnen.

*g schau dir nochmal meine Fragen an, damit hast du doch schon eine Struktur, um das ganze abzuarbeiten.

Wie genau sehen die UNIX-Timestamps aus?

int-Werte, die Sekunden/Milisekunden seit dem 01.01.1970 00:00:00 GMT
PHP gibt einen Wert in Sekunden wieder, optional mit milisekunden-Angabe
über Date.getTime() erhälst du eine ganzzahl, die die Anzahl der Milisekunden seit o.g. Zeitpunkt wiedergibt.

[thomas_E]

PHP-Code:

var s:String = "06.07.2011 15:01:03.750 1.4327\n"
    + "06.07.2011 15:01:02.250 1.43265\n"
    + "06.07.2011 15:00:53.250 1.43275\n"
    + "06.07.2011 15:00:52.750 1.4327\n"
    + "06.07.2011 15:00:49.750 1.43265\n"
    + "06.07.2011 15:00:48.750 1.4326\n"
    + "06.07.2011 15:00:46.750 1.4327\n"
    + "06.07.2011 15:00:43.250 1.43265\n"
    + "06.07.2011 15:00:41.250 1.4326\n"
    + "06.07.2011 15:00:35.250 1.43255\n"
    + "06.07.2011 15:00:34.250 1.4325";

//enthält DatenObjekte mit value, date und ts
var arr:Array = parseArray(s.split("\n"));
//Demo:
var map10:Object = mapData(arr, 10, arr[0].ts/1000);
traceMap(map10);

var map60:Object = mapData(arr, 60);
traceMap( map60 );

var mapCrazy:Object = mapData(arr, 42.792);  //ein Interval von 42.792 Sekunden ist doch irre :D
traceMap( mapCrazy );


//FUNKTIONEN

//erzeugt aus dem Array eine "Karte" mit all den daten, die du benötigst
//interval und offset werden in Sekunden angegeben
function mapData(arr:Array, interval:Number, offset:Number):Object
{
    if(isNaN(offset)) offset = 0;
    
    var map:Object = {
        offset: offset,
        interval: interval,
        indices: []
    };
    
    for(var i:Number = arr.length; i--; ){
        var d:Object = arr[i];
        var n:Number = Math.floor((d.ts/1000 - offset) / interval);        //das n-te Zeitinterval seint 1.1.1970
        
        var segment:Object = map[n]
        if(!segment){
            map.indices.push(n);
            map[n] = {
                map: map,
                beginsAt: new Date( n * interval ),
                endsAt: new Date( (n+1) * interval-1 ),
                
                values: [d],
                //was ist dir hier lieber? Referenzen auf das Objekt, das den Wert enthält,
                //oder der jeweilige Wert selber?
                first: d,
                last: d,
                min: d,
                max: d
            };
        }else{
            segment.values.push(d);
            if(d.ts < segment.first.ts) segment.first = d;
            else if(d.ts > segment.last.ts) segment.last = d;
            
            if(d.value < segment.min.value) segment.min = d;
            else if(d.value > segment.max.value) segment.max = d;
        }
    }
    
    //cleanup
    map.indices.sort(Array.NUMERIC);
    for(i=map.indices.length; i--; ){
        map[ map.indices[i] ].values.sortOn('ts', Array.NUMERIC);
    }
    
    map.first = map[ map.indices[0] ];
    map.last = map[ map.indices[ map.indices.length-1 ] ];
    
    return map;
}


//parst das String-Array in ein Objekt-Array, und sortiert das einmal nach Zeitpunkt
function parseArray(arr:Array):Array
{
    arr = arr.slice();    //kopie erstellen
    for(var i:Number = arr.length; i--; ) arr[i] = parseLine(arr[i]);
    arr.sortOn("ts", Array.NUMERIC);
    return arr;
}

//parst eine einzelne Zeile, in ein Datums-Objekt, einen Timecode und den Wert
function parseLine(l:String):Object
{
    //Datum-und Uhrzeit 
    var s:String = "", t:Array = [];
    for(i=0; t.length < 7; ++i){
        var c:String = l.charAt(i);
        if(" :.".indexOf(c) > -1){
            t.push(parseInt(s, 10));
            s = "";
        }else{
            s += c;
        }
    }
    var d:Date = new Date(t[2], t[1], t[0], t[3], t[4], t[5], t[6]);
    
    //Wert
    var v:Number = parseFloat(l.substring(i, l.length));
    
    return {
        ts: Number(d),
        date: d,
        value: v
    };
}

//erzeugt einen umfangreichen Trace der Map
function traceMap(map:Object){
    var numIndices:Number = map.indices.length
    trace('');
    trace('Interval ' + map.interval + ' Seconds');
    trace("Number of Intervals: " + numIndices);
    trace('//////////');
    
//eine Möglichkeit
//    for(var s:String in map){
//        if(isNaN(s)) continue;

//ich persönlich würde hier jedoch diese bevorzugen
    for(var i:Number = 0; i<numIndices; ++i){
        var interval:Object = map[ map.indices[i] ];
        
        trace(map.indices[i] + '      from: ' + interval.beginsAt.toString() + 
            '   to: ' + interval.endsAt.toString());
        trace('  number of Values: ' + interval.values.length);
//        trace('  first @           ' +  interval.first.ts);
        trace('  first @           ' +  interval.first.date.toString());
//        trace('  last @            ' +  interval.last.ts);
        trace('  last @            ' +  interval.last.date.toString());
        trace('  min Value:        ' +  interval.min.value);
        trace('  max Value:        ' +  interval.max.value);
        trace('//////////');
    }
    trace('');
    
} 


Map:	enthält Segment-Objekte abhängig von Interval und offset, der verwendet wurde, um diese "Karte" zu erzeugen
	indices:	Array mit den belegten Indices
	interval:	Der Interval, der verwendet wurde, um diese Map anzulegen
	offset:		offset gibt einen Zeitversatz, quasi den Beginn der Rechnug der Zeitabschnitte an
	first:		das früheste Segment-Objekt (Zeitabschnitt)
	last:		das späteste Segment-Objekt (Zeitabschnitt)
	...			für jeden Eintrag in indices ist ein Segment in map vorhanden
				Beispiel: 
					wenn map.indices[0] == 12345 ist, 
					dann gibbet unter map[12345] ein Segment-Objekt dazu

Segment-Objekt:		Beschreibt einen Zeitabschnitt, bei einem bestimmten Interval, und die darin vorkommenden Datenobjekte
	values:		Array mit den DatenObjekten in diesem Zeitabschnitt
	beginsAt:	ein Date-Objekt, dass den Beginn des Zeitabschnittes angibt, den dieses Segment überdeckt
	endsAt:		ein Date-Objekt, dass das Ende des Zeitabschnittes angibt...
	first:		das früheste DatenObjekten
	last:		das späteste DatenObjekten
	min:		das Datenobjekt, mit dem niedrigsten value
	max:		das Datenobjekt mit dem höchsten value
	

DatenObjekt:	//Kleinste "Einheit" in diesem Baum, hält einfach nur Wert und Zeitpunkt zusammen
	date:		ein Date-Objekt, dass den Zeitpunkt dieses Eintrags definiert
	value:		der Wert dieses Eintrags,
	ts:			ein timestamp (in ms)

[Fralle]

Hallo Thomas,


vielen Dank für die ausführliche Antwort!
Ich werde mir das Script in allen Einzelheiten ansehen und das Rückmeldung geben.


Gruß,
Fralle