qm

// import qm module
var qm = require('qminer');
// get the compile flags
var flags = qm.flags;

// import qm module
var qm = require('qminer');
// get the module version
var version = qm.version;

var qm = require('qminer');
// create a simple base, where each record contains the student name and it's study group
// here we know the student is part of only one study group
var base = new qm.Base({
   mode: 'createClean',
   schema: [{
      name: "Class",
      fields: [
         { name: "Name", type: "string" },
         { name: "StudyGroup", type: "string" }
      ]
   }]
});
// create a feature space containing the categorical extractor, where it's values
// are taken from the field "StudyGroup": "A", "B", "C" and "D"
var ftr = new qm.FeatureSpace(base, { type: "categorical", source: "Class", field: "StudyGroup" });
// add a few records to the store
base.store("Class").push({ Name: "Fred", StudyGroup: "A" });
base.store("Class").push({ Name: "Wilma", StudyGroup: "B" });
base.store("Class").push({ Name: "Barney", StudyGroup: "C" });
// update the feature space to get the categories
ftr.updateRecords(base.store("Class").allRecords);
// get the feature vector for the first record
var vec = ftr.extractVector(base.store("Class")[0]); // returns vector [1, 0, 0]
base.close();

var qm = require('qminer');
// create a simple base, where each record contains only a persons name
var base = new qm.Base({
  mode: 'createClean',
  schema: [{
     name: "Person",
     fields: [{ name: "Name", type: "string" }]
  }]
});
// create a feature space containing the constant extractor, where the constant is equal 5
var ftr = new qm.FeatureSpace(base, { type: "constant", source: "Person", const: 5 });
// add a new record to the base
base.store("Person").push({ Name: "Peterson" });
// get the features of the record
var vec = ftr.extractVector(base.store("Person")[0]); // the vector [5]
base.close();

// import qm module
var qm = require('qminer');

// import qm module
var qm = require('qminer');

var qm = require('qminer');
// create a simple base, where each record contains the name of the student and his study groups
// each student is part of multiple study groups
var base = new qm.Base({
   mode: 'createClean',
   schema: [{
      name: "Class",
      fields: [
         { name: "Name", type: "string" },
         { name: "StudyGroups", type: "string_v" }
      ]
   }]
});
// create a feature space containing the jsfunc extractor, where the function counts the number
// of study groups each student is part of. The functions name is "NumberOFGroups", it's dimension
// is 1 (returns only one value, not an array)
var ftr = new qm.FeatureSpace(base, {
    type: "jsfunc", source: "Class", name: "NumberOfGroups", dim: 1,
    fun: function (rec) { return rec.StudyGroups.length; }
});
// add a record to the store
base.store("Class").push({ Name: "Gaben", StudyGroups: ["A", "B", "D"] });
// get the feature vector of the record
var vec = ftr.extractVector(base.store("Class")[0]); // returns vector [3]
base.close();

var qm = require('qminer');
// create a simple base, where each record contains the student name and an array of study groups
// here we know a student can be part of multiple study groups
var base = new qm.Base({
   mode: 'createClean',
   schema: [{
      name: "Class",
      fields: [
         { name: "Name", type: "string" },
         { name: "StudyGroups", type: "string_v" }
      ]
   }]
});
// create a feature space containing the multinomial extractor, where the values are normalized,
// and taken from the field "StudyGroup": "A", "B", "C", "D", "E", "F"
var ftr = new qm.FeatureSpace(base, {
    type: "multinomial", source: "Class", field: "StudyGroups", normalize: true
});
// add a few records to the store
base.store("Class").push({ Name: "Fred", StudyGroups: ["A", "B"] });
base.store("Class").push({ Name: "Wilma", StudyGroups: ["B", "C"] });
base.store("Class").push({ Name: "Barney", StudyGroups: ["C", "A"] });
// update the feature space to get the categories
ftr.updateRecords(base.store("Class").allRecords);
// get the feature vector for the first record
var vec = ftr.extractVector(base.store("Class")[0]); // returns vector [0.707, 0.707, 0]
base.close();

var qm = require('qminer');
// create a simple base, where each record contains the student name and it's grade
var base = new qm.Base({
   mode: 'createClean',
   schema: [{
      name: "Class",
      fields: [
         { name: "Name", type: "string" },
         { name: "Grade", type: "int" }
      ]
   }]
});
// create a feature space containing the numeric extractor, where the values are
// normalized, the values are taken from the field "Grade"
var ftr = new qm.FeatureSpace(base, { type: "numeric", source: "Class", normalize: "scale", field: "Grade" });
// add a new record to the base
base.store("Class").push({ Name: "Peterson", Grade: 9 });
base.store("Class").push({ Name: "Ericsson", Grade: 8 });
// update the feature space for scaling
ftr.updateRecords(base.store("Class").allRecords);
// get the features of the first record
var vec = ftr.extractVector(base.store("Class")[0]); // the vector with the random value
base.close();

var qm = require('qminer');

var qm = require('qminer');
// create a simple base, where each record contains only a persons name
var base = new qm.Base({
  mode: 'createClean',
  schema: [{
     name: "Person",
     fields: [{ name: "Name", type: "string" }]
  }]
});
// create a feature space containing the random extractor
var ftr = new qm.FeatureSpace(base, { type: "random", source: "Person" });
// add a new record to the base
base.store("Person").push({ Name: "Peterson" });
// get the features of the record
var vec = ftr.extractVector(base.store("Person")[0]); // the vector with the random value
base.close();

var qm = require('qminer');
// create a simple base, where each record contains the student name and it's grade
var base = new qm.Base({
   mode: 'createClean',
   schema: [{
      "name": "Class",
      "fields": [
         { "name": "Name", "type": "string" },
         { "name": "Features", "type": "num_sp_v" }
      ]
   }]
});
// create a feature space containing the numeric extractor, where the values are
// normalized, the values are taken from the field "Grade"
var ftr = new qm.FeatureSpace(base, { type: "num_sp_v", source: "Class", normalize: false, field: "Features" });
base.close();

var qm = require('qminer');
// create a simple base, where each record contains the title of the article and it's content
var base = new qm.Base({
   mode: 'createClean',
   schema: [{
      name: "Articles",
      fields: [
         { name: "Title", type: "string" },
         { name: "Text", type: "string" }
      ]
   }]
});
// create a feature spave containing the text (bag of words) extractor, where the values are normalized,
// weighted with 'tfidf' and the tokenizer is of 'simple' type, it uses english stopwords.
var ftr = new qm.FeatureSpace(base, {
    type: "text", source: "Articles", field: "Text", normalize: true, weight: "tfidf",
    tokenizer: { type: "simple", stopwords: "en"}
});
// add a few records to the store
base.store("Articles").push({ Title: "Article1", Text: "The last time we drew up the league table for bad banks, UBS was on top." });
base.store("Articles").push({ Title: "Article2", Text: "Barclays dropped a bombshell on its investment bankers last week." });
// update the feature space to get the the terms for the bag-of-words text representation
ftr.updateRecords(base.store("Articles").allRecords);
// extract the feature vector for the first article
var vec = ftr.extractSparseVector(base.store("Articles")[0]);
base.close();

var qm = require('qminer');
// create a simple movies store, where each record contains only the movie title.
var base = new qm.Base({
    mode: 'createClean',
    schema: [{
      name: "Movies",
      fields: [{ name: "title", type: "string" }]
    }]
});
base.close();

var qm = require('qminer');
 var base = new qm.Base({
     mode: 'createClean',
     schema: [
       { name: 'NewsArticles',
         fields: [
           { name: "ID", primary: true, type: "string", shortstring: true },
           { name: "Source", type: "string", codebook: true },
           { name: "DateTime", type: "datetime" },
           { name: "Title", type: "string", store: "cache" },
           { name: "Tokens", type: "string_v", store: "cache", null: true },
           { name: "Vector", type: "num_sp_v", store: "cache", null: true }]
       }
    ]
 });
// add a record:
// - we set the date using the ISO string representation
// - we set the string vector Tokens with an array of strings
// - we set the numeric sparse vector Vector with an array of two element arrays
//   (index, value), see the sparse vector constructor {@link module:la.SparseVector}
base.store('NewsArticles').push({
  ID: 't12344',
  Source: 's1234',
  DateTime: '2015-01-01T00:05:00',
  Title: 'the title',
  Tokens: ['token1', 'token2'],
  Vector: [[0,1], [1,1]]});
base.close();

var qm = require('qminer');
// Create two stores: People which stores only names of persons and Movies, which stores only titles.
// Each person can direct zero or more movies, so we use an index join named 'directed' and
// each movie has a single director, so we use a field join 'director'. The joins are
// inverses of each other. The inverse join simplifies the linking, since only one join needs
// to be specified, and the other direction can be linked automatically (in the example
// below we specify only the 'director' link and the 'directed' join is updated automatically).
//
var base = new qm.Base({
    mode: 'createClean',
    schema: [
      { name: 'People',
        fields: [{ name: 'name', type: 'string', primary: true }],
        joins: [{ name: 'directed', 'type': 'index', 'store': 'Movies', 'inverse': 'director' }] },
      { name: 'Movies',
        fields: [{ name: 'title', type: 'string', primary: true }],
        joins: [{ name: 'director', 'type': 'field', 'store': 'People', 'inverse': 'directed' }] }
    ]
});
// Adds a movie, automatically adds 'Jim Jarmusch' to People, sets the 'director' join (field join)
// and automatically updates the index join 'directed', since it's an inverse join of 'director'
base.store('Movies').push({ title: 'Broken Flowers', director: { name: 'Jim Jarmusch' } });

// Adds a movie, sets the 'director' join, updates the index join of 'Jim Jarmusch'
base.store('Movies').push({ title: 'Coffee and Cigarettes', director: { name: 'Jim Jarmusch' } });
// Adds movie, automatically adds 'Lars von Trier' to People, sets the 'director' join
// and 'directed' inverse join (automatically)
base.store('Movies').push({ title: 'Dogville', director: { name: 'Lars von Trier' } });

// Adds a person, sets the 'directed' join with multiple movies ('directed' is of type 'index', movies must be given in an array)
base.store('People').push({ name: 'Christopher Nolan', directed: [{ title: 'Inception' }, { title: 'Interstellar' }] });

var movie = base.store('Movies')[0]; // get the first movie (Broken Flowers)
// Each movie has a property corresponding to the join name: 'director'.
// Accessing the property returns a {@link module:qm.Record} from the store People.
var person = movie.director; // get the director
var personName = person.name; // get person's name ('Jim Jarmusch')

// Each person has a property corresponding to the join name: 'directed'.
// Accessing the property returns a {@link module:qm.RecSet} from the store People.
var movies = person.directed; // get all the movies the person directed.
movies.each(function (movie) { var title = movie.title; });
// Gets the following titles:
//   'Broken Flowers'
//   'Coffee and Cigarettes'
base.close();

var qm = require('qminer');
// Create a store People which stores only names of persons.
var base = new qm.Base({
    mode: 'createClean',
    schema: [
        { name: 'People',
          fields: [{ name: 'name', type: 'string', primary: true }],
          keys: [
            { field: 'name', type: 'value'},
            { field: 'name', name: 'nameText', type: 'text'}
         ]
       }
    ]
});

base.store('People').push({name : 'John Smith'});
base.store('People').push({name : 'Mary Smith'});
// search based on indexed values
base.search({$from : 'People', name: 'John Smith'}); // Return the record set containing 'John Smith'
// search based on indexed values
base.search({$from : 'People', name: 'Smith'}); // Returns the empty record set
// search based on text indexing
base.search({$from : 'People', nameText: 'Smith'}); // Returns both records
base.close();

Define window by number of records

var qm = require('qminer');
// create base
var base = new qm.Base({ mode: 'createClean' });
// create store with window
base.createStore({
    "name": "TestStore",
    "fields": [
        { "name": "DateTime", "type": "datetime" },
        { "name": "Measurement", "type": "float" }
    ],
    window: 3,
});

// push 5 records into created store
for (var i = 0; i < 5; i++) {
    var rec = {
        "DateTime": new Date().toISOString(),
        "Measurement": i
    };
    base.store("TestStore").push(rec);
}

// check number of records in store
base.store("TestStore").allRecords.length; // 5
// clean base with garbage collector
base.garbageCollect();
// check number of records in store
base.store("TestStore").allRecords.length; // 3
base.close();

Define window by time

var qm = require('qminer');
// create base
var base = new qm.Base({ mode: 'createClean' });
// create store with window
base.createStore({
    "name": "TestStore",
    "fields": [
        { "name": "DateTime", "type": "datetime" },
        { "name": "Measurement", "type": "float" }
    ],
    timeWindow: {
        duration: 2,
        unit: "hour",
        field: "DateTime"
    }
});

// push 5 records into created store
for (var i = 0; i < 5; i++) {
    var rec = {
        "DateTime": new Date(new Date().getTime() + i * 60 * 60 * 1001).toISOString(),
        "Measurement": i
    };
    base.store("TestStore").push(rec);
}

// check number of records in store
base.store("TestStore").allRecords.length; // 5
// clean base with garbage collector
base.garbageCollect();
// check number of records in store
base.store("TestStore").allRecords.length; // 2
base.close();

var qm = require('qminer');
// create a base with a simple timeseries store
var base = new qm.Base({
    mode: 'createClean',
    schema: [{
        name: 'default',
        fields: [
            { name: 'timestamp', type: 'datetime' },
            { name: 'value', type: 'float' }
        ]
    }]
});
var store = base.store('default');
// the tick aggregate reads from the store (provides time series input to other aggregates)
var raw = store.addStreamAggr({
    type: 'timeSeriesTick',
    timestamp: 'timestamp',
    value: 'value'
});

// will compute sums over 1 second intervals
var resampler = store.addStreamAggr({
    type: 'aggrResample',
    inAggr: raw.name,
    start: '1970-01-01T00:00:00.000',
    defaultValue: 0,
    aggType: 'sum',
    interval: 1000
});

// will print out resampler state on each resample
var resamplerOutput = new qm.StreamAggr(base, new function () {
    this.onStep = function () {
        console.log('Resampler emitted the sum: ' + resampler.getFloat() +
            ' for the interval [' + new Date(resampler.getTimestamp()).toISOString() +
            ' - ' + new Date(resampler.getTimestamp() + resampler.getParams().interval).toISOString() + ')');
    }
});

// IMPORTANT. After the output exists, connect it to resampler
resampler.setParams({ outAggr: resamplerOutput.name });

store.push({ timestamp:  1, value: 1 });
store.push({ timestamp: 10, value: 10 });
store.push({ timestamp: 500, value: 100 });
store.push({ timestamp: 2000, value: 1000 }); // triggers two resampling steps (two intervals complete)
// // three measurements for the first interval
// Resampler emitted the sum: 111 for the interval [1970-01-01T00:00:00.000Z - 1970-01-01T00:00:01.000Z)
// // zero measurements for the second interval (does not skip empty)
// Resampler emitted the sum: 0 for the interval [1970-01-01T00:00:01.000Z - 1970-01-01T00:00:02.000Z)
store.push({ timestamp: 2001, value: 10000 });
store.push({ timestamp: 3000, value: 100000 }); // triggers one resampling step (one interval complete)
// // one measurement for the third interval
// Resampler emitted the sum: 11000 for the interval [1970-01-01T00:00:02.000Z - 1970-01-01T00:00:03.000Z)

base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store named Cars with 4 fields
var base = new qm.Base({
    mode: 'createClean',
    schema: [{
        name: 'Cars',
        fields: [
            { name: 'NumberOfCars', type: 'float' },
            { name: 'Temperature', type: 'float' },
            { name: 'Precipitation', type: 'float' },
            { name: 'Time', type: 'datetime' }
        ]
    }]
});
// create the store
var store = base.store('Cars');
// define a feature space aggregator on the Cars store which needs at least 2 records to be initialized. Use three of the
// four fields of the store to create feature vectors with normalized values.
var aggr = {
   name: "ftrSpaceAggr",
   type: "featureSpace",
   initCount: 2,
   update: true, full: false, sparse: true,
   featureSpace: [
       { type: "numeric", source: "Cars", field: "NumberOfCars", normalize: "var" },
       { type: "numeric", source: "Cars", field: "Temperature", normalize: "var" },
       { type: "numeric", source: "Cars", field: "Precipitation", normalize: "var" }
   ]
};
//create the feature space aggregator
var ftrSpaceAggr = base.store('Cars').addStreamAggr(aggr);
// define a new time series tick stream aggregator for the 'Cars' store, that takes the values from the 'NumberOfCars' field
// and the timestamp from the 'Time' field.
var aggr = {
    name: "tickAggr",
    type: "timeSeriesTick",
    store: "Cars",
    timestamp: "Time",
    value: "NumberOfCars"
};
//create the tick aggregator
var tickAggr = base.store('Cars').addStreamAggr(aggr);

//define an anomaly detection aggregator using nearest neighbor on the cars store that takes as input timestamped features.
// The time stamp is provided by the tick aggregator while the feature vector is provided by the feature space aggregator.
var aggr = {
    name: 'AnomalyDetectorAggr',
    type: 'nnAnomalyDetector',
    inAggrSpV: 'ftrSpaceAggr',
    inAggrTm: 'tickAggr',
    rate: [0.7, 0.5, 0.15],
    windowSize: 2
};
//create the anomaly detection aggregator
var anomaly = base.store('Cars').addStreamAggr(aggr);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series tick stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window should be 1 hour.
var timeser = {
   name: 'TimeSeriesAggr',
   type: 'timeSeriesTick',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius'
};
var timeSeries = base.store("Heat").addStreamAggr(timeser);

// add an exponentional moving average aggregator, that is connected with the 'TimeSeriesAggr' aggregator.
// It should interpolate with the previous value, the decay should be 3 seconds and the initWindow should be 2 seconds.
var ema = {
   name: 'emaAggr',
   type: 'ema',
   store: 'Heat',
   inAggr: 'TimeSeriesAggr',
   emaType: 'previous',
   interval: 3000,
   initWindow: 2000
};
var expoMovingAverage = base.store("Heat").addStreamAggr(ema);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Data",
       fields: [
           { name: "Text", type: "string" },
           { name: "Time", type: "datetime" }
       ]
   }]
});
var store = base.store("Data");
// create a new time series that emits data as sparse vector, based on text
var aggr = {
   name: 'featureSpaceWindow',
   type: 'timeSeriesWinBufFeatureSpace',
   store: store.name,
   timestamp: 'Time',
   featureSpace: {
      type: "categorical",
      source: store.name,
      field: "Text"
   },
   winsize: 1 // keep only most recent value in window
};
// attach sum
var sa = store.addStreamAggr(aggr);
var aggr2 = {
   name: 'sparseVectorSum',
   type: 'winBufSpVecSum',
   store: store.name,
   inAggr: aggr.name // this means that sum is equal to the most recent data
};
// ok, now attach EMA
var sa2 = store.addStreamAggr(aggr2);
var ema_def = {
   name: 'sparseVectorEma',
   type: 'emaSpVec',
   store: store.name,
   inAggr: aggr2.name,
   emaType: "next",
   interval: 2000,
   initWindow: 0
};
var ema = store.addStreamAggr(ema_def);
// add some data
store.push({ Time: 1000, Text: 'a' });
store.push({ Time: 2000, Text: 'b' });
store.push({ Time: 3000, Text: 'c' });
// display EMA data
ema.getValueVector().print();
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store named Cars with 4 fields
var base = new qm.Base({
    mode: 'createClean',
    schema: [{
        name: 'Cars',
        fields: [
            { name: 'NumberOfCars', type: 'float' },
            { name: 'Temperature', type: 'float' },
            { name: 'Precipitation', type: 'float' },
            { name: 'Time', type: 'datetime' }
        ]
    }]
});
// create the store
var store = base.store('Cars');
// define a feature space aggregator on the Cars store which needs at least 2 records to be initialized. Use three of the
// four fields of the store to create feature vectors with normalized values.
var aggr = {
   name: "ftrSpaceAggr",
   type: "featureSpace",
   initCount: 2,
   update: true, full: false, sparse: true,
   featureSpace: [
       { type: "numeric", source: "Cars", field: "NumberOfCars", normalize: "var" },
       { type: "numeric", source: "Cars", field: "Temperature", normalize: "var" },
       { type: "numeric", source: "Cars", field: "Precipitation", normalize: "var" }
   ]
};
//create the feature space aggregator
var ftrSpaceAggr = base.store('Cars').addStreamAggr(aggr);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window is 1 day.
var timeser = {
   name: 'TimeSeriesBuffer',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 86400000 // one day in miliseconds
};
var timeSeries = base.store("Heat").addStreamAggr(timeser);

// add a histogram aggregator, that is connected with the 'TimeSeriesAggr' aggregator
var aggrJson = {
   name: 'Histogram',
   type: 'onlineHistogram',
   store: 'Heat',
   inAggr: 'TimeSeriesBuffer',
   lowerBound: 0,
   upperBound: 10,
   bins: 5,
   addNegInf: false,
   addPosInf: false
};
var hist = base.store("Heat").addStreamAggr(aggrJson);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window is 1 day.
var timeser = {
   name: 'TimeSeriesAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 86400000 // one day in miliseconds
};
var timeSeries = base.store("Heat").addStreamAggr(timeser);

// add a max aggregator, that is connected with the 'TimeSeriesAggr' aggregator
var max = {
   name: 'MaxAggr',
   type: 'winBufMax',
   store: 'Heat',
   inAggr: 'TimeSeriesAggr'
};
var maximal = base.store("Heat").addStreamAggr(max);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Cars",
       fields: [
           { name: "NumberOfCars", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   },
   {
       name: "Temperature",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   },
   {
       name: "Merged",
       fields: [
           { name: "NumberOfCars", type: "float" },
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});
// create a new merger stream aggregator that mergers the records of the 'Cars' and 'Temperature' stores.
// The records are interpolated linearly and stored in the 'Merged' store.
var mer = {
   name: 'MergerAggr',
   type: 'merger',
   outStore: 'Merged',
   createStore: false,
   timestamp: 'Time',
   fields: [
       { source: 'Cars', inField: 'NumberOfCars', outField: 'NumberOfCars', interpolation: 'linear', timestamp: 'Time' },
       { source: 'Temperature', inField: 'Celsius', outField: 'Celsius', interpolation: 'linear', timestamp: 'Time' }
   ]
};
var merger = new qm.StreamAggr(base, mer);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window is 1 day.
var timeser = {
   name: 'TimeSeriesAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 86400000 // 1 day in miliseconds
};
var timeSeries = base.store("Heat").addStreamAggr(timeser);

// add a min aggregator, that is connected with the 'TimeSeriesAggr' aggregator
var min = {
   name: 'MinAggr',
   type: 'winBufMin',
   store: 'Heat',
   inAggr: 'TimeSeriesAggr'
};
var minimal = base.store("Heat").addStreamAggr(min);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window should be 1 day.
var timeser = {
   name: 'TimeSeriesAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 86400000
};
var timeSeries = base.store("Heat").addStreamAggr(timeser);

// add a moving average aggregator, that is connected with the 'TimeSeriesAggr' aggregator
var ma = {
   name: 'movingAverageAggr',
   type: 'ma',
   store: 'Heat',
   inAggr: 'TimeSeriesAggr'
};
var movingAverage = base.store("Heat").addStreamAggr(ma);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "WaterConsumption", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window is 1 day
var Celsius = {
   name: 'CelsiusAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 86400000
}; base.store("Heat").addStreamAggr(Celsius);

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'WaterConsumption' field
// and the timestamp from the 'Time' field. The size of the window is 1 day
var water = {
   name: 'WaterAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'WaterConsumption',
   winsize: 86400000
}; base.store("Heat").addStreamAggr(water);

// add a covariance aggregator, that is connected with the 'CelsiusAggr' and 'WaterAggr' aggregators
var covariance = {
   name: 'covarianceAggr',
   type: 'covariance',
   store: 'Heat',
   inAggrX: 'CelsiusAggr',
   inAggrY: 'WaterAggr'
}; base.store("Heat").addStreamAggr(covariance);

// add the two variance aggregators, that take from the 'Celsius' and 'WaterConsumption' fields, respectively
var celVar = {
   name: 'CelsiusVarAggr',
   type: 'variance',
   store: 'Heat',
   inAggr: 'CelsiusAggr'
}; base.store("Heat").addStreamAggr(celVar);

var waterVar = {
   name: 'waterVarAggr',
   type: 'variance',
   store: 'Heat',
   inAggr: 'WaterAggr'
}; base.store("Heat").addStreamAggr(waterVar);

// add a correlation aggregator, that is connected to 'CovarianceAggr', 'CelsiusVarAggr' and 'WaterValAggr' aggregators
var corr = {
   name: 'corrAggr',
   type: 'correlation',
   store: 'Heat',
   inAggrCov: 'covarianceAggr',
   inAggrVarX: 'CelsiusVarAggr',
   inAggrVarY: 'waterVarAggr'
};
var correlation = base.store("Heat").addStreamAggr(corr);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "WaterConsumption", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window is 1 day.
var Celsius = {
   name: 'CelsiusAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 86400000
}; base.store("Heat").addStreamAggr(Celsius);

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'WaterConsumption' field
// and the timestamp from the 'Time' field. The size of the window is 1 day.
var water = {
   name: 'WaterAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'WaterConsumption',
   winsize: 86400000
}; base.store("Heat").addStreamAggr(water);

// add a covariance aggregator, that is connected with the 'CelsiusAggr' and 'WaterAggr' stream aggregators
var covariance = {
   name: 'covAggr',
   type: 'covariance',
   store: 'Heat',
   inAggrX: 'CelsiusAggr',
   inAggrY: 'WaterAggr'
};
var covarianceAggr = base.store("Heat").addStreamAggr(covariance);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window is 1 day
var timeser = {
   name: 'TimeSeriesAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 86400000
};
var timeSeries = base.store("Heat").addStreamAggr(timeser);

// add a variance aggregator, that is connected with the 'TimeSeriesAggr' aggregator
var variance = {
   name: 'varAggr',
   type: 'variance',
   store: 'Heat',
   inAggr: 'TimeSeriesAggr'
};
var varianceAggr = base.store("Heat").addStreamAggr(variance);
base.close();

// main library
let qm = require('qminer');

// create a base with a simple store
// the store records results of clustering
base = new qm.Base({
    mode: "createClean",
    schema: [{
        name: "Store",
        fields: [
            { name: "Value", type: "float" },
            { name: "Time", type: "datetime" }
        ]
    }]
});

// create a new time series stream aggregator for the 'Store' store that takes the recorded cluster id
// and the timestamp from the 'Time' field. The size of the window is 2 hours.
let timeser = {
    name: 'seriesTick1',
    type: 'timeSeriesTick',
    store: 'Store',
    timestamp: 'Time',
    value: 'Value'
};
let timeSeries1 = base.store("Store").addStreamAggr(timeser);
// add a histogram aggregator, that is connected with the 'TimeSeries1' aggregator
let aggrPHT = {
    name: 'PageHinkley',
    type: 'pagehinkley',
    store: 'Store',
    inAggr: 'seriesTick1',
    minInstances: 1,
    delta: 0.005,
    lambda: 50,
    alpha: 0.9999
};
store = base.store("Store");
pht = store.addStreamAggr(aggrPHT);

// creating start time
let time = new Date();
let changes = 0;

// simulating concept drift at element 1000 in a time series
for (let i = 0; i < 2000; i++) {
    // add one second to the timestamp and create an ISO string
    time.setSeconds(time.getSeconds() + 1);
    let timeStr = time.toISOString();
    // create value
    let value = Math.random() * 1;
    if (i > 1000) {
        value = Math.random() * 2 + 1;
    }
    // adding values to the signal store
    store.push({ Time: timeStr, Value: value });
    // counting changes
    if (pht.saveJson().drift == 1) {
        changes++;
    }
}

// checking if drift has been correctly detected
if (changes >= 1) { console.log("Last concept drift was detected " + pht.val.driftOffset + " samples ago."); }
else { console.log("No concept drift was detected!"); }

// clean up
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store. The size of the window is 3 records.
var aggr = {
   name: 'Delay',
   type: 'recordBuffer',
   size: 3
};
base.store("Heat").addStreamAggr(aggr);
base.close();

// main library
var qm = require('qminer');

// create a store
var base = new qm.Base({
    mode: 'createClean',
    schema: [{
        name: 'testStore',
        fields: [
            { name: 'switchField', type: 'string' }
        ]
    }]
});
// select store
var store = base.store('testStore');

// first JS aggregate
var outAggr1 = new qm.StreamAggr(base, new function () {
    this.onAdd = function (rec) {
        console.log('first');
    }
});

// second JS aggregate
var outAggr2 = new qm.StreamAggr(base, new function () {
    this.onAdd = function (rec) {
        console.log('second');
    }
});

// switcher aggregate: calls outAggr1 when rec.switchField == 'a' and outAggr2 when rec.switchField == 'b'
var switcher = store.addStreamAggr({
    type: 'recordSwitchAggr',
    store: 'testStore',
    fieldName: 'switchField',
    $set: [{ key: 'a', aggrName: outAggr1.name },
           { key: 'b', aggrName: outAggr2.name }],
    throwMissing: false
});

store.push({ switchField: 'a' });
// outAggr1 prints `first`
store.push({ switchField: 'b' });
// outAggr2 prints `second`
store.push({ switchField: 'b' });
// outAggr2 prints `second`
store.push({ switchField: 'c' });
// nothing happens
store.push({ switchField: 'a' });
// outAggr1 prints `first`

// clean up
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   },
   {
       name: "interpolatedValues",
       fields: [
           { name: "Value", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});
// create a new resampler stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The interpolated values are stored in the 'interpolatedValues' store.
// The interpolation should be linear and the interval should be 2 seconds
var res = {
   name: 'resamplerAggr',
   type: 'resampler',
   store: 'Heat',
   outStore: 'interpolatedValues',
   timestamp: 'Time',
   fields: [{
       name: 'Celsius',
       interpolator: 'linear'
   }],
   createStore: false,
   interval: 2000
};
var resampler = base.store("Heat").addStreamAggr(res);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with X,Y measurements
var base = new qm.Base({
    mode: 'createClean',
    schema: [{
        name: 'Function',
        fields: [
            { name: 'Time', type: 'datetime' },
            { name: 'X', type: 'float' },
            { name: 'Y', type: 'float' }
        ]
    }]
});

var store = base.store('Function');

// 1 second buffer for X values
var winX = store.addStreamAggr({
    type: 'timeSeriesWinBuf',
    timestamp: 'Time',
    value: 'X',
    winsize: 1000
});
// 1 second buffer for Y values
var winY = store.addStreamAggr({
    type: 'timeSeriesWinBuf',
    timestamp: 'Time',
    value: 'Y',
    winsize: 1000
});

// the will find regression line, as well as two parallel quartile lines
var linReg = store.addStreamAggr({
    type: 'simpleLinearRegression',
    inAggrX: winX.name,
    inAggrY: winY.name,
    storeX: "Function",
    storeY: "Function",
    quantiles: [0.25, 0.75]
});

store.push({ Time: '2015-06-10T14:13:32.001', X: 0, Y: -2 });
store.push({ Time: '2015-06-10T14:13:32.002', X: 0, Y: -1 });
store.push({ Time: '2015-06-10T14:13:32.003', X: 0, Y: 1 });
store.push({ Time: '2015-06-10T14:13:32.004', X: 0, Y: 2 });
store.push({ Time: '2015-06-10T14:13:32.005', X: 1, Y: -1 });
store.push({ Time: '2015-06-10T14:13:32.006', X: 1, Y: -0 });
store.push({ Time: '2015-06-10T14:13:32.007', X: 1, Y: 2 });
store.push({ Time: '2015-06-10T14:13:32.008', X: 1, Y: 3 });

var res = linReg.saveJson();
res.bands[0]; // -1.5
res.bands[1]; // 1.5

base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window is 4 weeks
var timeser = {
   name: 'TimeSeriesBuffer',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 2419200000 // 4 weeks
};
var timeSeries = base.store("Heat").addStreamAggr(timeser);

// add a slotted-histogram aggregator, that is connected with the 'TimeSeriesAggr' aggregator
// it will present accumulated histogram for the last 2 hours (window) of the week (period) for the last 4 weeks (see aggregate above)
var aggrJson = {
   name: 'Histogram',
   type: 'onlineSlottedHistogram',
   store: 'Heat',
   inAggr: 'TimeSeriesBuffer',
   period: 604800000, // 1 week
   window: 7200000, // 2h
   bins: 5, // 5 possible clusters
   granularity: 300000  // 5 min
};
var hist = base.store("Heat").addStreamAggr(aggrJson);
base.close();

var qm = require('qminer');
var base = new qm.Base({
  mode: 'createClean',
  schema: [{
      name: 'Docs',
      fields: [
          { name: 'Time', type: 'datetime' },
          { name: 'Text', type: 'string' }
      ]
  }]
});
var store = base.store('Docs');

var aggr = {
  name: 'featureSpaceWindow',
  type: 'timeSeriesWinBufFeatureSpace',
  store: 'Docs',
  timestamp: 'Time',
  featureSpace: {
      type: "categorical",
      source: "Docs",
      field: "Text"
  },
  winsize: 1000
};
var sa = store.addStreamAggr(aggr);

var aggr2 = {
  name: 'sparseVectorSum',
  type: 'winBufSpVecSum',
  store: 'Docs',
  inAggr: 'featureSpaceWindow'
};
var sa2 = store.addStreamAggr(aggr2);

store.push({ Time: '2015-06-10T14:13:32.0', Text: 'a' }); // 0
store.push({ Time: '2015-06-10T14:13:33.0', Text: 'b' }); // 1
store.push({ Time: '2015-06-10T14:14:34.0', Text: 'c' }); // 2
store.push({ Time: '2015-06-10T14:15:35.0', Text: 'd' }); // 3
store.push({ Time: '2015-06-10T14:15:36.0', Text: 'e' }); // 4
store.push({ Time: '2015-06-10T14:15:37.0', Text: 'f' }); // 5

var valVec2 = sa2.getValueVector(); // [0, 0, 0, 0, 1, 1] - only vectors 4 and 5 remain in window

base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Income",
       fields: [
           { name: "Amount", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Income' store, that takes the values from the 'Amount' field
// and the timestamp from the 'Time' field. The size of the window should 1 week.
var timeser = {
   name: 'TimeSeriesAggr',
   type: 'timeSeriesWinBuf',
   store: 'Income',
   timestamp: 'Time',
   value: 'Amount',
   winsize: 604800000 // 7 days in miliseconds
};
var timeSeries = base.store("Income").addStreamAggr(timeser);

// add a sum aggregator, that is connected with the 'TimeSeriesAggr' aggregator
var sum = {
   name: 'SumAggr',
   type: 'winBufSum',
   store: 'Heat',
   inAggr: 'TimeSeriesAggr'
};
var sumAggr = base.store("Income").addStreamAggr(sum);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with the Time and Value fields
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Processor",
       fields: [
           { name: "Value", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});
var store = base.store('Processor');

// create a new time series stream aggregator for the 'Processor' store, that takes the value of the processor
// and the timestamp from the 'Time' field. The size of the window is 1 second.
var tick = {
    name: 'TickAggr',
    type: 'timeSeriesTick',
    store: 'Processor',
    timestamp: 'Time',
    value: 'Value',
    winsize: 1000 // one day in miliseconds
};
var timeSeries = store.addStreamAggr(tick);

// create the TDigest stream aggregator
var aggr = {
    name: 'TDigest',
    type: 'tdigest',
    store: 'Processor',
    inAggr: 'TickAggr',
    quantiles: [0.90, 0.95, 0.99, 0.999],
    minCount: 5
};
// add the stream aggregator to the 'Processor' store
var td = store.addStreamAggr(aggr);
store.push({ Time: '2015-12-01T14:20:32.0', Value: 0.9948628368 });
store.push({ Time: '2015-12-01T14:20:33.0', Value: 0.1077458826 });
store.push({ Time: '2015-12-01T14:20:34.0', Value: 0.9855685823 });
store.push({ Time: '2015-12-01T14:20:35.0', Value: 0.7796449082 });
// with this record the aggregator will initialize becuase it is the 5th record
store.push({ Time: '2015-12-01T14:20:36.0', Value: 0.0844943286 });

store.push({ Time: '2015-12-01T14:20:37.0', Value: 0.187490856 });
store.push({ Time: '2015-12-01T14:20:38.0', Value: 0.0779815107 });
store.push({ Time: '2015-12-01T14:20:39.0', Value: 0.8945312691 });
store.push({ Time: '2015-12-01T14:20:40.0', Value: 0.5574567409 });

// get the quantile estimations
var result = td.getFloatVector();
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series tick stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window should be 1 hour.
var timeser = {
   name: 'TimeSeriesTickAggr',
   type: 'timeSeriesTick',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius'
};
var timeSeries = base.store("Heat").addStreamAggr(timeser);

// a threshold aggregator, that is connected wit hthe 'TimeSeriesAggr' aggregator.
// It should output 1 when the temperature is over 3 degrees Celsius and 0 otherwise
var thresholdAggr = {
   name: 'thresholdAggr1',
   type: 'threshold',
   store: 'Heat',
   inAggr: 'TimeSeriesTickAggr',
   threshold: 3
};
var expoMovingAverage = base.store("Heat").addStreamAggr(thresholdAggr);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Students",
       fields: [
           { name: "Id", type: "float" },
           { name: "TimeOfGraduation", type: "datetime" }
       ]
   }]
});

// create a new time series tick stream aggregator for the 'Students' store, that takes the values from the 'Id' field
// and the timestamp from the 'TimeOfGraduation' field.
var tick = {
   name: 'TimeSeriesTickAggr',
   type: 'timeSeriesTick',
   store: 'Students',
   timestamp: 'TimeOfGraduation',
   value: 'Id',
};
var timeSeriesTick = base.store("Students").addStreamAggr(tick);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

// create a new time series stream aggregator for the 'Heat' store, that takes the values from the 'Celsius' field
// and the timestamp from the 'Time' field. The size of the window is 2 seconds (2000ms).
var aggr = {
   name: 'TimeSeriesAggr',
   type: 'timeSeriesWinBuf',
   store: 'Heat',
   timestamp: 'Time',
   value: 'Celsius',
   winsize: 2000
};
base.store("Heat").addStreamAggr(aggr);
base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Heat",
       fields: [
           { name: "Celsius", type: "float" },
           { name: "Time", type: "datetime" }
       ]
   }]
});

var store = base.store("Heat");
var tick = store.addStreamAggr({
    type: 'timeSeriesTick',
    timestamp: 'Time',
    value: 'Celsius'
});

var winbufvec = store.addStreamAggr({
    type: 'timeSeriesWinBufVector',
    inAggr: tick.name,
    winsize: 2000
});

store.push({ Time: '2015-06-10T14:13:32.0', Celsius: 1 });
winbufvec.getFloatVector().print(); // prints 1
store.push({ Time: '2015-06-10T14:33:30.0', Celsius: 2 });
winbufvec.getFloatVector().print(); // prints 2
store.push({ Time: '2015-06-10T14:33:31.0', Celsius: 3 });
winbufvec.getFloatVector().print(); // prints 2,3
store.push({ Time: '2015-06-10T14:33:32.0', Celsius: 4 });
winbufvec.getFloatVector().print(); // prints 2,3,4

base.close();

// import the qm module
var qm = require('qminer');
// create a base with a simple store
// the store records results of clustering
var base = new qm.Base({
mode: "createClean",
schema: [
{
  name: "Rpm",
  fields: [
      { name: "ClusterId", type: "float" },
      { name: "Time", type: "datetime" }
  ]
}]
});

var store = base.store('Rpm');

// create a new time series stream aggregator for the 'Rpm' store that takes the recorded cluster id
// and the timestamp from the 'Time' field. The size of the window is 4 weeks.
var timeser1 = {
  name: 'TimeSeries1',
  type: 'timeSeriesWinBuf',
  store: 'Rpm',
  timestamp: 'Time',
  value: 'ClusterId',
  winsize: 7200000 // 2 hours
};
var timeSeries1 = base.store("Rpm").addStreamAggr(timeser1);

// add a histogram aggregator, that is connected with the 'TimeSeries1' aggregator
var aggrJson1 = {
  name: 'Histogram1',
  type: 'onlineHistogram',
  store: 'Rpm',
  inAggr: 'TimeSeries1',
  lowerBound: 0,
  upperBound: 5,
  bins: 5,
  addNegInf: false,
  addPosInf: false
};
var hist1 = base.store("Rpm").addStreamAggr(aggrJson1);

// create a new time series stream aggregator for the 'Rpm' store that takes the recorded cluster id
// and the timestamp from the 'Time' field.
var timeser2 = {
  name: 'TimeSeries2',
  type: 'timeSeriesWinBuf',
  store: 'Rpm',
  timestamp: 'Time',
  value: 'ClusterId',
  winsize: 21600000 // 6 hours
};
var timeSeries2 = base.store("Rpm").addStreamAggr(timeser2);

// add a histogram aggregator, that is connected with the 'TimeSeries1' aggregator
var aggrJson2 = {
  name: 'Histogram2',
  type: 'onlineHistogram',
  store: 'Rpm',
  inAggr: 'TimeSeries2',
  lowerBound: 0,
  upperBound: 5,
  bins: 5,
  addNegInf: false,
  addPosInf: false
};
var hist2 = base.store("Rpm").addStreamAggr(aggrJson2);

// add diff aggregator that subtracts Histogram1 with 2h window from Histogram2 with 6h window
var aggrJson3 = {
  name: 'DiffAggr',
  type: 'onlineVecDiff',
  storeX: 'Rpm',
  storeY: 'Rpm',
  inAggrX: 'Histogram2',
  inAggrY: 'Histogram1'
}
var diff = store.addStreamAggr(aggrJson3);
base.close();

var assert = require('assert');
var qm = require('qminer');

// variables
var batchSize = 1000;
var nbatches = 10;

var dt = 10;
var windowMSec = batchSize*dt;

var quantileEps = 0.01;
var countEps = 0.0001;

var maxRelErr = quantileEps + 2*countEps;

var targetQuants = (function () {
    var quants = [];
    for (var prob = 0; prob <= 1; prob += 0.001) {
        quants.push(prob);
    }
    return quants;
})();

// create a base with a simple store
// the store records results of throwing two independent fair dices
var base = new qm.Base({
    mode: "createClean",
    schema: [
    {
        name: "hugeDie",
        fields: [
            { name: "value", type: "float" },
            { name: "time", type: "datetime" }
        ]
    }]
});
var store = base.store('hugeDie');

// create a new time series stream aggregator for the 'Dice' store, that takes the expected values of throwing a dice
// and the timestamp from the 'Time' field. The size of the window is 1 day.
var windowAggr = store.addStreamAggr({
    name: 'TimeSeries1',
    type: 'timeSeriesWinBuf',
    store: store,
    timestamp: 'time',
    value: 'value',
    winsize: windowMSec
});

var gk = store.addStreamAggr({
type: 'windowQuantiles',
    inAggr: windowAggr,
    quantileEps: quantileEps,
    countEps: countEps,
    quantiles: targetQuants
})

var vals = [];
for (var i = 0; i < batchSize; i++) {
    vals.push(i);
}
for (var batchN = 0; batchN < nbatches; batchN++) {
    // shuffle the array
    for (var i = 0; i < batchSize; i++) {
        var swapN = Math.floor(Math.random()*batchSize);
        var temp = vals[i];
        vals[i] = vals[swapN];
        vals[swapN] = temp;
    }

    for (var i = 0; i < batchSize; i++) {
        var time = (batchN*batchSize + i)*dt;
        store.push({ time: time, value: vals[i] })
    }

    var result = gk.getFloatVector();
    for (var i = 0; i < targetQuants.length; i++) {
        var pval = targetQuants[i];
        var quant_hat = result[i];
        assert(Math.floor((pval - maxRelErr)*batchSize) <= quant_hat);
        assert(Math.ceil((pval + maxRelErr)*batchSize) >= quant_hat);
    }
}