GTSHelper (warpscript 3.0.0 API)

java.lang.Object
- io.warp10.continuum.gts.GTSHelper

public class GTSHelper
extends java.lang.Object

Helper class to manipulate Geo Time Series.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class GTSHelper.BinarySearchTickChoice
Option for the binarySearchTick function.

Nested Classes
Modifier and Type	Class and Description
`static class`	`GTSHelper.BinarySearchTickChoice` Option for the binarySearchTick function.

Constructor Summary

Constructors
Constructor and Description

GTSHelper()

Constructors
Constructor and Description
`GTSHelper()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static java.util.List<GeoTimeSerie>`	`apply(WarpScriptBinaryOp op, java.util.Collection<GeoTimeSerie> op1, java.util.Collection<GeoTimeSerie> op2, java.util.Collection<java.lang.String> bylabels)` Deprecated.
`static GeoTimeSerie`	`applyNAryFunction(WarpScriptNAryFunction function, java.util.Map<java.lang.String,java.lang.String> commonlabels, java.util.List<GeoTimeSerie>... subseries)`
`static java.util.List<java.lang.Number>`	`bbox(GeoTimeSerie gts)`
`static int`	`binarySearchTick(GeoTimeSerie gts, int fromIndex, int toIndex, long timestamp, GTSHelper.BinarySearchTickChoice tickChoice)` Gives the index of the first/last/arbitrary instance of the given timestamp in a sorted GTS.
`static int`	`binarySearchTick(GeoTimeSerie gts, long timestamp, GTSHelper.BinarySearchTickChoice tickChoice)`
`static java.util.List<GeoTimeSerie>`	`booleanGTSSplit(GeoTimeSerie gts, boolean shrink)`
`static void`	`booleanNot(GeoTimeSerie gts)`
`static java.util.BitSet`	`booleanValues(GeoTimeSerie gts)`
`static GeoTimeSerie`	`bSAX(GeoTimeSerie gts, int alphabetSize, int wordLen, int windowLen, boolean standardizePAA)` Produces a String GTS whose values are the encoded bSAX words of the sequence starting at each tick.
`static GeoTimeSerie`	`bucketize(GeoTimeSerie gts, long bucketspan, int bucketcount, long lastbucket, java.lang.Object aggregator, long maxbuckets, WarpScriptStack stack)`
`static GeoTimeSerie`	`bucketize(GeoTimeSerie gts, long bucketspan, int bucketcount, long lastbucket, WarpScriptBucketizerFunction aggregator, long maxbuckets)` Converts a Geo Time Serie into a bucketized version.
`static java.lang.String`	`buildSelector(GeoTimeSerie gts, boolean forSearch)`
`static java.lang.String`	`buildSelector(Metadata metadata, boolean forSearch)` Build a string representation of Metadata suitable for selection (via FIND/FETCH).
`static java.util.List<GeoTimeSerie>`	`chunk(GeoTimeSerie gts, long lastchunk, long chunkwidth, long chunkcount, java.lang.String chunklabel, boolean keepempty)` Splits a GTS in 'chunks' of equal time length.
`static java.util.List<GeoTimeSerie>`	`chunk(GeoTimeSerie gts, long lastchunk, long chunkwidth, long chunkcount, java.lang.String chunklabel, boolean keepempty, long overlap)`
`static java.util.List<GTSEncoder>`	`chunk(GTSEncoder encoder, long lastchunk, long chunkwidth, long chunkcount, java.lang.String chunklabel, boolean keepempty, long overlap)`
`static long`	`classId(byte[] key, GeoTimeSerie gts)` Compute the class Id of a Geo Time Serie instance.
`static long`	`classId(byte[] key, java.lang.String name)` Compute a class Id (metric name Id) using SipHash and the given key.
`static long`	`classId(long[] key, java.lang.String name)`
`static long`	`classId(long k0, long k1, java.lang.String name)`
`static void`	`clear(GeoTimeSerie gts)` Removes all values from a GTS instance by setting its value count to 0 and its type to UNDEFINED
`static java.util.Map<java.lang.String,java.lang.String>`	`commonAttributes(java.util.List<GeoTimeSerie> lgts)` Find common attributes, taking into account keys and values, in a list of GTSs.
`static java.util.List<GeoTimeSerie>`	`commonTicks(java.util.List<GeoTimeSerie> series)` Return shrinked versions of the input GTS containing only the ticks which have values in all input GTS.
`static GeoTimeSerie`	`compact(GeoTimeSerie gts, boolean preserveRanges)` Compact a GeoTimeSerie instance by removing measurements which have the same value/location/elevation as the previous one.
`static int`	`compareAllAtTick(GeoTimeSerie gts, int index1, int index2)` Compare data in a GTS at given indexes.
`static GeoTimeSerie`	`compensateResets(GeoTimeSerie gts, boolean resethigher)` Compensate resets by computing an offset each time a value decreased between two ticks.
`static void`	`copy(GeoTimeSerie src, int srcPos, GeoTimeSerie dest, int destPos, int length)` Copy the specified part of a GTS to an other specified part of GTS.
`static void`	`copyGeo(GeoTimeSerie from, GeoTimeSerie to)` Copy geo infos (location + elevation) from GTS 'from' into GTS 'to' Only infos for matching ticks with values in 'to' will be copied
`static GeoTimeSerie`	`cprob(GeoTimeSerie gts, java.lang.String separator)` Compute conditional probabilities given a GTS considering the values as the concatenation of given events plus the event for which we want to compute the probability, separated by 'separator'.
`static GeoTimeSerie`	`crop(GeoTimeSerie gts)` Crops a bucketized GTS so it spans the largest interval with actual values.
`static GeoTimeSerie`	`dedup(GeoTimeSerie gts)` Remove duplicate ticks from the GeoTimeSerie instance.
`static GeoTimeSerie`	`detect(GeoTimeSerie gts, int alphabetSize, int wordLen, int windowLen, java.util.Collection<java.lang.String> patterns, boolean standardizePAA)` Detect patterns in a Geo Time Serie instance.
`static java.util.List<GeoTimeSerie>`	`doubleExponentialSmoothing(GeoTimeSerie gts, double alpha, double beta)` Perform a double exponential smoothing on the input GTS.
`static double[]`	`doubleValues(GeoTimeSerie gts)`
`static void`	`dump(GTSEncoder encoder, java.io.PrintWriter pw)`
`static long`	`elevationAtIndex(GeoTimeSerie gts, int idx)` Return the elevation in a GeoTimeSerie at a given index
`static long`	`elevationAtTick(GeoTimeSerie gts, long tick)` Return the elevation in a Geo Time Serie at a given timestamp.
`static void`	`encodeName(java.lang.StringBuilder sb, java.lang.String name)`
`static void`	`encodeValue(java.lang.StringBuilder sb, java.lang.Object value)`
`static java.util.List<GeoTimeSerie>`	`fill(GeoTimeSerie gtsa, GeoTimeSerie gtsb, WarpScriptFillerFunction filler)` This function fills the gaps in two GTS so they end up with identical ticks
`static void`	`fillGTSIds(byte[] bytes, int offset, long classId, long labelsId)`
`static GeoTimeSerie`	`fillnext(GeoTimeSerie gts)` Fill missing values/locations/elevations in a bucketized GTS with the next encountered one.
`static GeoTimeSerie`	`fillprevious(GeoTimeSerie gts)` Fill missing values/locations/elevations in a bucketized GTS with the previously encountered one.
`static GeoTimeSerie`	`fillticks(GeoTimeSerie gts, long location, long elevation, java.lang.Object value, long[] ticks)` Fill the given ticks in a GTS with the elements provided.
`static GeoTimeSerie`	`fillvalue(GeoTimeSerie gts, long location, long elevation, java.lang.Object value)` Fill missing values/locations/elevations in a bucketized GTS with the given location/elevation/value.
`static long`	`firsttick(GeoTimeSerie gts)` Return the first tick in the GTS instance.
`static GeoTimeSerie`	`fullsort(GeoTimeSerie gts)` Sort the GTS by respectively by tick, value, location and elevation.
`static GeoTimeSerie`	`fullsort(GeoTimeSerie gts, boolean reversed)` Sort the GTS by respectively by tick, value, location and elevation.
`static GTSEncoder`	`fullsort(GTSEncoder encoder, boolean reversed)`
`static GTSEncoder`	`fullsort(GTSEncoder encoder, boolean reversed, long baseTimestamp)` Sort an encoder
`static GeoTimeSerie`	`fuse(java.util.Collection<GeoTimeSerie> chunks)`
`static boolean`	`geointersects(com.geoxp.GeoXPLib.GeoXPShape shape, GeoTimeSerie gts)`
`static boolean`	`geowithin(com.geoxp.GeoXPLib.GeoXPShape shape, GeoTimeSerie gts)`
`static int`	`getBucketCount(GeoTimeSerie gts)`
`static long`	`getBucketSpan(GeoTimeSerie gts)`
`static long[]`	`getElevations(GeoTimeSerie gts)` Return an array with a copy of the locations of the given GTS.
`static int[]`	`getFirstLastTicks(long[] ticks)`
`static long`	`getLastBucket(GeoTimeSerie gts)`
`static java.lang.Object`	`getLastValue(GeoTimeSerie gts)` Return the value of the most recent tick in this GTS.
`static long[]`	`getLocations(GeoTimeSerie gts)` Return an array with a copy of the locations of the given GTS.
`static long[]`	`getOriginalElevations(GeoTimeSerie gts)`
`static long[]`	`getOriginalLocations(GeoTimeSerie gts)`
`static long[]`	`getTicks(GeoTimeSerie gts)` Return an array with a copy of the ticks of the given GTS.
`static double[]`	`getValuesAsDouble(GeoTimeSerie gts)` Return an array with a copy of the GTS values as doubles
`static GeoTimeSerie.TYPE`	`getValueType(java.lang.Object value)`
`static long`	`gtsId(long[] key, long classId, long labelsId)` Compute a gts Id from given classId/labelsId.
`static java.lang.String`	`gtsIdToString(long classId, long labelsId)`
`static java.lang.String`	`gtsIdToString(long classId, long labelsId, boolean intern)`
`static java.lang.Object`	`highest(GeoTimeSerie gts)` Handy method to compute the maximum elevation of a GTS instance.
`static int`	`indexAtTick(GeoTimeSerie gts, long tick)`
`static GeoTimeSerie`	`integrate(GeoTimeSerie gts, double initialValue)` 'Integrate' a GTS, considering the value at each tick is a rate of change per second.
`static void`	`internalizeStrings(Metadata meta)` Transform a Metadata instance by 'intern'ing all of its strings.
`static boolean`	`isBucketized(GeoTimeSerie gts)`
`static boolean`	`isNormal(GeoTimeSerie gts, int buckets, double pcterror, boolean bessel)` Determine if a GTS' values are normally distributed.
`static GeoTimeSerie`	`isonormalize(GeoTimeSerie gts)` Normalize a GTS, replacing X by (X-MEAN)/(MAX-MIN) or 1.0
`static boolean`	`isReversed(GeoTimeSerie gts)` Tell if a GTS instance is considered reversed.
`static boolean`	`isSorted(GeoTimeSerie gts)` Tell if a GTS instance is considered sorted.
`static double`	`kurtosis(GeoTimeSerie gts, boolean bessel)`
`static long`	`labelsId_slow(byte[] key, java.util.Map<java.lang.String,java.lang.String> labels)`
`static long`	`labelsId(byte[] key, GeoTimeSerie gts)` Compute the labels Id of a GeoTimeSerie instance.
`static long`	`labelsId(byte[] key, java.util.Map<java.lang.String,java.lang.String> labels)` Compute a labels Id (unique hash of labels) using SipHash and the given key.
`static long`	`labelsId(long[] sipkey, java.util.Map<java.lang.String,java.lang.String> labels)`
`static long`	`labelsId(long sipkey0, long sipkey1, java.util.Map<java.lang.String,java.lang.String> labels)`
`static void`	`labelsToString(java.lang.StringBuilder sb, java.util.Map<java.lang.String,java.lang.String> labels, boolean expose)`
`static long`	`lasttick(GeoTimeSerie gts)` Return the last tick in the GTS instance.
`static long`	`locationAtIndex(GeoTimeSerie gts, int idx)` Return the location in a GeoTimeSerie at a given index.
`static long`	`locationAtTick(GeoTimeSerie gts, long tick)` Return the location in a Geo Time Serie at a given timestamp.
`static GeoTimeSerie`	`locationSort(GeoTimeSerie gts)`
`static long[]`	`longValues(GeoTimeSerie gts)`
`static void`	`lowess_stl(GeoTimeSerie fromGTS, GeoTimeSerie toGTS, int neighbours, int degree, int jump, double[] weights, double[] rho)` Version of LOWESS used in stl
`static java.lang.Object`	`lowest(GeoTimeSerie gts)` Handy method to compute the minimum elevation of a GTS instance.
`static GeoTimeSerie`	`lttb(GeoTimeSerie gts, int threshold, boolean timebased)`
`static java.util.List<GeoTimeSerie>`	`map(GeoTimeSerie gts, java.lang.Object mapper, long prewindow, long postwindow, long occurrences, boolean reversed, int step, boolean overrideTick, WarpScriptStack stack)`
`static java.util.List<GeoTimeSerie>`	`map(GeoTimeSerie gts, java.lang.Object mapper, long prewindow, long postwindow, long occurrences, boolean reversed, int step, boolean overrideTick, WarpScriptStack stack, java.util.List<java.lang.Long> outputTicks)`
`static java.util.List<GeoTimeSerie>`	`map(GeoTimeSerie gts, java.lang.Object mapper, long prewindow, long postwindow, long occurrences, boolean reversed, int step, boolean overrideTick, WarpScriptStack stack, java.util.List<java.lang.Long> outputTicks, boolean dedup)` Apply a mapper on a GeoTimeSerie instance and produce a new GTS instance with the result of the mapper application.
`static java.util.List<GeoTimeSerie>`	`map(GeoTimeSerie gts, WarpScriptMapperFunction mapper, long prewindow, long postwindow)`
`static java.util.List<GeoTimeSerie>`	`map(GeoTimeSerie gts, WarpScriptMapperFunction mapper, long prewindow, long postwindow, long occurrences, boolean reversed)`
`static java.util.List<GeoTimeSerie>`	`map(GeoTimeSerie gts, WarpScriptMapperFunction mapper, long prewindow, long postwindow, long occurrences, boolean reversed, int step, boolean overrideTick)`
`static java.lang.Object`	`max(GeoTimeSerie gts)` Handy method to compute the max value of a GTS instance.
`static GeoTimeSerie`	`merge(GeoTimeSerie base, GeoTimeSerie gts)` Merge 'gts' into 'base'.
`static GeoTimeSerie`	`mergeViaEncoders(java.util.List<GeoTimeSerie> series)` Merge GeoTimeSerie instances using GTSEncoders.
`static void`	`metadataToString(java.lang.StringBuilder sb, java.lang.String name, java.util.Map<java.lang.String,java.lang.String> labels, boolean expose)`
`static java.lang.Object`	`min(GeoTimeSerie gts)` Handy method to compute the min value of a GTS instance.
`static void`	`multiProvision(GeoTimeSerie gts, GeoTimeSerie.TYPE fallbackType, int numberOfValuesToAdd, int provisionSize)` Provision GTS arrays for several values.
`static double[]`	`musigma(GeoTimeSerie gts, boolean bessel)`
`static GeoTimeSerie`	`normalize(GeoTimeSerie gts)` Normalize a GTS, replacing X by (X-MIN)/(MAX-MIN) or 1.0
`static int`	`nticks(GeoTimeSerie gts)` Return the number of ticks in a GTS instance.
`static int`	`nvalues(GeoTimeSerie gts)` Return the number of values in a GTS instance.
`static GeoTimeSerie`	`onlybuckets(GeoTimeSerie gts)` Removes non-bucket points of a bucketized GTS
`static GTSEncoder`	`parse_regexp(GTSEncoder encoder, java.lang.String str, java.util.Map<java.lang.String,java.lang.String> extraLabels)` Parses a string representation of a measurement and return a single valued GTS
`static GTSEncoder`	`parse(GTSEncoder encoder, java.lang.String str)`
`static GTSEncoder`	`parse(GTSEncoder encoder, java.lang.String str, java.util.Map<java.lang.String,java.lang.String> extraLabels, java.lang.Long now)`
`static GTSEncoder`	`parse(GTSEncoder encoder, java.lang.String str, java.util.Map<java.lang.String,java.lang.String> extraLabels, java.lang.Long now, long maxValueSize)`
`static GTSEncoder`	`parse(GTSEncoder encoder, java.lang.String str, java.util.Map<java.lang.String,java.lang.String> extraLabels, java.lang.Long now, long maxValueSize, java.util.concurrent.atomic.AtomicBoolean parsedAttributes)`
`static GTSEncoder`	`parse(GTSEncoder encoder, java.lang.String str, java.util.Map<java.lang.String,java.lang.String> extraLabels, java.lang.Long now, long maxValueSize, java.util.concurrent.atomic.AtomicBoolean parsedAttributes, java.lang.Long maxpast, java.lang.Long maxfuture, java.util.concurrent.atomic.AtomicLong ignoredCount, boolean deltaAttributes)`
`static GTSEncoder`	`parse(GTSEncoder encoder, java.lang.String str, java.util.Map<java.lang.String,java.lang.String> extraLabels, java.lang.Long now, long maxValueSize, java.util.concurrent.atomic.AtomicBoolean parsedAttributes, java.lang.Long maxpast, java.lang.Long maxfuture, java.util.concurrent.atomic.AtomicLong ignoredCount, boolean deltaAttributes, long timeshift)`
`static GTSEncoder`	`parseJSON(GTSEncoder encoder, java.lang.String str, java.util.Map<java.lang.String,java.lang.String> extraLabels, java.lang.Long now)`
`static java.util.Map<java.lang.String,java.lang.String>`	`parseLabels(int initialCapacity, java.lang.String str)` Parses the string representation of labels.
`static java.util.Map<java.lang.String,java.lang.String>`	`parseLabels(java.lang.String str)`
`static java.util.LinkedHashMap<java.lang.String,java.lang.String>`	`parseLabelsSelectors(java.lang.String selectors)` Parse labels selectors and return a map of label name to selector.
`static java.lang.Object`	`parseValue_regexp(java.lang.String valuestr)`
`static java.lang.Object`	`parseValue(java.lang.String valuestr)`
`static java.util.Map<java.util.Map<java.lang.String,java.lang.String>,java.util.List<GeoTimeSerie>>`	`partition(java.util.Collection<GeoTimeSerie> series, java.util.Collection<java.lang.String> bylabels)` Partition a collection of Geo Time Serie instances into equivalence classes.
`static java.util.List<GeoTimeSerie>`	`partitionAndApply(java.lang.Object function, WarpScriptStack stack, WarpScriptStack.Macro validator, java.util.Collection<java.lang.String> bylabels, java.util.List<GeoTimeSerie>... series)` Apply a function (either a filter or n-ary op) onto collections of GTS instances.
`static java.util.Map<java.util.Map<java.lang.String,java.lang.String>,java.util.List<GeoTimeSerie>>`	`partitionAndApplyUnflattened(java.lang.Object function, WarpScriptStack stack, WarpScriptStack.Macro validator, java.util.Collection<java.lang.String> bylabels, java.util.List<GeoTimeSerie>... series)` Apply a function or filter GTS and keep the results ventilated per equivalence class This function has the side effect of unsetting classId/labelsId
`static java.util.Map<java.lang.String,java.util.regex.Pattern>`	`patternsFromSelectors(java.lang.String classLabelsSelectionString)` Return patterns for matching class and labels The class selector is associated with the 'null' key.
`static double`	`pointwise_lowess(GeoTimeSerie gts, int idx, long tick, int q, int p, double[] weights, double[] rho, double[] beta)`
`static double`	`pointwise_lowess(GeoTimeSerie gts, int idx, long tick, int q, int p, double[] weights, double[] rho, double[] beta, boolean reversed)` Compute local weighted regression at given tick
`static GeoTimeSerie`	`prob(GeoTimeSerie gts)` Convert a GTS into a GTS of the probability associated with the value present at each tick.
`static GeoTimeSerie`	`quantize(GeoTimeSerie gts, double[] bounds, java.lang.Object[] values)`
`static java.util.List<GeoTimeSerie>`	`reduce(WarpScriptReducerFunction reducer, java.util.Collection<GeoTimeSerie> series, java.util.Collection<java.lang.String> bylabels)`
`static java.util.List<GeoTimeSerie>`	`reduce(WarpScriptReducerFunction reducer, java.util.Collection<GeoTimeSerie> series, java.util.Collection<java.lang.String> bylabels, boolean overrideTick)`
`static java.util.Map<java.util.Map<java.lang.String,java.lang.String>,java.util.List<GeoTimeSerie>>`	`reduceUnflattened(WarpScriptReducerFunction reducer, java.util.Collection<GeoTimeSerie> series, java.util.Collection<java.lang.String> bylabels)`
`static java.util.Map<java.util.Map<java.lang.String,java.lang.String>,java.util.List<GeoTimeSerie>>`	`reduceUnflattened(WarpScriptReducerFunction reducer, java.util.Collection<GeoTimeSerie> series, java.util.Collection<java.lang.String> bylabels, boolean overrideTick)`
`static GeoTimeSerie`	`relabel(GeoTimeSerie gts, java.util.Map<java.lang.String,java.lang.String> newlabels)` Modify the labels of a GTS instance.
`static GTSEncoder`	`relabel(GTSEncoder encoder, java.util.Map<java.lang.String,java.lang.String> newlabels)`
`static void`	`removeValue(GeoTimeSerie gts, long timestamp, boolean all)` Remove a datapoint from a GTS.
`static GeoTimeSerie`	`rename(GeoTimeSerie gts, java.lang.String name)` Rename the given Geo Time Serie instance.
`static void`	`reset(GeoTimeSerie gts)`
`static GeoTimeSerie`	`rlowess(GeoTimeSerie gts, int q, int r, long d, int p)`
`static GeoTimeSerie`	`rlowess(GeoTimeSerie gts, int q, int r, long d, int p, double[] weights, double[] rho, boolean inplace)` Compute fast and robust version of LOWESS on a Geo Time Series, with a polynomial fit of degree p > 0.
`static void`	`setBucketCount(GeoTimeSerie gts, int bucketcount)`
`static void`	`setBucketSpan(GeoTimeSerie gts, long bucketspan)`
`static void`	`setElevationAtIndex(GeoTimeSerie gts, int idx, long elevation)` Set the elevation at a specific index in the GTS
`static void`	`setLastBucket(GeoTimeSerie gts, long lastbucket)`
`static void`	`setLocationAtIndex(GeoTimeSerie gts, int idx, long location)` Set the location at a specific index in the GTS
`static int`	`setValue(GeoTimeSerie gts, long timestamp, long geoxppoint, long elevation, java.lang.Object value, boolean overwrite)` Add a measurement at the given timestamp/location/elevation FIXME(hbs): If performance is bad due to autoboxing, we can always split addValue by type and have 4 methods instead of 1.
`static int`	`setValue(GeoTimeSerie gts, long timestamp, long geoxppoint, java.lang.Object value)`
`static int`	`setValue(GeoTimeSerie gts, long timestamp, java.lang.Object value)`
`static void`	`shrink(GeoTimeSerie gts)` Shrink the internal arrays of this GTS so their length matches the number of values.
`static void`	`shrink(GeoTimeSerie gts, double ratio)`
`static GeoTimeSerie`	`shrinkTo(GeoTimeSerie gts, int newsize)` Reduce the number of values in a GTS.
`static GTSEncoder`	`shrinkTo(GTSEncoder encoder, int newsize)` Shrink an encoder to at most a given number of values.
`static GeoTimeSerie`	`singleExponentialSmoothing(GeoTimeSerie gts, double alpha)` Perform exponential smoothing on a numeric GTS.
`static double`	`skewness(GeoTimeSerie gts, boolean bessel)`
`static GeoTimeSerie`	`slowmerge(GeoTimeSerie base, GeoTimeSerie gts, boolean overwrite)` Merge 'gts' into 'base' the slow way, i.e.
`static GeoTimeSerie`	`sort(GeoTimeSerie gts)` Sort the values (and associated locations/elevations) by order of ascending ticks.
`static GeoTimeSerie`	`sort(GeoTimeSerie gts, boolean reversed)` Sort the values (and associated locations/elevations) by order of their ticks
`static GeoTimeSerie`	`sortedMerge(GeoTimeSerie base, GeoTimeSerie gts)` Merge 2 GTSs into one sorted GTS, with values from gts overwriting values from base.
`static GTSEncoder`	`sortedMerge(java.util.List<java.lang.Object> params, boolean reversed)` Merge sorted GTS or encoders
`static int[]`	`sortIndices(long[] values, boolean reversed)` Return an array of indices sorted in the order of the matching value in the 'values' array.
`static GeoTimeSerie`	`standardize(GeoTimeSerie gts)` Standardize a numeric GeoTimeSerie
`static GeoTimeSerie`	`standardize(GeoTimeSerie gts, double mean, double sd)`
`static double`	`standardizedMoment(int moment, GeoTimeSerie gts, boolean bessel)`
`static java.util.List<GeoTimeSerie>`	`stl(GeoTimeSerie gts, int buckets_per_period, int inner, int outer, int neighbour_s, int degree_s, int jump_s, int neighbour_l, int degree_l, int jump_l, int neighbour_t, int degree_t, int jump_t, int neighbour_p, int degree_p, int jump_p)` Compute STL i.e.
`static long[]`	`stringToGTSId(java.lang.String s)`
`static java.lang.String[]`	`stringValues(GeoTimeSerie gts)`
`static GeoTimeSerie`	`subCycleSerie(GeoTimeSerie gts, long lastbucket, int buckets_per_period, boolean overwrite)`
`static GeoTimeSerie`	`subCycleSerie(GeoTimeSerie gts, long lastbucket, int buckets_per_period, boolean overwrite, GeoTimeSerie subgts)` Return a new GeoTimeSerie instance containing only the values of 'gts' that fall under timestamps that are bound by the same modulo class.
`static GeoTimeSerie`	`subSerie(GeoTimeSerie gts, long starttimestamp, long stoptimestamp, boolean overwrite)`
`static GeoTimeSerie`	`subSerie(GeoTimeSerie gts, long starttimestamp, long stoptimestamp, boolean overwrite, boolean copyLabels, GeoTimeSerie subgts)` Return a new GeoTimeSerie instance containing only the value of 'gts' which fall between 'starttimestamp' (inclusive) and 'stoptimestamp' (inclusive) The resulting GTS instance will be sorted.
`static long`	`tickAtIndex(GeoTimeSerie gts, int idx)` Return the tick at a given index in a GeoTimeSerie.
`static GeoTimeSerie`	`tickindex(GeoTimeSerie gts)` Produces a GTS instance similar to the original one except that its ticks will have been modified to reflect their index int the sequence, starting at 0.
`static GTSEncoder`	`tickindex(GTSEncoder encoder)`
`static java.util.Iterator<java.lang.Long>`	`tickIterator(GeoTimeSerie gts, boolean reversed)` Return an iterator on the GeoTimeSerie ticks.
`static java.util.List<java.lang.Long>`	`tickList(GeoTimeSerie gts)` Return a list with the ticks in a GeoTimeSerie.
`static java.lang.String`	`tickToString(long timestamp, long location, long elevation, java.lang.Object value)`
`static java.lang.String`	`tickToString(java.lang.StringBuilder clslbls, long timestamp, long location, long elevation, java.lang.Object value)` Return a string representation of a GTS measurement at 'tick'
`static GeoTimeSerie`	`timeclip(GeoTimeSerie gts, long start, long end)` Return a GTS which is a subset of the input GTS with only those ticks which fall between start and end (both inclusive).
`static GTSEncoder`	`timeclip(GTSEncoder encoder, long start, long end)` Clip a GTSEncoder
`static GeoTimeSerie`	`timescale(GeoTimeSerie gts, double scale)` Multiply the ticks of a GTS instance by a factor.
`static GeoTimeSerie`	`timeshift(GeoTimeSerie gts, long delta)` Shifts a GTS instance by the given time delta.
`static java.util.List<GeoTimeSerie>`	`timesplit(GeoTimeSerie gts, long quietperiod, int minvalues, java.lang.String labelname)` Split a GTS into multiple GTS by cutting in 'quiet zones', i.e.
`static void`	`unbucketize(GeoTimeSerie gts)`
`static byte[]`	`unpackGTSId(java.math.BigInteger bi)` Convert a GTS Id packed as a BigInteger into an array of bytes containing classId/labelsId in big endian representation
`static byte[]`	`unpackGTSId(java.lang.String s)`
`static long[]`	`unpackGTSIdLongs(java.lang.String s)`
`static java.lang.Object`	`valueAtIndex(GeoTimeSerie gts, int idx)` Return the value in a GTS instance at a given index.
`static java.lang.Object`	`valueAtTick(GeoTimeSerie gts, long tick)` Return the value in a Geo Time Serie at a given timestamp.
`static java.util.Map<java.lang.Object,java.lang.Long>`	`valueHistogram(GeoTimeSerie gts)` Build an occurrence count by value for the given time serie.
`static java.util.Map<java.lang.Object,java.lang.Long>`	`valueHistogram(GTSEncoder encoder)` Build an occurrence count by value for the given GTS Encoder.
`static java.util.Iterator<java.lang.String>`	`valueRepresentationIterator(GeoTimeSerie gts)`
`static GeoTimeSerie`	`valueSort(GeoTimeSerie gts)`
`static GeoTimeSerie`	`valueSort(GeoTimeSerie gts, boolean reversed)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - GTSHelper
```
public GTSHelper()
```
- Method Detail
  - sort
```
public static final GeoTimeSerie sort(GeoTimeSerie gts,
                                      boolean reversed)
```
    Sort the values (and associated locations/elevations) by order of their ticks
    
    Parameters:
    
    gts - The GeoTimeSerie instance to sort
    
    reversed - If true, the ticks will be sorted from most recent to least
    
    Returns:
    
    gts, only sorted
  - sort
```
public static final GeoTimeSerie sort(GeoTimeSerie gts)
```
    Sort the values (and associated locations/elevations) by order of ascending ticks.
    
    Parameters:
    
    gts - GeoTimeSerie instance to sort
    
    Returns:
    
    gts, only sorted
  - fullsort
```
public static final GeoTimeSerie fullsort(GeoTimeSerie gts)
```
    Sort the GTS by respectively by tick, value, location and elevation.
    
    Parameters:
    
    gts - The GTS instance to be sorted.
    
    Returns:
    
    a fully sorted GTS.
  - fullsort
```
public static final GeoTimeSerie fullsort(GeoTimeSerie gts,
                                          boolean reversed)
```
    Sort the GTS by respectively by tick, value, location and elevation.
    
    Parameters:
    
    gts - The GTS instance to be sorted.
    
    reversed - Whether to reverse the order of the returned list.
    
    Returns:
    
    a fully sorted GTS.
  - fullsort
```
public static GTSEncoder fullsort(GTSEncoder encoder,
                                  boolean reversed)
                           throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - fullsort
```
public static GTSEncoder fullsort(GTSEncoder encoder,
                                  boolean reversed,
                                  long baseTimestamp)
                           throws java.io.IOException
```
    Sort an encoder
    
    Throws:
    
    java.io.IOException
  - binarySearchTick
```
public static final int binarySearchTick(GeoTimeSerie gts,
                                         long timestamp,
                                         GTSHelper.BinarySearchTickChoice tickChoice)
```
  - binarySearchTick
```
public static final int binarySearchTick(GeoTimeSerie gts,
                                         int fromIndex,
                                         int toIndex,
                                         long timestamp,
                                         GTSHelper.BinarySearchTickChoice tickChoice)
```
    Gives the index of the first/last/arbitrary instance of the given timestamp in a sorted GTS. Similar in principle to Arrays.binarySearch
    
    Parameters:
    
    gts - The GTS in which the timestamp is searched
    
    timestamp - The searched timestamp
    
    Returns:
    
    the index of the last instance of the given timestamp in a sorted GTS or (-(insertion point) - 1).
  - valueSort
```
public static final GeoTimeSerie valueSort(GeoTimeSerie gts,
                                           boolean reversed)
```
  - valueSort
```
public static final GeoTimeSerie valueSort(GeoTimeSerie gts)
```
  - tickIterator
```
public static final java.util.Iterator<java.lang.Long> tickIterator(GeoTimeSerie gts,
                                                                    boolean reversed)
```
    Return an iterator on the GeoTimeSerie ticks. If the GTS is bucketized, one tick per bucket is returned, otherwise only the ticks for which there are values are returned. If the GTS is not bucketized, the ticks are first sorted in natural ordering. There is no tick deduplication.
    
    Parameters:
    
    gts - GeoTimeSerie instance for which to return an iterator
    
    reversed - If true, ticks will be returned from most recent to oldest
    
    Returns:
    
    an iterator on the GeoTimeSerie ticks.
  - booleanGTSSplit
```
public static java.util.List<GeoTimeSerie> booleanGTSSplit(GeoTimeSerie gts,
                                                           boolean shrink)
```
  - locationSort
```
public static GeoTimeSerie locationSort(GeoTimeSerie gts)
```
  - compareAllAtTick
```
public static int compareAllAtTick(GeoTimeSerie gts,
                                   int index1,
                                   int index2)
```
    Compare data in a GTS at given indexes. Compare ticks, then if equal, values, then if equal locations then if equal elevations. Be careful, no check is done on the validity of the indexes.
    
    Parameters:
    
    gts - The GTS to get the data form.
    
    index1 - The first index to get the data at in the GTS.
    
    index2 - The second index to get the data at in the GTS.
    
    Returns:
    
    -1 if the data at first given index is considered before, 1 if considered after else 0. Comparison is done using natural ordering and false before true.
  - tickAtIndex
```
public static long tickAtIndex(GeoTimeSerie gts,
                               int idx)
```
    Return the tick at a given index in a GeoTimeSerie.
    
    Parameters:
    
    gts - GeoTimeSerie instance to get the tick from.
    
    idx - Index of the tick.
    
    Returns:
    
    the tick value or Long.MIN_VALUE if no tick at that index.
  - tickList
```
public static java.util.List<java.lang.Long> tickList(GeoTimeSerie gts)
```
    Return a list with the ticks in a GeoTimeSerie.
    
    Returns:
    
    a list with the ticks in a GeoTimeSerie.
  - indexAtTick
```
public static int indexAtTick(GeoTimeSerie gts,
                              long tick)
```
  - valueAtTick
```
public static java.lang.Object valueAtTick(GeoTimeSerie gts,
                                           long tick)
```
    Return the value in a Geo Time Serie at a given timestamp. The GeoTimeSerie instance will be sorted if it is not already
    
    Parameters:
    
    gts - GeoTimeSerie instance from which to extract value
    
    tick - Timestamp at which to read the value
    
    Returns:
    
    The value at 'tick' or null if none exists
  - valueAtIndex
```
public static java.lang.Object valueAtIndex(GeoTimeSerie gts,
                                            int idx)
```
    Return the value in a GTS instance at a given index. Return null if no value exists for the given index.
    
    Parameters:
    
    gts - GeoTimeSerie instance from which to extract the value.
    
    idx - Index at which to read the value.
    
    Returns:
    
    The value at the given tick.
  - locationAtTick
```
public static long locationAtTick(GeoTimeSerie gts,
                                  long tick)
```
    Return the location in a Geo Time Serie at a given timestamp. The GeoTimeSerie instance will be sorted if it is not already.
    
    Parameters:
    
    gts - GeoTimeSerie instance from which to extract location
    
    tick - Timestamp at which to read the location
    
    Returns:
    
    The location at 'tick' (NO_LOCATION if none set).
  - locationAtIndex
```
public static long locationAtIndex(GeoTimeSerie gts,
                                   int idx)
```
    Return the location in a GeoTimeSerie at a given index.
    
    Parameters:
    
    gts - GeoTimeSerie instance from which to extract the location.
    
    idx - Index at which to read the location.
    
    Returns:
    
    The location in a GeoTimeSerie at a given index.
  - setLocationAtIndex
```
public static void setLocationAtIndex(GeoTimeSerie gts,
                                      int idx,
                                      long location)
```
    Set the location at a specific index in the GTS
    
    Parameters:
    
    gts - GeoTimeSerie instance to be modified.
    
    idx - Index at which to write the location.
    
    location - Location as HHCode to write.
  - elevationAtTick
```
public static long elevationAtTick(GeoTimeSerie gts,
                                   long tick)
```
    Return the elevation in a Geo Time Serie at a given timestamp. The GeoTimeSerie instance will be sorted if it is not already.
    
    Parameters:
    
    gts - GeoTimeSerie instance from which to extract elevation
    
    tick - Timestamp at which to read the elevation
    
    Returns:
    
    The elevation at 'tick' (NO_ELEVATION if none set).
  - setElevationAtIndex
```
public static void setElevationAtIndex(GeoTimeSerie gts,
                                       int idx,
                                       long elevation)
```
    Set the elevation at a specific index in the GTS
    
    Parameters:
    
    gts - GeoTimeSerie instance to be modified.
    
    idx - Index at which to write the elevation.
    
    elevation - Elevation to write.
  - elevationAtIndex
```
public static long elevationAtIndex(GeoTimeSerie gts,
                                    int idx)
```
    Return the elevation in a GeoTimeSerie at a given index
    
    Parameters:
    
    gts - GeoTimeSerie instance from which to extract elevation.
    
    idx - Index at which to read the elevation
    
    Returns:
    
    The elevation in the GeoTimeSerie at a given index (NO_ELEVATION if none set).
  - removeValue
```
public static void removeValue(GeoTimeSerie gts,
                               long timestamp,
                               boolean all)
```
    Remove a datapoint from a GTS.
    
    Parameters:
    
    gts - The GTS to alter
    
    timestamp - The timestamp at which to remove the value
    
    all - Boolean indicating whether or not we should remove all occurrences or simply the first one found
  - setValue
```
public static final int setValue(GeoTimeSerie gts,
                                 long timestamp,
                                 long geoxppoint,
                                 long elevation,
                                 java.lang.Object value,
                                 boolean overwrite)
```
    Add a measurement at the given timestamp/location/elevation FIXME(hbs): If performance is bad due to autoboxing, we can always split addValue by type and have 4 methods instead of 1.
    
    Parameters:
    
    gts - GeoTimeSerie instance to which the measurement must be added
    
    timestamp - Timestamp in microseconds of the measurement
    
    geoxppoint - Location of measurement as a GeoXPPoint
    
    elevation - Elevation of measurement in millimeters
    
    value - Value of measurement
    
    overwrite - Flag indicating whether or not to overwrite a previous measurement done at the same timestamp
    
    Returns:
    
    The number of values in the GeoTimeSerie, including the one that was just added
  - setValue
```
public static final int setValue(GeoTimeSerie gts,
                                 long timestamp,
                                 long geoxppoint,
                                 java.lang.Object value)
```
  - setValue
```
public static final int setValue(GeoTimeSerie gts,
                                 long timestamp,
                                 java.lang.Object value)
```
  - multiProvision
```
public static final void multiProvision(GeoTimeSerie gts,
                                        GeoTimeSerie.TYPE fallbackType,
                                        int numberOfValuesToAdd,
                                        int provisionSize)
```
    Provision GTS arrays for several values. If the arrays have enough space left, no provision is done. If arrays have not enough space left, a provision is done according to the given parameter.
    
    Parameters:
    
    gts - The GTS instance to provision space for.
    
    numberOfValuesToAdd - Minimum available space in arrays for new data.
    
    provisionSize - Array length increase in case arrays are too small.
  - subSerie
```
public static final GeoTimeSerie subSerie(GeoTimeSerie gts,
                                          long starttimestamp,
                                          long stoptimestamp,
                                          boolean overwrite,
                                          boolean copyLabels,
                                          GeoTimeSerie subgts)
```
    Return a new GeoTimeSerie instance containing only the value of 'gts' which fall between 'starttimestamp' (inclusive) and 'stoptimestamp' (inclusive) The resulting GTS instance will be sorted.
    
    Parameters:
    
    gts - GeoTimeSerie from which to extract values.
    
    starttimestamp - Oldest timestamp to consider (in microseconds)
    
    stoptimestamp - Most recent timestamp to consider (in microseconds)
    
    overwrite - Should we overwrite measurements which occur at the same timestamp to only keep the last one added.
    
    copyLabels - If true, labels will be copied from the original GTS to the subserie.
    
    Returns:
    
    The computed sub Geo Time Serie
  - subSerie
```
public static final GeoTimeSerie subSerie(GeoTimeSerie gts,
                                          long starttimestamp,
                                          long stoptimestamp,
                                          boolean overwrite)
```
  - subCycleSerie
```
public static final GeoTimeSerie subCycleSerie(GeoTimeSerie gts,
                                               long lastbucket,
                                               int buckets_per_period,
                                               boolean overwrite,
                                               GeoTimeSerie subgts)
                                        throws WarpScriptException
```
    Return a new GeoTimeSerie instance containing only the values of 'gts' that fall under timestamps that are bound by the same modulo class. The resulting GTS instance will be sorted and bucketized.
    
    Parameters:
    
    gts - GeoTimeSerie from which to extract values. It must be bucketized.
    
    lastbucket - Most recent timestamp to consider (in microseconds)
    
    buckets_per_period - Number of buckets of the input gts that sum up to a bucket for the sub cycle gts
    
    overwrite - Should we overwrite measurements which occur at the same timestamp to only keep the last one added.
    
    Returns:
    
    The computed sub cycle Geo Time Serie
    
    Throws:
    
    WarpScriptException
  - subCycleSerie
```
public static final GeoTimeSerie subCycleSerie(GeoTimeSerie gts,
                                               long lastbucket,
                                               int buckets_per_period,
                                               boolean overwrite)
                                        throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - bucketize
```
public static final GeoTimeSerie bucketize(GeoTimeSerie gts,
                                           long bucketspan,
                                           int bucketcount,
                                           long lastbucket,
                                           WarpScriptBucketizerFunction aggregator,
                                           long maxbuckets)
                                    throws WarpScriptException
```
    Converts a Geo Time Serie into a bucketized version. Bucketizing means aggregating values (with associated location and elevation) that lie within a given interval into a single one. Intervals considered span a given width called the bucketspan.
    
    Parameters:
    
    gts - Geo Time Serie to bucketize
    
    bucketspan - Width of bucket (time interval) in microseconds
    
    bucketcount - Number of buckets to use
    
    lastbucket - Timestamp of the end of the last bucket of the resulting GTS. If 0, 'lastbucket' will be set to the last timestamp of 'gts'.
    
    aggregator - Function used to aggregate values/locations/elevations
    
    Returns:
    
    A bucketized version of the GTS.
    
    Throws:
    
    WarpScriptException
  - bucketize
```
public static final GeoTimeSerie bucketize(GeoTimeSerie gts,
                                           long bucketspan,
                                           int bucketcount,
                                           long lastbucket,
                                           java.lang.Object aggregator,
                                           long maxbuckets,
                                           WarpScriptStack stack)
                                    throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - unbucketize
```
public static void unbucketize(GeoTimeSerie gts)
```
  - parse_regexp
```
public static GTSEncoder parse_regexp(GTSEncoder encoder,
                                      java.lang.String str,
                                      java.util.Map<java.lang.String,java.lang.String> extraLabels)
                               throws java.text.ParseException,
                                      java.io.IOException
```
    Parses a string representation of a measurement and return a single valued GTS
    
    Parameters:
    
    str - String representation to parse
    
    Returns:
    
    The resulting data in a GTSEncoder. The resulting encoder will not have classId/labelsId set.
    
    Throws:
    
    java.text.ParseException - if a parsing error occurred
    
    java.io.IOException
  - parseJSON
```
public static GTSEncoder parseJSON(GTSEncoder encoder,
                                   java.lang.String str,
                                   java.util.Map<java.lang.String,java.lang.String> extraLabels,
                                   java.lang.Long now)
                            throws java.io.IOException,
                                   java.text.ParseException
```
    Throws:
    
    java.io.IOException
    
    java.text.ParseException
  - parse
```
public static GTSEncoder parse(GTSEncoder encoder,
                               java.lang.String str,
                               java.util.Map<java.lang.String,java.lang.String> extraLabels,
                               java.lang.Long now)
                        throws java.text.ParseException,
                               java.io.IOException
```
    Throws:
    
    java.text.ParseException
    
    java.io.IOException
  - parse
```
public static GTSEncoder parse(GTSEncoder encoder,
                               java.lang.String str,
                               java.util.Map<java.lang.String,java.lang.String> extraLabels,
                               java.lang.Long now,
                               long maxValueSize)
                        throws java.text.ParseException,
                               java.io.IOException
```
    Throws:
    
    java.text.ParseException
    
    java.io.IOException
  - parse
```
public static GTSEncoder parse(GTSEncoder encoder,
                               java.lang.String str,
                               java.util.Map<java.lang.String,java.lang.String> extraLabels,
                               java.lang.Long now,
                               long maxValueSize,
                               java.util.concurrent.atomic.AtomicBoolean parsedAttributes)
                        throws java.text.ParseException,
                               java.io.IOException
```
    Throws:
    
    java.text.ParseException
    
    java.io.IOException
  - parse
```
public static GTSEncoder parse(GTSEncoder encoder,
                               java.lang.String str,
                               java.util.Map<java.lang.String,java.lang.String> extraLabels,
                               java.lang.Long now,
                               long maxValueSize,
                               java.util.concurrent.atomic.AtomicBoolean parsedAttributes,
                               java.lang.Long maxpast,
                               java.lang.Long maxfuture,
                               java.util.concurrent.atomic.AtomicLong ignoredCount,
                               boolean deltaAttributes)
                        throws java.text.ParseException,
                               java.io.IOException
```
    Throws:
    
    java.text.ParseException
    
    java.io.IOException
  - parse
```
public static GTSEncoder parse(GTSEncoder encoder,
                               java.lang.String str,
                               java.util.Map<java.lang.String,java.lang.String> extraLabels,
                               java.lang.Long now,
                               long maxValueSize,
                               java.util.concurrent.atomic.AtomicBoolean parsedAttributes,
                               java.lang.Long maxpast,
                               java.lang.Long maxfuture,
                               java.util.concurrent.atomic.AtomicLong ignoredCount,
                               boolean deltaAttributes,
                               long timeshift)
                        throws java.text.ParseException,
                               java.io.IOException
```
    Throws:
    
    java.text.ParseException
    
    java.io.IOException
  - parse
```
public static GTSEncoder parse(GTSEncoder encoder,
                               java.lang.String str)
                        throws java.text.ParseException,
                               java.io.IOException
```
    Throws:
    
    java.text.ParseException
    
    java.io.IOException
  - parseValue
```
public static java.lang.Object parseValue(java.lang.String valuestr)
                                   throws java.text.ParseException
```
    Throws:
    
    java.text.ParseException
  - parseValue_regexp
```
public static java.lang.Object parseValue_regexp(java.lang.String valuestr)
                                          throws java.text.ParseException
```
    Throws:
    
    java.text.ParseException
  - parseLabels
```
public static java.util.Map<java.lang.String,java.lang.String> parseLabels(int initialCapacity,
                                                                           java.lang.String str)
                                                                    throws java.text.ParseException
```
    Parses the string representation of labels. The representation is composed of name=value pairs separated by commas (','). Values are expected to be UTF-8 strings percent-encoded.
    
    Throws:
    
    java.text.ParseException - if a label name is incorrect.
  - parseLabels
```
public static java.util.Map<java.lang.String,java.lang.String> parseLabels(java.lang.String str)
                                                                    throws java.text.ParseException
```
    Throws:
    
    java.text.ParseException
  - classId
```
public static final long classId(byte[] key,
                                 java.lang.String name)
```
    Compute a class Id (metric name Id) using SipHash and the given key. We compute the class Id in two phases. During the first phase we compute the SipHash of the class name and the SipHash of the reversed class name. Then we compute the SipHash of the concatenation of those two hashes. This is done to mitigate potential collisions in SipHash. We assume that if a collision occurs for two class names CLASS0 and CLASS1, no collision will occur for the reversed class names (i.e. 0SSALC and 1SSALC), and that no collision will occur on concatenations of hash and hash of reversed input. We waste some CPU cycles compared to just computing a SipHash of the class name but this will ensure we do not risk synthezied collisions in classIds. In the highly unlikely event of a collision, we'll offer 12 months of free service to the customer who finds it!.
    
    Parameters:
    
    key - 128 bits SipHash key to use
    
    name - Name of metric to hash
  - classId
```
public static final long classId(long[] key,
                                 java.lang.String name)
```
  - classId
```
public static final long classId(long k0,
                                 long k1,
                                 java.lang.String name)
```
  - gtsId
```
public static final long gtsId(long[] key,
                               long classId,
                               long labelsId)
```
    Compute a gts Id from given classId/labelsId. We compute the palindromic SipHash of 'GTS:' + + ':' +
  - classId
```
public static final long classId(byte[] key,
                                 GeoTimeSerie gts)
```
    Compute the class Id of a Geo Time Serie instance.
    
    Parameters:
    
    key - 128 bits SipHash key to use
    
    gts - GeoTimeSerie instance for which to compute the classId
  - labelsId
```
public static final long labelsId(byte[] key,
                                  java.util.Map<java.lang.String,java.lang.String> labels)
```
    Compute a labels Id (unique hash of labels) using SipHash and the given key. The label Id is computed in two phases. During the first phase, we compute the SipHash of both label names and values. We then sort those pairs of hashes in ascending order (name hashes, then associated values). Note that unless there is a collision in name hashes, we should only have different name hashes since a label name can only appear once in the labels map. Once the hashes are sorted, we compute the SipHash of the ids array. In case of label names collisions (label0 and label1), the labels Id will be identical for the value set of label0 and label1, i.e. the labels Id will be the same for label0=X,label1=Y and label0=Y,label1=X. In case of label values collisions(X and Y), the labels Id will be identical when the colliding values are affected to the same label, i.e. the labels Id of label0=X will be the same as that of label0=Y. Even though those cases have a non zero probability of happening, we deem them highly improbable as there is a strong probability that the collision happens with some random data which would probably not be used as a label name or value which tend to have meaning. And if our hypothesis on randomness is not verified, we'll have the pleasure of showing the world a legible SipHash collision :-) And we'll offer 6 month of subscription to the customer who finds it!
    
    Parameters:
    
    key - 128 bit SipHash key to use
    
    labels - Map of label names to label values
  - labelsId
```
public static final long labelsId(long[] sipkey,
                                  java.util.Map<java.lang.String,java.lang.String> labels)
```
  - labelsId
```
public static final long labelsId(long sipkey0,
                                  long sipkey1,
                                  java.util.Map<java.lang.String,java.lang.String> labels)
```
  - labelsId_slow
```
public static final long labelsId_slow(byte[] key,
                                       java.util.Map<java.lang.String,java.lang.String> labels)
```
  - labelsId
```
public static final long labelsId(byte[] key,
                                  GeoTimeSerie gts)
```
    Compute the labels Id of a GeoTimeSerie instance.
    
    Parameters:
    
    key - 128 bits SipHash key to use
    
    gts - GeoTimeSerie instance for which to compute the labels Id
    
    Returns:
    
    Labels ID of a GeoTimeSerie instance
  - unpackGTSId
```
public static byte[] unpackGTSId(java.math.BigInteger bi)
```
    Convert a GTS Id packed as a BigInteger into an array of bytes containing classId/labelsId in big endian representation
    
    Parameters:
    
    bi - Packed GTS ID.
    
    Returns:
    
    array of bytes containing classId/labelsId in big endian representation
  - unpackGTSId
```
public static byte[] unpackGTSId(java.lang.String s)
```
  - unpackGTSIdLongs
```
public static long[] unpackGTSIdLongs(java.lang.String s)
```
  - gtsIdToString
```
public static java.lang.String gtsIdToString(long classId,
                                             long labelsId)
```
  - gtsIdToString
```
public static java.lang.String gtsIdToString(long classId,
                                             long labelsId,
                                             boolean intern)
```
  - stringToGTSId
```
public static long[] stringToGTSId(java.lang.String s)
```
  - fillGTSIds
```
public static void fillGTSIds(byte[] bytes,
                              int offset,
                              long classId,
                              long labelsId)
```
  - parseLabelsSelectors
```
public static final java.util.LinkedHashMap<java.lang.String,java.lang.String> parseLabelsSelectors(java.lang.String selectors)
                                                                                             throws java.text.ParseException
```
    Parse labels selectors and return a map of label name to selector. The syntax of the 'selectors' String is: NAME<TYPE>VALUE,NAME<TYPE>VALUE,... where <TYPE> is either '=' for exact matches or '~' for regular expression matches. NAME and VALUE are percent-encoded UTF-8 Strings.
    
    Parameters:
    
    selectors - Selectors following the syntax NAME<TYPE>VALUE,NAME<TYPE>VALUE,... to be parsed.
    
    Returns:
    
    A map from label name to selector.
    
    Throws:
    
    java.text.ParseException
  - patternsFromSelectors
```
public static java.util.Map<java.lang.String,java.util.regex.Pattern> patternsFromSelectors(java.lang.String classLabelsSelectionString)
                                                                                     throws java.text.ParseException
```
    Return patterns for matching class and labels The class selector is associated with the 'null' key. The labels selectors are associated with the label name they're associated with
    
    Parameters:
    
    classLabelsSelectionString - A string representation of a class/labels selector
    
    Returns:
    
    Patterns for matching class and labels.
    
    Throws:
    
    java.text.ParseException - when classLabelsSelectionString is not representing a selector.
  - valueRepresentationIterator
```
public static java.util.Iterator<java.lang.String> valueRepresentationIterator(GeoTimeSerie gts)
```
  - tickToString
```
public static java.lang.String tickToString(java.lang.StringBuilder clslbls,
                                            long timestamp,
                                            long location,
                                            long elevation,
                                            java.lang.Object value)
```
    Return a string representation of a GTS measurement at 'tick'
    
    Returns:
    
    String representation of a GTS measurement at 'tick'.
  - tickToString
```
public static java.lang.String tickToString(long timestamp,
                                            long location,
                                            long elevation,
                                            java.lang.Object value)
```
  - encodeValue
```
public static void encodeValue(java.lang.StringBuilder sb,
                               java.lang.Object value)
```
  - encodeName
```
public static void encodeName(java.lang.StringBuilder sb,
                              java.lang.String name)
```
  - slowmerge
```
public static GeoTimeSerie slowmerge(GeoTimeSerie base,
                                     GeoTimeSerie gts,
                                     boolean overwrite)
```
    Merge 'gts' into 'base' the slow way, i.e. copying values one at a time. If 'gts' and 'base' differ in type, no merging takes place, unless 'base' is empty. Values/locations/elevations in gts override those in base if they occur at the same tick. No check of name or labels is done, the name and labels of 'base' are not modified.
    
    Parameters:
    
    base - GTS instance into which other values should be merged
    
    gts - GTS instance whose values/locations/elevations should be merged.
    
    overwrite - Flag indicating whether or not to overwrite existing value at identical timestamp
    
    Returns:
    
    base
  - merge
```
public static GeoTimeSerie merge(GeoTimeSerie base,
                                 GeoTimeSerie gts)
```
    Merge 'gts' into 'base'. If 'gts' and 'base' differ in type, no merging takes place, unless 'base' is empty. No deduplication is done if the same tick is present in 'base' and 'gts'. No check of name or labels is done, the name and labels of 'base' are not modified.
    
    Parameters:
    
    base - GTS instance into which other values should be merged
    
    gts - GTS instance whose values/locations/elevations should be merged.
    
    Returns:
    
    base
  - mergeViaEncoders
```
public static GeoTimeSerie mergeViaEncoders(java.util.List<GeoTimeSerie> series)
                                     throws java.io.IOException
```
    Merge GeoTimeSerie instances using GTSEncoders. This is noticeably faster than what 'merge' is doing.
    
    Parameters:
    
    series - List of series to merge, the first one will be considered the base. Its metadata will be used.
    
    Returns:
    
    The merged series.
    
    Throws:
    
    java.io.IOException
  - sortedMerge
```
public static GeoTimeSerie sortedMerge(GeoTimeSerie base,
                                       GeoTimeSerie gts)
```
    Merge 2 GTSs into one sorted GTS, with values from gts overwriting values from base. If both GTSs are without duplicate, the result is also without duplicate. If there are some duplicates in base or gts, the result will contain some duplicates so it's best to avoid this situation. The returned GTS has the same classname, labels and attributes as the base GTS.
    
    Parameters:
    
    base - The GTS used as a reference
    
    gts - The GTS whose data is to be merged with that of base.
    
    Returns:
    
    A new instance of GTS, sorted and without duplicates if base and gts are without duplicates.
    
    Throws:
    
    java.lang.RuntimeException - when GTSs are not of the same type and base is not empty.
  - sortedMerge
```
public static GTSEncoder sortedMerge(java.util.List<java.lang.Object> params,
                                     boolean reversed)
                              throws WarpScriptException
```
    Merge sorted GTS or encoders
    
    Throws:
    
    WarpScriptException
  - fillprevious
```
public static GeoTimeSerie fillprevious(GeoTimeSerie gts)
```
    Fill missing values/locations/elevations in a bucketized GTS with the previously encountered one. Returns a filled clone of 'gts'. 'gts' is not modified.
    
    Parameters:
    
    gts - GeoTimeSerie to fill
  - fillnext
```
public static GeoTimeSerie fillnext(GeoTimeSerie gts)
```
    Fill missing values/locations/elevations in a bucketized GTS with the next encountered one.
    
    Parameters:
    
    gts - GeoTimeSerie to fill
    
    Returns:
    
    A filled clone of 'gts'.
  - fillvalue
```
public static GeoTimeSerie fillvalue(GeoTimeSerie gts,
                                     long location,
                                     long elevation,
                                     java.lang.Object value)
```
    Fill missing values/locations/elevations in a bucketized GTS with the given location/elevation/value.
    
    Parameters:
    
    gts - GeoTimeSerie to fill
    
    location - Location to use for filling
    
    elevation - Elevation to use for filling
    
    value - Value to use for filling 'gts'
    
    Returns:
    
    A filled clone of 'gts'.
  - fillticks
```
public static GeoTimeSerie fillticks(GeoTimeSerie gts,
                                     long location,
                                     long elevation,
                                     java.lang.Object value,
                                     long[] ticks)
```
    Fill the given ticks in a GTS with the elements provided. If the GTS is bucketized, do nothing.
    
    Parameters:
    
    gts - GeoTimeSerie instance to had its values filled.
    
    location - Location data to use for the filling.
    
    elevation - Elevation data to use for the filling.
    
    value - Value data to use for the filling.
    
    ticks - Ticks to be filled.
    
    Returns:
    
    A cloned and filled GTS or a cloned GTS if bucketized.
  - fill
```
public static final java.util.List<GeoTimeSerie> fill(GeoTimeSerie gtsa,
                                                      GeoTimeSerie gtsb,
                                                      WarpScriptFillerFunction filler)
                                               throws WarpScriptException
```
    This function fills the gaps in two GTS so they end up with identical ticks
    
    Parameters:
    
    gtsa - First GTS to fill
    
    gtsb - Second GTS to fill
    
    filler - Instance of filler to use for filling the gaps.
    
    Throws:
    
    WarpScriptException
  - compensateResets
```
public static GeoTimeSerie compensateResets(GeoTimeSerie gts,
                                            boolean resethigher)
```
    Compensate resets by computing an offset each time a value decreased between two ticks. If we have the following TS (from most recent to most ancient) : 10 5 1 9 4 3 7 2 1 we detect 2 resets (one between values 9 and 1, another one between 7 and 3). The compensated GTS will be 31 21 17 16 11 10 7 2 1
    
    Parameters:
    
    gts - GTS instance to compensate resets for
    
    resethigher - If true, indicates that resets will have higher values than counter value (i.e. counter decreases)
    
    Returns:
    
    A cloned GTS with compensated resets.
  - isBucketized
```
public static boolean isBucketized(GeoTimeSerie gts)
```
  - timesplit
```
public static java.util.List<GeoTimeSerie> timesplit(GeoTimeSerie gts,
                                                     long quietperiod,
                                                     int minvalues,
                                                     java.lang.String labelname)
```
    Split a GTS into multiple GTS by cutting in 'quiet zones', i.e. intervals of 'quietperiod' or more during which there were no measurements. If 'gts' has no values or if 'label' is already part of the labels of 'gts', then the resulting list of GTS will only contain a clone of 'gts'.
    
    Parameters:
    
    gts - GTS instance to split
    
    quietperiod - Minimum number of microseconds without values to consider a split. The previous value must be at least 'quietperiod' us ago.
    
    minvalues - Only produce GTS with more than 'minvalues' values, this is to ignore lone values
    
    labelname - Name to use for a label containing the GTS sequence (oldest GTS is 1, next is 2, ....). 'label' MUST NOT exist among the labels of 'gts'.
    
    Returns:
    
    The list of resulting GTS.
  - crop
```
public static GeoTimeSerie crop(GeoTimeSerie gts)
```
    Crops a bucketized GTS so it spans the largest interval with actual values. This method simply clones non bucketized GTS. For bucketized GTS, only values at bucket boundaries are kept.
    
    Parameters:
    
    gts - GTS instance to crop.
    
    Returns:
    
    A cropped version of GTS or a clone thereof if GTS was not bucketized.
  - timeshift
```
public static GeoTimeSerie timeshift(GeoTimeSerie gts,
                                     long delta)
```
    Shifts a GTS instance by the given time delta. All ticks will be shifted by 'delta'. For bucketized GTS instances, all buckets will be shifted by 'delta'.
    
    Parameters:
    
    gts - GTS instance to shift
    
    delta - Number of microsecondes to shift ticks by.
    
    Returns:
    
    A shifted version of 'gts'.
  - tickindex
```
public static GeoTimeSerie tickindex(GeoTimeSerie gts)
```
    Produces a GTS instance similar to the original one except that its ticks will have been modified to reflect their index int the sequence, starting at 0.
  - tickindex
```
public static GTSEncoder tickindex(GTSEncoder encoder)
                            throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - clear
```
public static void clear(GeoTimeSerie gts)
```
    Removes all values from a GTS instance by setting its value count to 0 and its type to UNDEFINED
    
    Parameters:
    
    gts - GTS instance to clear.
  - reset
```
public static void reset(GeoTimeSerie gts)
```
  - map
```
public static java.util.List<GeoTimeSerie> map(GeoTimeSerie gts,
                                               WarpScriptMapperFunction mapper,
                                               long prewindow,
                                               long postwindow,
                                               long occurrences,
                                               boolean reversed,
                                               int step,
                                               boolean overrideTick)
                                        throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - map
```
public static java.util.List<GeoTimeSerie> map(GeoTimeSerie gts,
                                               java.lang.Object mapper,
                                               long prewindow,
                                               long postwindow,
                                               long occurrences,
                                               boolean reversed,
                                               int step,
                                               boolean overrideTick,
                                               WarpScriptStack stack)
                                        throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - map
```
public static java.util.List<GeoTimeSerie> map(GeoTimeSerie gts,
                                               java.lang.Object mapper,
                                               long prewindow,
                                               long postwindow,
                                               long occurrences,
                                               boolean reversed,
                                               int step,
                                               boolean overrideTick,
                                               WarpScriptStack stack,
                                               java.util.List<java.lang.Long> outputTicks)
                                        throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - map
```
public static java.util.List<GeoTimeSerie> map(GeoTimeSerie gts,
                                               java.lang.Object mapper,
                                               long prewindow,
                                               long postwindow,
                                               long occurrences,
                                               boolean reversed,
                                               int step,
                                               boolean overrideTick,
                                               WarpScriptStack stack,
                                               java.util.List<java.lang.Long> outputTicks,
                                               boolean dedup)
                                        throws WarpScriptException
```
    Apply a mapper on a GeoTimeSerie instance and produce a new GTS instance with the result of the mapper application.
    
    Parameters:
    
    gts - GTS instance to apply the mapper on
    
    mapper - Mapper Function to use
    
    prewindow - Number of ticks or time interval to consider BEFORE each tick for which the computation is done. If number is 0, don't consider any ticks prior to the current one. If number is > 0, consider that many ticks prior to the current one. If number is < 0, consider that number negated of microseconds prior to the current tick. A delta comparison from the previous value will need a prewindow of 1 (1 tick before the current one). *
    
    postwindow - Same meaning as 'prewindow' but for the interval AFTER each tick.
    
    occurrences - Number of times to apply map, 0 means apply it for each tick. This is useful for some computations like sums where the only result that might matter is that of the latest tick
    
    reversed - Compute ticks backwards, starting from most recent one
    
    step - How many ticks to move the sliding window after each mapper application (>=1)
    
    outputTicks - Sorted list of ticks to use instead of the gts ticks (reverse sorted if reversed is true)
    
    overrideTick - If true, use the tick returned by the mapper instead of the current tick. This may lead to duplicate ticks, need to run DEDUP.
    
    Returns:
    
    A new GTS instance with the result of the Mapper.
    
    Throws:
    
    WarpScriptException
  - map
```
public static java.util.List<GeoTimeSerie> map(GeoTimeSerie gts,
                                               WarpScriptMapperFunction mapper,
                                               long prewindow,
                                               long postwindow,
                                               long occurrences,
                                               boolean reversed)
                                        throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - map
```
public static java.util.List<GeoTimeSerie> map(GeoTimeSerie gts,
                                               WarpScriptMapperFunction mapper,
                                               long prewindow,
                                               long postwindow)
                                        throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - relabel
```
public static GeoTimeSerie relabel(GeoTimeSerie gts,
                                   java.util.Map<java.lang.String,java.lang.String> newlabels)
```
    Modify the labels of a GTS instance. If a label appears in 'newlabels', the associated value will be used in 'gts', unless the associated value is the empty string or null in which case the said label will be removed from 'gts'. If a null key is present in the 'newlabels' map, the labels will replace those of 'gts' instead of modifying them.
    
    Parameters:
    
    gts - GTS instance whose labels must be modified.
    
    newlabels - Map of label names to label values.
  - relabel
```
public static GTSEncoder relabel(GTSEncoder encoder,
                                 java.util.Map<java.lang.String,java.lang.String> newlabels)
```
  - rename
```
public static GeoTimeSerie rename(GeoTimeSerie gts,
                                  java.lang.String name)
```
    Rename the given Geo Time Serie instance.
    
    Parameters:
    
    gts - GTS instance to rename.
    
    name - New name to give the GTS, or suffix to add to its current name if 'name' starts with '+' (the '+' will be trimmed).
  - partition
```
public static java.util.Map<java.util.Map<java.lang.String,java.lang.String>,java.util.List<GeoTimeSerie>> partition(java.util.Collection<GeoTimeSerie> series,
                                                                                                                     java.util.Collection<java.lang.String> bylabels)
```
    Partition a collection of Geo Time Serie instances into equivalence classes. Member of each equivalence class have at least a common set of values for 'bylabels', they may share common values for other labels too.
    
    Parameters:
    
    series - Collection of GTS to partition
    
    bylabels - Collection of label names to use for partitioning or null to use all labels of each GTS
    
    Returns:
    
    A map of label values to GTS instances
  - commonAttributes
```
public static java.util.Map<java.lang.String,java.lang.String> commonAttributes(java.util.List<GeoTimeSerie> lgts)
```
    Find common attributes, taking into account keys and values, in a list of GTSs.
    
    Parameters:
    
    lgts - List of GTSs to find common attributes from.
    
    Returns:
    
    The common attributes.
  - firsttick
```
public static long firsttick(GeoTimeSerie gts)
```
    Return the first tick in the GTS instance.
    
    Parameters:
    
    gts - GeoTimeSerie to return the first tick for.
    
    Returns:
    
    The first tick or Long.MAX_VALUE if 'gts' is not bucketized and has no values.
  - lasttick
```
public static long lasttick(GeoTimeSerie gts)
```
    Return the last tick in the GTS instance.
    
    Parameters:
    
    gts - GeoTimeSerie to return the last tick for.
    
    Returns:
    
    The last tick or Long.MIN_VALUE if 'gts' is not bucketized and has no values.
  - nticks
```
public static int nticks(GeoTimeSerie gts)
```
    Return the number of ticks in a GTS instance. If the GTS is bucketized, the number of buckets is returned, not the number of actual values.
    
    Parameters:
    
    gts - GeoTimeSerie instance of which to count ticks.
    
    Returns:
    
    Number of ticks in GTS
  - nvalues
```
public static int nvalues(GeoTimeSerie gts)
```
    Return the number of values in a GTS instance.
    
    Parameters:
    
    gts - GeoTimeSerie instance of which to count values.
    
    Returns:
    
    Number of values in GTS.
  - isSorted
```
public static boolean isSorted(GeoTimeSerie gts)
```
    Tell if a GTS instance is considered sorted. If this method returns true, the GTS instance is sorted but if it returns false the GTS instance may or may not be sorted.
    
    Parameters:
    
    gts - GeoTimeSerie instance to consider.
    
    Returns:
    
    true if the GTS instance is considered sorted, false otherwise.
  - isReversed
```
public static boolean isReversed(GeoTimeSerie gts)
```
    Tell if a GTS instance is considered reversed. This has only a meaning if the GTS instance is considered sorted. If this method returns true, the GTS instance is reversed but if it returns false the GTS instance may or may not be reversed.
    
    Parameters:
    
    gts - GeoTimeSerie instance to consider.
    
    Returns:
    
    true if the GTS instance is considered reversed, false otherwise.
  - max
```
public static java.lang.Object max(GeoTimeSerie gts)
                            throws WarpScriptException
```
    Handy method to compute the max value of a GTS instance. It uses 'map_max' under the hood.
    
    Parameters:
    
    gts - GTS to compute the max of
    
    Returns:
    
    The computed max value
    
    Throws:
    
    WarpScriptException
  - min
```
public static java.lang.Object min(GeoTimeSerie gts)
                            throws WarpScriptException
```
    Handy method to compute the min value of a GTS instance. It uses 'map_min' under the hood.
    
    Parameters:
    
    gts - GTS to compute the max of
    
    Returns:
    
    The computed min value
    
    Throws:
    
    WarpScriptException
  - lowest
```
public static java.lang.Object lowest(GeoTimeSerie gts)
                               throws WarpScriptException
```
    Handy method to compute the minimum elevation of a GTS instance. It uses 'map_lowest' under the hood.
    
    Parameters:
    
    gts - GTS to compute the minimum elevation on
    
    Returns:
    
    The computed lowest elevation
    
    Throws:
    
    WarpScriptException
  - highest
```
public static java.lang.Object highest(GeoTimeSerie gts)
                                throws WarpScriptException
```
    Handy method to compute the maximum elevation of a GTS instance. It uses 'map_highest' under the hood.
    
    Parameters:
    
    gts - GTS to compute the maximum elevation on
    
    Returns:
    
    The computed highest elevation
    
    Throws:
    
    WarpScriptException
  - longValues
```
public static long[] longValues(GeoTimeSerie gts)
                         throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - doubleValues
```
public static double[] doubleValues(GeoTimeSerie gts)
                             throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - booleanValues
```
public static java.util.BitSet booleanValues(GeoTimeSerie gts)
                                      throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - stringValues
```
public static java.lang.String[] stringValues(GeoTimeSerie gts)
                                       throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - dedup
```
public static GeoTimeSerie dedup(GeoTimeSerie gts)
```
    Remove duplicate ticks from the GeoTimeSerie instance. Only the last value found for a given timestamp will be kept.
    
    Parameters:
    
    gts - GeoTimeSerie instance from which to remove duplicates.
    
    Returns:
    
    A clone of the given GeoTimeSerie without duplicate ticks.
  - onlybuckets
```
public static GeoTimeSerie onlybuckets(GeoTimeSerie gts)
```
    Removes non-bucket points of a bucketized GTS
    
    Parameters:
    
    gts - GeoTimeSerie instance to clean.
    
    Returns:
    
    A clone of the given GeoTimeSerie without non-bucket points or a clone if not bucketized.
  - partitionAndApply
```
@SafeVarargs
public static java.util.List<GeoTimeSerie> partitionAndApply(java.lang.Object function,
                                                                          WarpScriptStack stack,
                                                                          WarpScriptStack.Macro validator,
                                                                          java.util.Collection<java.lang.String> bylabels,
                                                                          java.util.List<GeoTimeSerie>... series)
                                                                   throws WarpScriptException
```
    Apply a function (either a filter or n-ary op) onto collections of GTS instances. Let's assume there are N collections in 'series'. The GTS instances from collections among those N that have more than 1 element will be partitioned. For each partition P, the function F will be called with arguments F(labels, S(Ci,Pi), S(C1,P2), ... S(Ci,Pi), ...., S(CN,PN)) where S(Ci,Pi) is either the collection Ci if card(Ci) == 1 or only those series from Pi which belong to Ci. 'labels' is the set of common labels in the partition.
    
    Parameters:
    
    function - The function to apply, either an WarpScriptFilterFunction or WarpScriptNAryFunction
    
    bylabels - Labels to use for partitioning the GTS instances
    
    series - Set of GTS instances collections
    
    Returns:
    
    A list of GeoTimeSeries, result of the application of the function
    
    Throws:
    
    WarpScriptException - if the function is invalid.
  - partitionAndApplyUnflattened
```
@SafeVarargs
public static java.util.Map<java.util.Map<java.lang.String,java.lang.String>,java.util.List<GeoTimeSerie>> partitionAndApplyUnflattened(java.lang.Object function,
                                                                                                                                                     WarpScriptStack stack,
                                                                                                                                                     WarpScriptStack.Macro validator,
                                                                                                                                                     java.util.Collection<java.lang.String> bylabels,
                                                                                                                                                     java.util.List<GeoTimeSerie>... series)
                                                                                                                                              throws WarpScriptException
```
    Apply a function or filter GTS and keep the results ventilated per equivalence class This function has the side effect of unsetting classId/labelsId
    
    Parameters:
    
    function - The function to apply, either an WarpScriptFilterFunction or WarpScriptNAryFunction
    
    bylabels - Labels to use for partitioning the GTS instances
    
    series - Set of GTS instances collections
    
    Returns:
    
    A list of GeoTimeSeries, result of the application of the function
    
    Throws:
    
    WarpScriptException - if the function is invalid.
  - applyNAryFunction
```
@SafeVarargs
public static GeoTimeSerie applyNAryFunction(WarpScriptNAryFunction function,
                                                          java.util.Map<java.lang.String,java.lang.String> commonlabels,
                                                          java.util.List<GeoTimeSerie>... subseries)
                                                   throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - apply
```
@Deprecated
public static java.util.List<GeoTimeSerie> apply(WarpScriptBinaryOp op,
                                                             java.util.Collection<GeoTimeSerie> op1,
                                                             java.util.Collection<GeoTimeSerie> op2,
                                                             java.util.Collection<java.lang.String> bylabels)
                                                      throws WarpScriptException
```
    Deprecated.
    
    Apply a binary op to pairs drawn from two collections of GTS instances. If op1 has one element, op will be applied to (op1,y) where y belongs to op2. Result name and labels will be those of y. If op2 has one element, op will be applied to (x,op2) where x belongs to op1. Result name and labels will be those of x. If cardinalities of both op1 and op2 are > 1, the set {op1 + op2} will be partitioned using 'bylabels' (@see #partition). If each partition contains 2 GTS instances, op will be applied on each partition. The result will have name and labels of the partition element which belongs to op1.
    
    Parameters:
    
    op - Binary op to apply.
    
    op1 - Collection of GTS instances for operand1 of op
    
    op2 - Collection of GTS instances for operand2 of op
    
    bylabels - Label names to use for partitioning op1+op2
    
    Returns:
    
    A list of resulting GTS instances.
    
    Throws:
    
    WarpScriptException - If partitioning could not be done
  - reduce
```
public static java.util.List<GeoTimeSerie> reduce(WarpScriptReducerFunction reducer,
                                                  java.util.Collection<GeoTimeSerie> series,
                                                  java.util.Collection<java.lang.String> bylabels)
                                           throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - reduce
```
public static java.util.List<GeoTimeSerie> reduce(WarpScriptReducerFunction reducer,
                                                  java.util.Collection<GeoTimeSerie> series,
                                                  java.util.Collection<java.lang.String> bylabels,
                                                  boolean overrideTick)
                                           throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - reduceUnflattened
```
public static java.util.Map<java.util.Map<java.lang.String,java.lang.String>,java.util.List<GeoTimeSerie>> reduceUnflattened(WarpScriptReducerFunction reducer,
                                                                                                                             java.util.Collection<GeoTimeSerie> series,
                                                                                                                             java.util.Collection<java.lang.String> bylabels)
                                                                                                                      throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - reduceUnflattened
```
public static java.util.Map<java.util.Map<java.lang.String,java.lang.String>,java.util.List<GeoTimeSerie>> reduceUnflattened(WarpScriptReducerFunction reducer,
                                                                                                                             java.util.Collection<GeoTimeSerie> series,
                                                                                                                             java.util.Collection<java.lang.String> bylabels,
                                                                                                                             boolean overrideTick)
                                                                                                                      throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - getLastValue
```
public static java.lang.Object getLastValue(GeoTimeSerie gts)
```
    Return the value of the most recent tick in this GTS.
    
    Parameters:
    
    gts - GTS instance to extract value from.
    
    Returns:
    
    The value of the most recent tick in the given GeoTimeSerie instance.
  - sortIndices
```
public static int[] sortIndices(long[] values,
                                boolean reversed)
```
    Return an array of indices sorted in the order of the matching value in the 'values' array.
    
    Parameters:
    
    values - Values whose order must be checked
    
    reversed - If true, sort indices so 'values' is in descending order
    
    Returns:
    
    An array of indices sorted in the order of the matching value in the 'values' array.
  - getValueType
```
public static GeoTimeSerie.TYPE getValueType(java.lang.Object value)
```
  - shrink
```
public static void shrink(GeoTimeSerie gts)
```
    Shrink the internal arrays of this GTS so their length matches the number of values.
    
    Parameters:
    
    gts - GTS instance to shrink
  - shrink
```
public static void shrink(GeoTimeSerie gts,
                          double ratio)
```
  - compact
```
public static GeoTimeSerie compact(GeoTimeSerie gts,
                                   boolean preserveRanges)
```
    Compact a GeoTimeSerie instance by removing measurements which have the same value/location/elevation as the previous one. We retain the last value so the resulting GTS instance spans the same time interval as the original one. Otherwise for example in the case of a constant GTS, there would be only a single value which would means we would not know when the last value was.
    
    Parameters:
    
    gts - GTS instance to compress
    
    preserveRanges - Flag indicating if we should preserve range extrema or not
    
    Returns:
    
    a new GTS instance which is a compressed version of the input one
  - normalize
```
public static GeoTimeSerie normalize(GeoTimeSerie gts)
```
    Normalize a GTS, replacing X by (X-MIN)/(MAX-MIN) or 1.0
    
    Parameters:
    
    gts - GeoTimeSerie instance to be normalized.
    
    Returns:
    
    A clone of the given GTS, normalized only if it contains numeric values.
  - isonormalize
```
public static GeoTimeSerie isonormalize(GeoTimeSerie gts)
```
    Normalize a GTS, replacing X by (X-MEAN)/(MAX-MIN) or 1.0
    
    Parameters:
    
    gts - GeoTimeSerie instance to be isonormalized.
    
    Returns:
    
    A clone of the given GTS, isonormalized only if it contains numeric values.
  - standardize
```
public static GeoTimeSerie standardize(GeoTimeSerie gts)
```
    Standardize a numeric GeoTimeSerie
    
    Parameters:
    
    gts - GeoTimeSerie instance to be standardized.
    
    Returns:
    
    A clone of the given GTS, standardized only if it contains numeric values.
  - standardize
```
public static GeoTimeSerie standardize(GeoTimeSerie gts,
                                       double mean,
                                       double sd)
```
  - bSAX
```
public static GeoTimeSerie bSAX(GeoTimeSerie gts,
                                int alphabetSize,
                                int wordLen,
                                int windowLen,
                                boolean standardizePAA)
                         throws WarpScriptException
```
    Produces a String GTS whose values are the encoded bSAX words of the sequence starting at each tick. It only works on numeric bucketized GTS instances.
    
    Parameters:
    
    gts - GeoTimeSerie instance on which to apply the bSAX algorithm, must be bucketized, filled and numeric.
    
    alphabetSize - Size of the alphabet used by bSAX, must be a power of two.
    
    wordLen - Size of the words to be generated by the bSAX algorithm.
    
    windowLen - Window size which is the width of each interval on which the pattern extraction should be performed.
    
    standardizePAA - Whether to standardize or not the piecewise aggregate approximation.
    
    Returns:
    
    A new GeoTimeSerie instance containing the bSAX result.
    
    Throws:
    
    WarpScriptException - if the GTS is not numeric, bucketized and filled or if parameters are incorrect.
  - singleExponentialSmoothing
```
public static GeoTimeSerie singleExponentialSmoothing(GeoTimeSerie gts,
                                                      double alpha)
                                               throws WarpScriptException
```
    Perform exponential smoothing on a numeric GTS.
    
    Parameters:
    
    gts - GeoTimeSerie instance on which to apply the exponential smoothing.
    
    alpha - Smoothing Factor (0 < alpha < 1)
    
    Returns:
    
    A clone of the given instance with single exponential smoothing applied.
    
    Throws:
    
    WarpScriptException - if the GTS is not numeric, has less than 2 values or alpha is not in ]0;1[.
  - doubleExponentialSmoothing
```
public static java.util.List<GeoTimeSerie> doubleExponentialSmoothing(GeoTimeSerie gts,
                                                                      double alpha,
                                                                      double beta)
                                                               throws WarpScriptException
```
    Perform a double exponential smoothing on the input GTS.
    
    Parameters:
    
    gts - GeoTimeSerie instance on which to apply the exponential smoothing.
    
    alpha - Smoothing Factor (0 < alpha < 1)
    
    beta - Trend smoothing Factor (0 < beta < 1)
    
    Returns:
    
    A clone of the given instance with double exponential smoothing applied.
    
    Throws:
    
    WarpScriptException - if the GTS is not numeric, has less than 2 values or alpha or beta is not in ]0;1[.
  - valueHistogram
```
public static java.util.Map<java.lang.Object,java.lang.Long> valueHistogram(GeoTimeSerie gts)
```
    Build an occurrence count by value for the given time serie.
  - valueHistogram
```
public static java.util.Map<java.lang.Object,java.lang.Long> valueHistogram(GTSEncoder encoder)
```
    Build an occurrence count by value for the given GTS Encoder.
  - detect
```
public static GeoTimeSerie detect(GeoTimeSerie gts,
                                  int alphabetSize,
                                  int wordLen,
                                  int windowLen,
                                  java.util.Collection<java.lang.String> patterns,
                                  boolean standardizePAA)
                           throws WarpScriptException
```
    Detect patterns in a Geo Time Serie instance. Return a modified version of the original GTS instance where only the values which are part of one of the provided patterns are kept.
    
    Parameters:
    
    gts - GeoTimeSerie in which to detect patterns.
    
    alphabetSize - Size of the alphabet used by bSAX, must be a power of two.
    
    wordLen - Size of the words to be generated by the bSAX algorithm.
    
    windowLen - Window size which is the width of each interval on which the pattern extraction should be performed.
    
    standardizePAA - Whether to standardize or not the piecewise aggregate approximation.
    
    Returns:
    
    A new GeoTimeSerie instance where only the values which are part of one of the provided patterns are kept.
    
    Throws:
    
    WarpScriptException - if the GTS is not numeric, bucketized and filled or if bSAX parameters are incorrect.
  - getBucketCount
```
public static int getBucketCount(GeoTimeSerie gts)
```
  - getBucketSpan
```
public static long getBucketSpan(GeoTimeSerie gts)
```
  - getLastBucket
```
public static long getLastBucket(GeoTimeSerie gts)
```
  - setBucketCount
```
public static void setBucketCount(GeoTimeSerie gts,
                                  int bucketcount)
```
  - setBucketSpan
```
public static void setBucketSpan(GeoTimeSerie gts,
                                 long bucketspan)
```
  - setLastBucket
```
public static void setLastBucket(GeoTimeSerie gts,
                                 long lastbucket)
```
  - metadataToString
```
public static void metadataToString(java.lang.StringBuilder sb,
                                    java.lang.String name,
                                    java.util.Map<java.lang.String,java.lang.String> labels,
                                    boolean expose)
```
  - labelsToString
```
public static void labelsToString(java.lang.StringBuilder sb,
                                  java.util.Map<java.lang.String,java.lang.String> labels,
                                  boolean expose)
```
  - buildSelector
```
public static java.lang.String buildSelector(GeoTimeSerie gts,
                                             boolean forSearch)
```
  - buildSelector
```
public static java.lang.String buildSelector(Metadata metadata,
                                             boolean forSearch)
```
    Build a string representation of Metadata suitable for selection (via FIND/FETCH).
    
    Parameters:
    
    metadata - Metadata to represent
    
    forSearch - Set to true if the result is for searching, in that case for empty values of labels, '~$' will be produced, otherwise '='
  - timeclip
```
public static GeoTimeSerie timeclip(GeoTimeSerie gts,
                                    long start,
                                    long end)
```
    Return a GTS which is a subset of the input GTS with only those ticks which fall between start and end (both inclusive).
    
    Parameters:
    
    gts - GeoTimeSerie instance to clip.
    
    start - Oldest tick (inclusive) to keep.
    
    end - Youngest tick (inclusive) to keep.
    
    Returns:
    
    A new GeoTimeSerie instance which is a subset of the input GTS with only those ticks which fall between start and end (both inclusive).
  - timeclip
```
public static GTSEncoder timeclip(GTSEncoder encoder,
                                  long start,
                                  long end)
```
    Clip a GTSEncoder
    
    Parameters:
    
    start - lower timestamp to consider (inclusive)
    
    end - upper timestamp to consider (inclusive)
    
    Returns:
    
    A new GTSEncoder instance which is a subset of the input GTSEncoder with only those ticks which fall between start and end (both inclusive).
  - integrate
```
public static GeoTimeSerie integrate(GeoTimeSerie gts,
                                     double initialValue)
```
    'Integrate' a GTS, considering the value at each tick is a rate of change per second.
    
    Parameters:
    
    gts - GeoTimeSerie instance to integrate.
    
    initialValue - Initial value of the resulting GTS.
    
    Returns:
    
    A new GeoTimeSerie instance which is the integration of the given GeoTimeSerie.
  - shrinkTo
```
public static GeoTimeSerie shrinkTo(GeoTimeSerie gts,
                                    int newsize)
```
    Reduce the number of values in a GTS. The underlying arrays are not shrunk. If the new size is far lower than the old size and should stay that way, consider applying GTSHelper.shrink to avoid wasting memory.
    
    Parameters:
    
    gts - Geo Time Series to reduce
    
    newsize - New number of values
    
    Returns:
    
    The given GeoTimeSerie instance with at more newsize values. If newsize>=0, return the GTS unmodified.
  - shrinkTo
```
public static GTSEncoder shrinkTo(GTSEncoder encoder,
                                  int newsize)
                           throws java.io.IOException
```
    Shrink an encoder to at most a given number of values.
    
    Throws:
    
    java.io.IOException
  - chunk
```
public static java.util.List<GeoTimeSerie> chunk(GeoTimeSerie gts,
                                                 long lastchunk,
                                                 long chunkwidth,
                                                 long chunkcount,
                                                 java.lang.String chunklabel,
                                                 boolean keepempty)
                                          throws WarpScriptException
```
    Splits a GTS in 'chunks' of equal time length.
    
    Parameters:
    
    gts -
    
    lastchunk - End timestamp of the most recent chunk. Use 0 to adjust automatically on 'chunkwidth' boundary
    
    chunkwidth - Width of each chunk in time units
    
    chunkcount - Number of chunks to generate. Use 0 to generate as many chunks as needed to cover the GTS
    
    chunklabel - Name of the label to use for storing the chunkid
    
    keepempty - Should we keed empty chunks
    
    Returns:
    
    a List of GeoTimeSerie, each GTS covering one chunk.
    
    Throws:
    
    WarpScriptException - if parameters are invalid.
  - chunk
```
public static java.util.List<GeoTimeSerie> chunk(GeoTimeSerie gts,
                                                 long lastchunk,
                                                 long chunkwidth,
                                                 long chunkcount,
                                                 java.lang.String chunklabel,
                                                 boolean keepempty,
                                                 long overlap)
                                          throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - chunk
```
public static java.util.List<GTSEncoder> chunk(GTSEncoder encoder,
                                               long lastchunk,
                                               long chunkwidth,
                                               long chunkcount,
                                               java.lang.String chunklabel,
                                               boolean keepempty,
                                               long overlap)
                                        throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - fuse
```
public static GeoTimeSerie fuse(java.util.Collection<GeoTimeSerie> chunks)
                         throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - timescale
```
public static GeoTimeSerie timescale(GeoTimeSerie gts,
                                     double scale)
                              throws WarpScriptException
```
    Multiply the ticks of a GTS instance by a factor. Cannot be applied to a bucketized GTS instance as it can cause rounding errors.
    
    Parameters:
    
    gts - The GTS instance whose ticks are to be scaled.
    
    scale - The factor to apply to the ticks.
    
    Returns:
    
    A copy of the given GTS instance with its tick scaled.
    
    Throws:
    
    WarpScriptException - If the GTS instance is bucketized.
  - isNormal
```
public static boolean isNormal(GeoTimeSerie gts,
                               int buckets,
                               double pcterror,
                               boolean bessel)
```
    Determine if a GTS' values are normally distributed. Works for numerical GTS only
    
    Parameters:
    
    gts - GTS to check
    
    buckets - Number of buckets to distribute the values in
    
    pcterror - Maximum acceptable percentage of deviation from the mean of the bucket sizes
    
    bessel - Should we apply Bessel's correction when computing sigma
    
    Returns:
    
    true if the GTS is normally distributed (no bucket over pcterror from the mean bucket size)
  - musigma
```
public static double[] musigma(GeoTimeSerie gts,
                               boolean bessel)
```
  - quantize
```
public static GeoTimeSerie quantize(GeoTimeSerie gts,
                                    double[] bounds,
                                    java.lang.Object[] values)
                             throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - getTicks
```
public static long[] getTicks(GeoTimeSerie gts)
```
    Return an array with a copy of the ticks of the given GTS.
    
    Parameters:
    
    gts - GeoTime Serie instance to get the ticks from.
    
    Returns:
    
    A copy of the array of ticks.
  - getLocations
```
public static long[] getLocations(GeoTimeSerie gts)
```
    Return an array with a copy of the locations of the given GTS. Allocation a new array if no location was specified in the GTS.
    
    Parameters:
    
    gts - GeoTime Serie instance to get the locations from.
    
    Returns:
    
    A copy of the array of locations.
  - getOriginalLocations
```
public static long[] getOriginalLocations(GeoTimeSerie gts)
```
  - getOriginalElevations
```
public static long[] getOriginalElevations(GeoTimeSerie gts)
```
  - getElevations
```
public static long[] getElevations(GeoTimeSerie gts)
```
    Return an array with a copy of the locations of the given GTS. Allocation a new array if no location was specified in the GTS.
    
    Parameters:
    
    gts - GeoTime Serie instance to get the elevations from.
    
    Returns:
    
    A copy of the array of elevations.
  - getValuesAsDouble
```
public static double[] getValuesAsDouble(GeoTimeSerie gts)
                                  throws WarpScriptException
```
    Return an array with a copy of the GTS values as doubles
    
    Parameters:
    
    gts - GeoTime Serie instance to get the doubles from.
    
    Returns:
    
    A copy of the array of doubles values.
    
    Throws:
    
    WarpScriptException - if the GeoTimeSerie instance does not contain doubles.
  - internalizeStrings
```
public static void internalizeStrings(Metadata meta)
```
    Transform a Metadata instance by 'intern'ing all of its strings.
    
    Parameters:
    
    meta - Metadata to be internalized.
  - pointwise_lowess
```
public static double pointwise_lowess(GeoTimeSerie gts,
                                      int idx,
                                      long tick,
                                      int q,
                                      int p,
                                      double[] weights,
                                      double[] rho,
                                      double[] beta,
                                      boolean reversed)
                               throws WarpScriptException
```
    Compute local weighted regression at given tick
    
    Parameters:
    
    gts - : input GTS
    
    idx - : considered as index of the first non-null neighbour at the right
    
    tick - : tick at which lowess is achieved
    
    q - : bandwitdth, i.e. number of nearest neighbours to consider
    
    p - : degree of polynomial fit
    
    weights - : optional array that store the weights
    
    rho - : optional array that store the robustness weights
    
    beta - : optional array that store the regression parameters
    
    reversed - : should idx be considered to be at the left instead
    
    Returns:
    
    the local weighted regression at given tick.
    
    Throws:
    
    WarpScriptException - if array lengths are not coherent.
  - pointwise_lowess
```
public static double pointwise_lowess(GeoTimeSerie gts,
                                      int idx,
                                      long tick,
                                      int q,
                                      int p,
                                      double[] weights,
                                      double[] rho,
                                      double[] beta)
                               throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - rlowess
```
public static GeoTimeSerie rlowess(GeoTimeSerie gts,
                                   int q,
                                   int r,
                                   long d,
                                   int p,
                                   double[] weights,
                                   double[] rho,
                                   boolean inplace)
                            throws WarpScriptException
```
    Compute fast and robust version of LOWESS on a Geo Time Series, with a polynomial fit of degree p > 0.
    
    Parameters:
    
    gts - Input GTS
    
    q - Bandwith, i.e. number of nearest neighbours to consider when applying LOWESS
    
    r - Robustness, i.e. number of robustifying iterations
    
    d - Delta in µs, i.e. acceptable neighbourhood radius within which LOWESS is not recomputed close points are approximated by polynomial interpolation, d should remain < 0.1*(lasttick-firstick) in most cases
    
    p - Degree, i.e. degree of the polynomial fit best usage p=1 or p=2 ; it will likely return an overflow error if p is too big
    
    weights - : optional array that store the weights
    
    rho - : optional array that store the robustness weights
    
    inplace - : should the gts returned be the same object than the input
    
    Returns:
    
    a smoothed GTS
    
    Throws:
    
    WarpScriptException - if parameters are incorrect.
    
    See Also:
    
    Robust Locally Weighted Regression and Smoothing Scatterplots
  - rlowess
```
public static GeoTimeSerie rlowess(GeoTimeSerie gts,
                                   int q,
                                   int r,
                                   long d,
                                   int p)
                            throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - lowess_stl
```
public static void lowess_stl(GeoTimeSerie fromGTS,
                              GeoTimeSerie toGTS,
                              int neighbours,
                              int degree,
                              int jump,
                              double[] weights,
                              double[] rho)
                       throws WarpScriptException
```
    Version of LOWESS used in stl
    
    Parameters:
    
    fromGTS - : GTS from which data used for estimation is taken
    
    toGTS - : GTS where results are saved
    
    neighbours - : number of nearest neighbours to take into account when computing lowess (bandwitdh)
    
    degree - : degree of polynomial fit in lowess
    
    jump - : number of bucket to skip when computing lowess (to speed it up)
    
    weights - : optional array that store the weights
    
    rho - : optional array that store the robustness weights
    
    Throws:
    
    WarpScriptException
  - stl
```
public static java.util.List<GeoTimeSerie> stl(GeoTimeSerie gts,
                                               int buckets_per_period,
                                               int inner,
                                               int outer,
                                               int neighbour_s,
                                               int degree_s,
                                               int jump_s,
                                               int neighbour_l,
                                               int degree_l,
                                               int jump_l,
                                               int neighbour_t,
                                               int degree_t,
                                               int jump_t,
                                               int neighbour_p,
                                               int degree_p,
                                               int jump_p)
                                        throws WarpScriptException
```
    Compute STL i.e. Seasonal-Trend decomposition procedure based on LOWESS Global parameters:
    
    Parameters:
    
    gts - : Input GTS, must be bucketized
    
    buckets_per_period - : number of buckets for one period of the seasonality
    
    inner - Precision : number of inner loops (to make the decomposition)
    
    outer - Robustness : number of outer loops (to alleviate the impact of outliers upon the decomposition) Optional sets of parameters shared by call of lowess of the same kind:
    
    neighbour_s - : (for the seasonal extracting step) Bandwidth, i.e. number of nearest neighbours to consider when applying LOWESS. If negative, approximation by the mean is used instead of LOWESS.
    
    degree_s - : (for the seasonal extracting step) Degree, i.e. degree of the polynomial fit
    
    jump_s - : (for the seasonal extracting step) Jump, i.e. number of bucket to skip to speed up computation. These buckets are interpolated afterward.
    
    neighbour_l - : (for the low frequency filtering step) Bandwidth, i.e. number of nearest neighbours to consider when applying LOWESS
    
    degree_l - : (for the low frequency filtering step) Degree, i.e. degree of the polynomial fit
    
    jump_l - : (for the low frequency filtering step) Jump, i.e. number of bucket to skip to speed up computation. These buckets are interpolated afterward.
    
    neighbour_t - : (for the trend extracting step) Bandwidth, i.e. number of nearest neighbours to consider when applying LOWESS
    
    degree_t - : (for the trend extracting step) Degree, i.e. degree of the polynomial fit
    
    jump_t - : (for the trend extracting step) Jump, i.e. number of bucket to skip to speed up computation. These buckets are interpolated afterward.
    
    neighbour_p - : (for the post seasonal smoothing step) Bandwidth, i.e. number of nearest neighbours to consider when applying LOWESS
    
    degree_p - : (for the post seasonal smoothing step) Degree, i.e. degree of the polynomial fit
    
    jump_p - : (for the post seasonal smoothing step) Jump, i.e. number of bucket to skip to speed up computation. These buckets are interpolated afterward.
    
    Returns:
    
    a list of 2 GTS consisting of the seasonal and trend part of the decomposition.
    
    Throws:
    
    WarpScriptException
    
    See Also:
    
    STL: A Seasonal-Trend Decomposition Procedure Based on Loess
  - copy
```
public static void copy(GeoTimeSerie src,
                        int srcPos,
                        GeoTimeSerie dest,
                        int destPos,
                        int length)
```
    Copy the specified part of a GTS to an other specified part of GTS.
    
    Parameters:
    
    src - The source GTS
    
    srcPos - The starting index in src
    
    dest - The destination GTS
    
    destPos - The starting index in dest
    
    length - The number of points to copy
  - copyGeo
```
public static void copyGeo(GeoTimeSerie from,
                           GeoTimeSerie to)
```
    Copy geo infos (location + elevation) from GTS 'from' into GTS 'to' Only infos for matching ticks with values in 'to' will be copied
    
    Parameters:
    
    from - Source GeoTimeSerie instance from which geo infos will be copied.
    
    to - Destination GeoTimeSerie instance to which geo infos will be copied.
  - getFirstLastTicks
```
public static int[] getFirstLastTicks(long[] ticks)
```
  - geowithin
```
public static boolean geowithin(com.geoxp.GeoXPLib.GeoXPShape shape,
                                GeoTimeSerie gts)
```
  - geointersects
```
public static boolean geointersects(com.geoxp.GeoXPLib.GeoXPShape shape,
                                    GeoTimeSerie gts)
```
  - commonTicks
```
public static java.util.List<GeoTimeSerie> commonTicks(java.util.List<GeoTimeSerie> series)
```
    Return shrinked versions of the input GTS containing only the ticks which have values in all input GTS.
    
    Parameters:
    
    series - List of GeoTimeSerie instance to get values with common ticks from.
    
    Returns:
    
    A new List of cloned GeoTimeSerie containing ony common ticks.
  - bbox
```
public static java.util.List<java.lang.Number> bbox(GeoTimeSerie gts)
```
  - cprob
```
public static GeoTimeSerie cprob(GeoTimeSerie gts,
                                 java.lang.String separator)
                          throws WarpScriptException
```
    Compute conditional probabilities given a GTS considering the values as the concatenation of given events plus the event for which we want to compute the probability, separated by 'separator'. i.e. given1<SEP>given2<SEP>....<SEP>event If 'separator' is null then we simply compute the probability of values instead of conditional probabilities
    
    Parameters:
    
    gts - GeoTimeSerie instance representing the sequence of events.
    
    separator - a String separator between events or null to simply compute the probability of values.
    
    Returns:
    
    a new GeoTimeSerie instance containing the probability P(X=event|A=given1,B=given2,...), the value of each random variable being those of the corresponding tick in the given GTS.
    
    Throws:
    
    WarpScriptException
  - prob
```
public static GeoTimeSerie prob(GeoTimeSerie gts)
```
    Convert a GTS into a GTS of the probability associated with the value present at each tick.
    
    Parameters:
    
    gts - GeoTimeSerie instance for which to get the value probabilities.
    
    Returns:
    
    a new GeoTimeSerie instance containing the probability P(X=event), the value 'event' being that of the corresponding tick in the given GTS.
  - lttb
```
public static GeoTimeSerie lttb(GeoTimeSerie gts,
                                int threshold,
                                boolean timebased)
                         throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - dump
```
public static void dump(GTSEncoder encoder,
                        java.io.PrintWriter pw)
```
  - standardizedMoment
```
public static double standardizedMoment(int moment,
                                        GeoTimeSerie gts,
                                        boolean bessel)
                                 throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - kurtosis
```
public static double kurtosis(GeoTimeSerie gts,
                              boolean bessel)
                       throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - skewness
```
public static double skewness(GeoTimeSerie gts,
                              boolean bessel)
                       throws WarpScriptException
```
    Throws:
    
    WarpScriptException
  - booleanNot
```
public static void booleanNot(GeoTimeSerie gts)
                       throws WarpScriptException
```
    Throws:
    
    WarpScriptException

Class GTSHelper

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

GTSHelper

Method Detail

sort

sort

fullsort

fullsort

fullsort

fullsort

binarySearchTick

binarySearchTick

valueSort

valueSort

tickIterator

booleanGTSSplit

locationSort

compareAllAtTick

tickAtIndex

tickList

indexAtTick

valueAtTick

valueAtIndex

locationAtTick

locationAtIndex

setLocationAtIndex

elevationAtTick

setElevationAtIndex

elevationAtIndex

removeValue

setValue

setValue

setValue

multiProvision

subSerie

subSerie

subCycleSerie

subCycleSerie

bucketize

bucketize

unbucketize

parse_regexp

parseJSON

parse

parse

parse

parse

parse

parse

parseValue

parseValue_regexp

parseLabels

parseLabels

classId

classId

classId

gtsId

classId

labelsId

labelsId

labelsId

labelsId_slow

labelsId

unpackGTSId

unpackGTSId

unpackGTSIdLongs

gtsIdToString

gtsIdToString

stringToGTSId

fillGTSIds

parseLabelsSelectors

patternsFromSelectors

valueRepresentationIterator

tickToString

tickToString

encodeValue