DataSetUtil

java.lang.Object
- org.das2.qds.DataSetUtil

```
public class DataSetUtil
extends java.lang.Object
```
Utilities for QDataSet, such as conversions from various forms to QDataSet, and doing a units conversion. TODO: DataSetUtil, DataSetOps, and org.virbo.dsops.Ops have become blurred over the years. These should either be combined or new mission statements need to be created.

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`PROPERTY_TYPE_BOOLEAN`
`static java.lang.String`	`PROPERTY_TYPE_CACHETAG`
`static java.lang.String`	`PROPERTY_TYPE_MAP`
`static java.lang.String`	`PROPERTY_TYPE_NUMBER`
`static java.lang.String`	`PROPERTY_TYPE_QDATASET`
`static java.lang.String`	`PROPERTY_TYPE_STRING`
`static java.lang.String`	`PROPERTY_TYPE_UNITS`

Constructor Summary

Constructors
Constructor and Description

DataSetUtil()

Constructors
Constructor and Description
`DataSetUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`addContext(java.util.Map<java.lang.String,java.lang.Object> props, QDataSet cds)` adds the rank 0 dataset (a Datum) to the properties, after all the other CONTEXT_<i> properties.
`static void`	`addContext(MutablePropertyDataSet ds, QDataSet cds)` adds the rank 0 dataset (a Datum) to the dataset's properties, after all the other CONTEXT_<i> properties.
`static void`	`addQube(MutablePropertyDataSet ds)` add QUBE property to dataset, maybe verifying that it is a qube.
`static double[][]`	`as2DArrayOfDoubles(QDataSet d)` convert the QDataSet to an array.
`static double[]`	`asArrayOfDoubles(QDataSet d)` convert the QDataSet to an array.
`static DRank0DataSet`	`asDataSet(Datum d)` create a rank 0 dataset from the Datum.
`static QDataSet`	`asDataSet(DatumRange dr)` return a 2-element rank 1 bins dataset with BINS_0=QDataSet.VALUE_BINS_MIN_MAX
`static QDataSet`	`asDataSet(DatumVector dv)` return the rank 1 dataset equivalent to the DatumVector
`static DRank0DataSet`	`asDataSet(double d)` create a dimensionless rank 0 dataset from the double.
`static DRank0DataSet`	`asDataSet(double d, Units u)` create a rank 0 dataset from the double and units.
`static QDataSet`	`asDataSet(java.lang.Object arr)` convert java arrays into QDataSets.
`static QDataSet`	`asDataSet(java.lang.Object x, java.lang.Object y)` convert java arrays into QDataSets.
`static QDataSet`	`asDataSet(java.lang.Object x, java.lang.Object y, java.lang.Object z)` convert java types into QDataSets.
`static Datum`	`asDatum(QDataSet ds)` convert the rank 0 QDataSet to a Datum.
`static Datum`	`asDatum(RankZeroDataSet ds)`
`static DatumRange`	`asDatumRange(QDataSet ds)` return the DatumRange equivalent of this 2-element, rank 1 bins dataset.
`static DatumRange`	`asDatumRange(QDataSet ds, boolean sloppy)` return the DatumRange equivalent of this 2-element, rank 1 bins dataset.
`static DatumVector`	`asDatumVector(QDataSet ds)` return DatumVector, which is a 1-d array of Datums.
`static DatumFormatter`	`bestFormatter(QDataSet datums)` return a DatumFormatter that can accurately format all of the datums in the dataset.
`static int`	`binarySearch(QDataSet ds, double key, int low, int high)` perform a binary search for key within ds, constraining the search to between low and high.
`static java.lang.String[]`	`bundleNames(QDataSet ds)` return the name for each column of the bundle.
`static QDataSet`	`bundleWeightsDataSet(QDataSet ds)` special weightsDataSet for when there is a bundle, and each component could have its own FILL_VALID and VALID_MAX.
`static WritableDataSet`	`canonizeFill(QDataSet ds)` Iterate through the dataset, changing all points outside of validmin, validmax and with zero weight to fill=-1e31.
`static void`	`checkListOfIndeces(QDataSet ds, QDataSet indices)` verify that the indeces really are indeces, and a warning may be printed if the indeces don't appear to match the array by looking at the MAX_VALUE property of the indeces.
`static boolean`	`checkQube(QDataSet ds)` check to see if a dataset really is a qube, even if there is a rank 2 dep1.
`static int`	`closest(QDataSet ds, double d, int guess)` return the index of the closest value in ds to d, using guess as a starting point.
`static int`	`closestIndex(QDataSet ds, Datum datum)` returns the index of the closest index in the data.
`static int`	`closestIndex(QDataSet table, double x, Units units)`
`static java.lang.String`	`contextAsString(QDataSet ds)` provide the context as a string, for example to label a plot.
`static java.lang.String`	`contextAsString(QDataSet ds, java.lang.String delim)` provide the context as a string, for example to label a plot.
`static QDataSet`	`convertTo(QDataSet ds, Units u)` convert the dataset to the given units.
`static void`	`copyDimensionProperties(QDataSet source, MutablePropertyDataSet dest)` Copy over all the dimension properties, including: UNITS, FORMAT, SCALE_TYPE, TYPICAL_MIN, TYPICAL_MAX, VALID_MIN, VALID_MAX, FILL_VALUE, NAME, LABEL, TITLE, USER_PROPERTIES These are dimension properties, as opposed to structural see dimensionProperties() for a list of dimension properties.
`static java.lang.String[]`	`correlativeProperties()` properties that go along with the zeroth index.
`static RankZeroDataSet`	`courserCadence(RankZeroDataSet yTagWidth0, RankZeroDataSet yTagWidth1)` return the courser cadence of the two cadences.
`static java.lang.String[]`	`dimensionProperties()` return the list of properties that pertain to the dimension that dataset values exist.
`static QDataSet`	`firstValidPoint(QDataSet ds)` returns the first valid point found in a dataset, or null if no such point is found.
`static java.lang.String`	`format(QDataSet ds)` return a human-readable string representing the dataset
`static java.lang.String`	`format(QDataSet ds, boolean showContext)` return a human-readable string representing the dataset
`static QDataSet`	`gcd(QDataSet ds, QDataSet limit)` return the greatest common divisor, which is the unit for which all elements in the dataset are integer multiples of the result.
`static QDataSet`	`gcd(QDataSet ds, QDataSet d, QDataSet limit)` return the greatest common divisor, which is the unit for which all elements in the dataset are integer multiples of the result.
`static RankZeroDataSet`	`getCadenceWaveform(QDataSet ds)` return the cadence between measurements of a waveform dataset.
`static QDataSet`	`getContext(QDataSet ds)` collect the context for the dataset.
`static java.util.Map<java.lang.String,java.lang.Object>`	`getDimensionProperties(QDataSet ds, java.util.Map<java.lang.String,java.lang.Object> def)` return just the properties attached to the dataset, like UNITS and SCALE_TYPE, and not like DEPEND_x, etc.
`static int`	`getNextIndex(QDataSet ds, Datum datum)` returns the first column that is after the given datum.
`static java.lang.Integer`	`getNextIndexStrict(QDataSet ds, Datum datum)` Returns the index of the value which is greater than the value less of the datum.
`static DatumRange`	`getNextInterval(QDataSet ds, DatumRange dr0)` return the next interval (typically time) containing data, centered on data, with the roughly the same width.
`static int`	`getPreviousIndex(QDataSet ds, Datum datum)` returns the first index that is before the given datum, or zero if no data is found before the datum.
`static java.lang.Integer`	`getPreviousIndexStrict(QDataSet ds, Datum datum)` Returns the index of the value which is less than the value less of the datum.
`static DatumRange`	`getPreviousInterval(QDataSet ds, DatumRange dr0)` return the previous interval (typically time) containing data, centered on data, with the roughly the same width.
`static java.util.Map<java.lang.String,java.lang.Object>`	`getProperties(QDataSet ds)` gets all the properties of the dataset.
`static java.util.Map<java.lang.String,java.lang.Object>`	`getProperties(QDataSet ds, java.util.Map<java.lang.String,java.lang.Object> def)` gets all the properties of the dataset.
`static java.util.Map<java.lang.String,java.lang.Object>`	`getProperties(QDataSet ds, java.lang.String[] names, java.util.Map<java.lang.String,java.lang.Object> def)` return the properties listed, using the defaults if provided.
`static java.lang.Object`	`getProperty(QDataSet ds, java.lang.String name, java.lang.Object deflt)`
`static java.lang.Class`	`getPropertyClass(java.lang.String name)` return the class for the property, to support Jython.
`static java.lang.String`	`getPropertyType(java.lang.String name)` return the type of the property, as a string to support use in Jython: String,Number,Boolean,Map,QDataSet,CacheTag,Units
`static java.lang.String`	`getStringValue(QDataSet ds)` Return just the value encoded as richly as possible, for human consumption.
`static java.lang.String`	`getStringValue(QDataSet yds, double value)` return the string value of the double, considering QDataSet.FORMAT, the units and the value.
`static java.lang.String`	`getStringValue(QDataSet ds, double value, int i)` return the value, which gets units from index i.
`static java.lang.Object`	`getUserProperty(QDataSet ds, java.lang.String name)` return the "User" property, which allow for extensions of the data model that aren't used.
`static java.lang.String[]`	`globalProperties()` properties that describe the dataset itself, rather than those of a dimension or structural properties.
`static QDataSet`	`guessCadence(QDataSet xds, QDataSet yds)` return the cadence for the given x tags.
`static QDataSet`	`guessCadence(QDataSet xds, QDataSet yds, QDataSet zds)` return the cadence in X for the given X tags and Y tags.
`static RankZeroDataSet`	`guessCadenceNew(QDataSet xds, QDataSet yds)` returns a rank 0 dataset indicating the cadence of the dataset.
`static MutablePropertyDataSet`	`indexGenDataSet(int n)` creates a dataset of integers 0,1,2,...,n-1.
`static QDataSet`	`inferBins(QDataSet yds)` This is the one code to infer bin boundaries when only the centers are available.
`static QDataSet[]`	`inferBinsRank2(QDataSet ydss)` infer the bins for the rank 2 ytags.
`static boolean`	`isConstant(QDataSet ds)` return true if each record of DEPEND_0 is the same.
`static boolean`	`isConstant(QDataSet ds, int dim)` return true if each record of DEPEND_i is the same.
`static boolean`	`isDataAt(QDataSet ds, Datum t)` is data found at the time t, or might it be within a gap in the data?
`static boolean`	`isDimensionProperty(java.lang.String name)` return true if the property name is a valid dimension property like "UNITS" or "FORMAT".
`static boolean`	`isInheritedProperty(java.lang.String prop)` true if the property is one that is global and is relevant throughout the dataset, such as a title or the units.
`static boolean`	`isLogSpacing(QDataSet ds)` return true if the data appears to have log spacing.
`static boolean`	`isMonotonic(QDataSet ds)` returns true if the dataset is monotonically increasing.
`static boolean`	`isMonotonicAndIncreasing(QDataSet ds)` returns true if the dataset is monotonically increasing and does not contain repeat values.
`static boolean`	`isMonotonicAndIncreasingQuick(QDataSet ds)` quickly determine, with high accuracy, if data is monotonic.
`static boolean`	`isMonotonicQuick(QDataSet ds)` quickly determine, with high accuracy, if data is monotonic (repeated values allowed).
`static boolean`	`isNotBundle(QDataSet ds)` return true if the data is not a bundle and has uniform units throughout the dataset.
`static boolean`	`isQube(QDataSet ds)` test to see that the dataset is a qube.
`static QDataSet`	`kmeansCadence(QDataSet xds, int n)` use K-means algorithm to find N means in a rank 1 dataset.
`static void`	`makeValid(MutablePropertyDataSet ds)` throw out DEPEND and PLANE to make dataset valid.
`static void`	`maybeCopyRenderType(QDataSet source, MutablePropertyDataSet dest)` copy over the render type, if it is still appropriate.
`static QDataSet`	`nLargest(QDataSet set, int n)` return the value of the nth biggest item.
`static boolean`	`oneUnit(QDataSet ds)` Test for bundle scheme.
`static int`	`product(int[] qube)` returns 1 for zero-length qube, the product otherwise.
`static java.lang.String[]`	`propertyNames()` Return the names of non-structural properties of the dataset, like the UNITS and CADENCE.
`static void`	`putProperties(java.util.Map<java.lang.String,java.lang.Object> properties, MutablePropertyDataSet ds)` copy all properties into the dataset by iterating through the map.
`static int[]`	`qubeDims(QDataSet ds)` provides a convenient way of indexing qubes, returning an int[] of length ds.rank() containing each dimension's length, or null if the dataset is not a qube.
`static QDataSet`	`qubeSubset(QDataSet ds, int reclen)` return a subset of the dataset which is a qube.
`static int[]`	`rangeOfMonotonic(QDataSet ds)` returns the indeces of the min and max elements of the monotonic dataset.
`static int`	`repeatingSignal(QDataSet yds)` return 0 or the number of values after which the signal repeats.
`static MutablePropertyDataSet`	`replicateDataSet(int n, double value)` creates a dataset with the given cadence, start and length.
`static boolean`	`samePopulation(QDataSet ds1, QDataSet ds2)` true if the two datasets appear to be from the same population.
`static java.util.Map<java.lang.String,java.lang.Object>`	`sliceProperties(QDataSet ds, int index, java.util.Map<java.lang.String,java.lang.Object> result)` return properties attached to the slice at index.
`static java.lang.String`	`statsString(QDataSet ds)` return a human readable statistical representation of the dataset.
`static int`	`sum(int[] qube)` returns 0 for zero-length qube, the sum otherwise.
`static MutablePropertyDataSet`	`tagGenDataSet(int n, double start, double cadence)` creates a dataset with the given cadence, start and length.
`static MutablePropertyDataSet`	`tagGenDataSet(int n, double start, double cadence, Units units)` creates a dataset with the given cadence, start and length.
`static MutablePropertyDataSet`	`toBundleDs(QDataSet labels)` make a proper bundle ds from a simple bundle containing ordinal units This assumes that labels is a unique set of labels.
`static java.lang.String`	`toSparkline(QDataSet ds, QDataSet extent, boolean bar)` Make a unicode spark line http://www.ssec.wisc.edu/~tomw/java/unicode.html.
`static java.lang.String`	`toString(int[] qube)` return string representation of the dimensions of the qube dimensions.
`static java.lang.String`	`toString(QDataSet ds)` provide a string representation of the dataset.
`static int`	`totalLength(QDataSet ds)` return the total number of values in the dataset.
`static long`	`totalLengthAsLong(QDataSet ds)` return the total number of values in the dataset, as a long.
`static java.util.Map<java.lang.String,java.lang.Object>`	`trimProperties(QDataSet ds, int start, int stop)` help out implementations of the QDataSet.trim() command.
`static boolean`	`validate(QDataSet ds, java.util.List<java.lang.String> problems)` returns true if the dataset is valid, false otherwise.
`static boolean`	`validate(QDataSet xds, QDataSet yds, java.util.List<java.lang.String> problems)` add method for validating before link is called.
`static boolean`	`validate(QDataSet xds, QDataSet yds, QDataSet zds, java.util.List<java.lang.String> problems)` add method for validating before link is called.
`static QDataSet`	`validPoints(QDataSet ds)` return just the valid points of the dataset.
`static double`	`value(RankZeroDataSet ds, Units tu)` get the value of the rank 0 dataset in the specified units.
`static QDataSet`	`weightsDataSet(QDataSet ds)` Provide consistent valid logic to operators by providing a QDataSet with >0.0 where the data is valid, and 0.0 where the data is invalid.
`static int`	`xTagBinarySearch(QDataSet ds, Datum datum, int low, int high)` returns the index of a tag, or the `(-(insertion point) - 1)`.

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

- Field Detail
  - PROPERTY_TYPE_STRING
```
public static final java.lang.String PROPERTY_TYPE_STRING
```
    See Also:
    
    Constant Field Values
  - PROPERTY_TYPE_NUMBER
```
public static final java.lang.String PROPERTY_TYPE_NUMBER
```
    See Also:
    
    Constant Field Values
  - PROPERTY_TYPE_BOOLEAN
```
public static final java.lang.String PROPERTY_TYPE_BOOLEAN
```
    See Also:
    
    Constant Field Values
  - PROPERTY_TYPE_MAP
```
public static final java.lang.String PROPERTY_TYPE_MAP
```
    See Also:
    
    Constant Field Values
  - PROPERTY_TYPE_QDATASET
```
public static final java.lang.String PROPERTY_TYPE_QDATASET
```
    See Also:
    
    Constant Field Values
  - PROPERTY_TYPE_CACHETAG
```
public static final java.lang.String PROPERTY_TYPE_CACHETAG
```
    See Also:
    
    Constant Field Values
  - PROPERTY_TYPE_UNITS
```
public static final java.lang.String PROPERTY_TYPE_UNITS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - DataSetUtil
```
public DataSetUtil()
```
- Method Detail
  - indexGenDataSet
```
public static MutablePropertyDataSet indexGenDataSet(int n)
```
    creates a dataset of integers 0,1,2,...,n-1.
    
    Parameters:
    
    n - the bound
    
    Returns:
    
    the dataset
  - tagGenDataSet
```
public static MutablePropertyDataSet tagGenDataSet(int n,
                                                   double start,
                                                   double cadence)
```
    creates a dataset with the given cadence, start and length. This is danger code, because the CADENCE must be reset if the UNITS are reset. use tagGenDataSet( int n, final double start, final double cadence, Units units ) if units are going to be specified.
    
    Parameters:
    
    n - the number of elements
    
    start - the value for the first element.
    
    cadence - the step size between elements
    
    Returns:
    
    the dataset
  - tagGenDataSet
```
public static MutablePropertyDataSet tagGenDataSet(int n,
                                                   double start,
                                                   double cadence,
                                                   Units units)
```
    creates a dataset with the given cadence, start and length. QDataSet.CADENCE will be set based on the units specified. Do not change the units of the result without updating cadence as well.
    
    Parameters:
    
    n - the number of elements
    
    start - the value for the first element.
    
    cadence - the step size between elements
    
    units - the units of the dataset, for example Units.cm
    
    Returns:
    
    the dataset
  - replicateDataSet
```
public static MutablePropertyDataSet replicateDataSet(int n,
                                                      double value)
```
    creates a dataset with the given cadence, start and length.
    
    Parameters:
    
    n - the number of elements
    
    value - the value for each element
    
    Returns:
    
    the dataset
  - isMonotonic
```
public static boolean isMonotonic(QDataSet ds)
```
    returns true if the dataset is monotonically increasing. If the dataset has the MONOTONIC property set to Boolean.TRUE, believe it. The data can contain repeated values. An empty dataset is not monotonic. We now use a weights dataset to more thoroughly check for fill. The dataset may contain fill data, only the non-fill portions are considered.
    
    Parameters:
    
    ds - the rank 1 dataset with physical units.
    
    Returns:
    
    true when the dataset is monotonically increasing.
    
    See Also:
    
    QDataSet.MONOTONIC, ArrayDataSet.monotonicSubset(org.das2.qds.ArrayDataSet), isMonotonicAndIncreasing(org.das2.qds.QDataSet), Ops.ensureMonotonic(org.das2.qds.QDataSet)
  - isMonotonicAndIncreasing
```
public static boolean isMonotonicAndIncreasing(QDataSet ds)
```
    returns true if the dataset is monotonically increasing and does not contain repeat values. An empty dataset is not monotonic. The dataset may contain fill data, only the non-fill portions are considered.
    
    Parameters:
    
    ds - the rank 1 dataset with physical units.
    
    Returns:
    
    true when the dataset is monotonically increasing.
    
    See Also:
    
    QDataSet.MONOTONIC, ArrayDataSet.monotonicSubset(org.das2.qds.ArrayDataSet), isMonotonic(org.das2.qds.QDataSet)
  - isMonotonicQuick
```
public static boolean isMonotonicQuick(QDataSet ds)
```
    quickly determine, with high accuracy, if data is monotonic (repeated values allowed). This should be a constant-time operation, and be extremely unlikely to fail.
    
    Parameters:
    
    ds -
    
    Returns:
    
    true if the data does pass quick tests for monotonic.
    
    See Also:
    
    isMonotonicAndIncreasing(org.das2.qds.QDataSet), QDataSet.MONOTONIC
  - isMonotonicAndIncreasingQuick
```
public static boolean isMonotonicAndIncreasingQuick(QDataSet ds)
```
    quickly determine, with high accuracy, if data is monotonic. This should be a constant-time operation, and be extremely unlikely to fail.
    
    Parameters:
    
    ds -
    
    Returns:
    
    true if the data does pass quick tests for monotonic increasing.
    
    See Also:
    
    isMonotonicAndIncreasing(org.das2.qds.QDataSet), QDataSet.MONOTONIC, Ops.ensureMonotonicAndIncreasingWithFill(org.das2.qds.QDataSet)
  - binarySearch
```
public static int binarySearch(QDataSet ds,
                               double key,
                               int low,
                               int high)
```
    perform a binary search for key within ds, constraining the search to between low and high.
    
    Parameters:
    
    ds - a rank 1 monotonic dataset.
    
    key - the value to find.
    
    low -
    
    high -
    
    Returns:
    
    a positive index of the found value or -index-1 the insertion point.
  - closest
```
public static int closest(QDataSet ds,
                          double d,
                          int guess)
```
    return the index of the closest value in ds to d, using guess as a starting point. This implementation ignores guess, but wise clients will supply it as a parameter.
    
    Parameters:
    
    ds - a rank 1, monotonic dataset.
    
    d - the value to find.
    
    guess - a guess at a close index, or -1 if no guess should be made. In this case, a binary search is performed.
    
    Returns:
    
    index of the closest.
  - getUserProperty
```
public static java.lang.Object getUserProperty(QDataSet ds,
                                               java.lang.String name)
```
    return the "User" property, which allow for extensions of the data model that aren't used. This returns the property "name" under the name USER_PROPERTIES, which must either be null or a Map<String,Object>.
    
    Parameters:
    
    ds - The dataset containing the property.
    
    name - The name of the user property.
    
    Returns:
  - propertyNames
```
public static java.lang.String[] propertyNames()
```
    Return the names of non-structural properties of the dataset, like the UNITS and CADENCE. These are the dimensionProperties, plus others specific to the dataset, such as CADENCE and DELTA_PLUS.
    
    Returns:
    
    the names of non-structural properties of the dataset, like the UNITS and CADENCE.
  - copyDimensionProperties
```
public static void copyDimensionProperties(QDataSet source,
                                           MutablePropertyDataSet dest)
```
    Copy over all the dimension properties, including: UNITS, FORMAT, SCALE_TYPE, TYPICAL_MIN, TYPICAL_MAX, VALID_MIN, VALID_MAX, FILL_VALUE, NAME, LABEL, TITLE, USER_PROPERTIES These are dimension properties, as opposed to structural see dimensionProperties() for a list of dimension properties. TODO: This DOES NOT support join datasets yet.
    
    Parameters:
    
    source -
    
    dest -
  - maybeCopyRenderType
```
public static void maybeCopyRenderType(QDataSet source,
                                       MutablePropertyDataSet dest)
```
    copy over the render type, if it is still appropriate. This nasty bit of code was introduced to support LANL data, where high-rank data is preferably plotted as a spectrogram, but can be plotted as a stack of lineplots.
    
    Parameters:
    
    source -
    
    dest -
  - dimensionProperties
```
public static java.lang.String[] dimensionProperties()
```
    return the list of properties that pertain to the dimension that dataset values exist. These are the properties that survive through most operations. For example, if you flattened the dataset, what properties would still exist? If you shuffled the data? These are not structural properties like DEPEND_0, BUNDLE_1, etc. Note that BUNDLE_1 will carry dimension properties as well.
    
    Returns:
  - getPropertyClass
```
public static java.lang.Class getPropertyClass(java.lang.String name)
```
    return the class for the property, to support Jython.
    
    Parameters:
    
    name - the property name, e.g. QDataSet.TITLE
    
    Returns:
    
    String.class
    
    See Also:
    
    //TODO: super inefficient, this needs to be rewritten as switch
  - getPropertyType
```
public static java.lang.String getPropertyType(java.lang.String name)
```
    return the type of the property, as a string to support use in Jython: String,Number,Boolean,Map,QDataSet,CacheTag,Units
    
    Parameters:
    
    name - the property name
    
    Returns:
    
    the property type or null if the name is not recognized
    
    See Also:
    
    getPropertyClass(java.lang.String), QDataSet
  - isDimensionProperty
```
public static boolean isDimensionProperty(java.lang.String name)
```
    return true if the property name is a valid dimension property like "UNITS" or "FORMAT". See dimensionProperties().
    
    Parameters:
    
    name - property name to test
    
    Returns:
    
    true if the property is a dimension property.
  - globalProperties
```
public static java.lang.String[] globalProperties()
```
    properties that describe the dataset itself, rather than those of a dimension or structural properties.
    
    Returns:
    
    the properties that describe the dataset itself
  - correlativeProperties
```
public static java.lang.String[] correlativeProperties()
```
    properties that go along with the zeroth index. These are all QDataSets with dimensions compatible with the datasets. If you trim the dataset, then these must be trimmed as well.
    
    Returns:
    
    the properties that go along with the zeroth index
  - isInheritedProperty
```
public static boolean isInheritedProperty(java.lang.String prop)
```
    true if the property is one that is global and is relevant throughout the dataset, such as a title or the units. property( "TITLE",0,0 ) often returns property("TITLE"), but property( "DEPEND_0",0,0 ) should never return property("DEPEND_0"). This is false, for example, for DEPEND_1.
    
    Parameters:
    
    prop - the property name.
    
    Returns:
    
    true if the property is inherited
  - sliceProperties
```
public static java.util.Map<java.lang.String,java.lang.Object> sliceProperties(QDataSet ds,
                                                                               int index,
                                                                               java.util.Map<java.lang.String,java.lang.Object> result)
```
    return properties attached to the slice at index. Note the slice implementations use this, and this only returns properties from dimensionProperties(). http://autoplot.org//QDataSet#20150514 Note this does not look at BUNDLE_1 properties. TODO: consider this.
    
    Parameters:
    
    ds - the dataset to slice.
    
    index - index to slice at.
    
    result - a map to insert the new properties, or null if a new one should be created.
    
    Returns:
    
    a map of properties attached to the slice at index
  - trimProperties
```
public static java.util.Map<java.lang.String,java.lang.Object> trimProperties(QDataSet ds,
                                                                              int start,
                                                                              int stop)
```
    help out implementations of the QDataSet.trim() command. This does the dimension properties and geometric properties like DEPEND_0 and DELTA_PLUS. This also checks for indexed properties, which are NAME__i.
    
    Parameters:
    
    ds - the dataset with properties to trim.
    
    start - start index of trim operation
    
    stop - exclusive stop index of the trim operation.
    
    Returns:
    
    the properties of ds, trimmed to the indices.
  - getDimensionProperties
```
public static java.util.Map<java.lang.String,java.lang.Object> getDimensionProperties(QDataSet ds,
                                                                                      java.util.Map<java.lang.String,java.lang.Object> def)
```
    return just the properties attached to the dataset, like UNITS and SCALE_TYPE, and not like DEPEND_x, etc.
    
    Parameters:
    
    ds - the dataset
    
    def - default values or null.
    
    Returns:
    
    a map of all the properties.
    
    See Also:
    
    dimensionProperties()
  - getProperties
```
public static java.util.Map<java.lang.String,java.lang.Object> getProperties(QDataSet ds,
                                                                             java.lang.String[] names,
                                                                             java.util.Map<java.lang.String,java.lang.Object> def)
```
    return the properties listed, using the defaults if provided. See dimensionProperties(), globalProperties().
    
    Parameters:
    
    ds - dataset source of the properties.
    
    names - array of names
    
    def - defaults, or null if no defaults are to be used.
    
    Returns:
    
    map of the properties.
  - getProperties
```
public static java.util.Map<java.lang.String,java.lang.Object> getProperties(QDataSet ds,
                                                                             java.util.Map<java.lang.String,java.lang.Object> def)
```
    gets all the properties of the dataset. This is a shallow copy of properties.
    
    Parameters:
    
    ds - the dataset
    
    def - an empty map.
    
    Returns:
    
    the properties.
  - getProperties
```
public static java.util.Map<java.lang.String,java.lang.Object> getProperties(QDataSet ds)
```
    gets all the properties of the dataset. This is a shallow copy of properties.
    
    Parameters:
    
    ds - the dataset
    
    Returns:
    
    the properties
    
    See Also:
    
    putProperties(java.util.Map, org.das2.qds.MutablePropertyDataSet)
  - putProperties
```
public static void putProperties(java.util.Map<java.lang.String,java.lang.Object> properties,
                                 MutablePropertyDataSet ds)
```
    copy all properties into the dataset by iterating through the map. Properties that are equal to null are not copied, since null is equivalent to the property not found.
    
    Parameters:
    
    properties - the properties
    
    ds - the mutable property dataset, which is still mutable.
    
    See Also:
    
    getProperties(org.das2.qds.QDataSet)
  - isNotBundle
```
public static boolean isNotBundle(QDataSet ds)
```
    return true if the data is not a bundle and has uniform units throughout the dataset.
    
    Parameters:
    
    ds - any dataset.
    
    Returns:
    
    true if the data is not a bundle and has uniform units throughout
  - toString
```
public static java.lang.String toString(QDataSet ds)
```
    provide a string representation of the dataset. This is intended for human consumption, but does follow rules outlined in http://autoplot.org//developer.datasetToString
    
    Parameters:
    
    ds - any dataset.
    
    Returns:
    
    a short, human-readable representation of the dataset.
    
    See Also:
    
    format(org.das2.qds.QDataSet, boolean)
  - firstValidPoint
```
public static QDataSet firstValidPoint(QDataSet ds)
```
    returns the first valid point found in a dataset, or null if no such point is found.
    
    Parameters:
    
    ds - non-bundle dataset.
    
    Returns:
    
    rank zero dataset containing the first valid point, or null.
  - validPoints
```
public static QDataSet validPoints(QDataSet ds)
```
    return just the valid points of the dataset.
    
    Parameters:
    
    ds - a dataset rank > 0.
    
    Returns:
    
    the valid points of the dataset in a rank 1 dataset.
  - gcd
```
public static QDataSet gcd(QDataSet ds,
                           QDataSet d,
                           QDataSet limit)
```
    return the greatest common divisor, which is the unit for which all elements in the dataset are integer multiples of the result. This works on continuous data, however, so limit is used to determine the fuzz allowed. TODO: this needs review and is not for production use.
    
    Parameters:
    
    ds - any dataset
    
    d - rank 0 dataset, first factor for the dataset, error is used to detect non-zero significance.
    
    limit - rank 0 dataset, the resolution for which data is considered equal, and this limit should be greater than numerical precision.
    
    Returns:
    
    the greatest common divisor.
    
    Throws:
    
    java.lang.IllegalArgumentException - if there is no valid data.
  - gcd
```
public static QDataSet gcd(QDataSet ds,
                           QDataSet limit)
```
    return the greatest common divisor, which is the unit for which all elements in the dataset are integer multiples of the result. This works on continuous data, however, so limit is used to determine the fuzz allowed. TODO: this needs review and is not for production use.
    
    Parameters:
    
    ds - any dataset
    
    limit - the resolution for which data is considered equal. The result will be an integer multiple of this.
    
    Returns:
    
    the greatest common divisor.
    
    Throws:
    
    java.lang.IllegalArgumentException - if there is no valid data.
  - courserCadence
```
public static RankZeroDataSet courserCadence(RankZeroDataSet yTagWidth0,
                                             RankZeroDataSet yTagWidth1)
```
    return the courser cadence of the two cadences. Das2's AverageTableRebinner needs to get the coursest of all the ytags.
    
    Parameters:
    
    yTagWidth0 - rank 0 dataset that is one cadence (e.g. 84 sec)
    
    yTagWidth1 - rank 0 dataset that is the second cadence (e.g. 70 sec)
    
    Returns:
    
    the courser of the two cadences. (e.g. 84 sec)
  - toSparkline
```
public static java.lang.String toSparkline(QDataSet ds,
                                           QDataSet extent,
                                           boolean bar)
```
    Make a unicode spark line http://www.ssec.wisc.edu/~tomw/java/unicode.html. This should be for human consumption, because future versions may include data reduction and doubling up characters. See commented code in MetadataPanel.histStr. (I knew I had done this before...)
    
    Parameters:
    
    ds - the rank N (typically 1) dataset
    
    extent - None or the range, see Ops.extent(ds)
    
    bar - true indicates bars should be used instead of scatter
    
    Returns:
    
    string that is a sparkline.
  - samePopulation
```
public static boolean samePopulation(QDataSet ds1,
                                     QDataSet ds2)
```
    true if the two datasets appear to be from the same population.
    
    Parameters:
    
    ds1 - first dataset
    
    ds2 - second dataset
    
    Returns:
    
    true if the two datasets appear to be from the same population
  - isLogSpacing
```
public static boolean isLogSpacing(QDataSet ds)
```
    return true if the data appears to have log spacing. The data is assumed to be monotonically increasing or decreasing.
    
    Parameters:
    
    ds - rank 1 dataset.
    
    Returns:
    
    true if the data is roughly log spaced.
  - inferBinsRank2
```
public static QDataSet[] inferBinsRank2(QDataSet ydss)
```
    infer the bins for the rank 2 ytags. This was first used with Juno high-rate data, where the ytags follow the FCE implied by the magnetic field detector.
    
    Parameters:
    
    ydss - rank 2 dataset[n,m]
    
    Returns:
    
    two-element array of rank 2 datasets[n,m], where 0 is the min and 1 is the max.
  - inferBins
```
public static QDataSet inferBins(QDataSet yds)
```
    This is the one code to infer bin boundaries when only the centers are available. This uses centers of adjacent data, and extrapolates to get the edge boundaries to create an acceptable limit. When the data is log-spaced, the centers are done in the ratiometric space. Small (<1000 element) datasets will be sorted if necessary.
    
    Parameters:
    
    yds - rank 1 dataset.
    
    Returns:
    
    rank 2 bins dataset.
  - getCadenceWaveform
```
public static RankZeroDataSet getCadenceWaveform(QDataSet ds)
```
    return the cadence between measurements of a waveform dataset. This is different than the cadence typically quoted, which is the cadence between waveform records.
    
    Parameters:
    
    ds -
    
    Returns:
    
    the cadence, possibly null.
  - guessCadenceNew
```
public static RankZeroDataSet guessCadenceNew(QDataSet xds,
                                              QDataSet yds)
```
    returns a rank 0 dataset indicating the cadence of the dataset. Using a dataset as the result allows the result to indicate SCALE_TYPE and UNITS. History:
    - 2011-02-21: keep track of repeat values, allowing zero to be considered either mono increasing or mono decreasing
    - 2011-02-21: deal with interleaved fill values, keeping track of last valid value.
    Parameters:
    
    xds - the x tags, which may not contain fill values for non-null result.
    
    yds - the y values, which if non-null is only used for fill values. This is only used if it is rank 1.
    
    Returns:
    null or the cadence in a rank 0 dataset. The following may be properties of the result:
    
    SCALE_TYPE may be "log"
    UNITS will be a ratiometric unit when the SCALE_TYPE is log, and will be the offset unit for interval units like Units.t2000.
  - nLargest
```
public static QDataSet nLargest(QDataSet set,
                                int n)
```
    return the value of the nth biggest item. This keeps n values in memory.
    
    Parameters:
    
    set - rank 1 dataset containing comparable data.
    
    n - the number of items to find
    
    Returns:
    
    the n largest elements, sorted.
  - kmeansCadence
```
public static QDataSet kmeansCadence(QDataSet xds,
                                     int n)
```
    use K-means algorithm to find N means in a rank 1 dataset.
    
    Parameters:
    
    xds - dataset containing data from N normal distributions
    
    n - number of divisions.
    
    Returns:
    
    dataset containing the index for each point.
  - guessCadence
```
public static QDataSet guessCadence(QDataSet xds,
                                    QDataSet yds)
```
    return the cadence for the given x tags. The goal will be a rank 0 dataset that describes the intervals, but this will also return a rank 1 dataset when multiple cadences are found. The yds values for each xds value can also be set, specifying where the x values can be ignored because of fill. TODO: this needs review.
    
    Parameters:
    
    xds - the x tags, which may not contain fill values for non-null result.
    
    yds - the y values, which if non-null is only used for fill values. This is only used if it is rank 1.
    
    Returns:
    
    rank 0 or rank 1 dataset.
  - guessCadence
```
public static QDataSet guessCadence(QDataSet xds,
                                    QDataSet yds,
                                    QDataSet zds)
```
    return the cadence in X for the given X tags and Y tags. The Y tags can repeat, and when this is the case, the X cadence will be span between successive X tags with the same Y tag. The goal will be a rank 0 dataset that describes the intervals, but this will also return a rank 1 dataset when multiple cadences are found.
    
    Parameters:
    
    xds - the x tags, which may not contain fill values for non-null result.
    
    yds - the y values, which may not contain fill values for non-null result.
    
    zds - the z values
    
    Returns:
    
    rank 0 or rank 1 dataset.
  - isConstant
```
public static boolean isConstant(QDataSet ds)
```
    return true if each record of DEPEND_0 is the same. Rank 0 datasets are trivially constant. TODO: ds.slice(i) can be slow because equivalent does so much with the metadata.
    
    Parameters:
    
    ds - any dataset
    
    Returns:
    
    true if the dataset doesn't change with DEPEND_0 or is rank 0.
  - isConstant
```
public static boolean isConstant(QDataSet ds,
                                 int dim)
```
    return true if each record of DEPEND_i is the same. Rank 0 datasets are trivially constant.
    
    Parameters:
    
    ds - any dataset
    
    dim - the index
    
    Returns:
    
    true if the dataset doesn't change with DEPEND_0 or is rank 0.
  - checkQube
```
public static boolean checkQube(QDataSet ds)
```
    check to see if a dataset really is a qube, even if there is a rank 2 dep1. Note this ignores BUNDLE_1 property if there is a DEPEND_1. This was motivated by the fftPower routine, which returned a rank 2 DEPEND_1, but is typically constant, and RBSP/ECT datasets that often have rank 2 DEPEND_1s that are constant. This will putProperty(QDataSet.QUBE,Boolean.TRUE) when the dataset really is a qube, or Boolean.FALSE if is clearly not a qube.
    
    Parameters:
    
    ds - any dataset
    
    Returns:
    
    true if the dataset really is a qube.
  - isQube
```
public static boolean isQube(QDataSet ds)
```
    test to see that the dataset is a qube. TODO: this all needs review.
    
    Parameters:
    
    ds - QDataSet of any rank.
    
    Returns:
    
    true if the dataset is a qube.
  - qubeSubset
```
public static QDataSet qubeSubset(QDataSet ds,
                                  int reclen)
```
    return a subset of the dataset which is a qube.
    
    Parameters:
    
    ds - a rank N dataset like dataset[3,1616*,6144*], where asterisks (stars) indicate it is not a qube.
    
    reclen - the record length for each record.
    
    Returns:
    
    a rank N-1 dataset.
  - qubeDims
```
public static int[] qubeDims(QDataSet ds)
```
    provides a convenient way of indexing qubes, returning an int[] of length ds.rank() containing each dimension's length, or null if the dataset is not a qube.
    
    Parameters:
    
    ds -
    
    Returns:
    
    int[] of length ds.rank() containing each dimension's length, or null if the dataset is not a qube.
  - oneUnit
```
public static boolean oneUnit(QDataSet ds)
```
    Test for bundle scheme. Returns true if the data contains data with just one unit. For example ds[time=100,en=30] might have BUNDLE_1 to specify labels for each of the 30 channels, but each of its measurements have the same units. However, bundle(time,density) results in a dataset with BUNDLE_1 with the two datasets having different units. When two bundled dataset's units are convertible but not equal this will return false. This will return true for a zero-length dataset.
    
    Parameters:
    
    ds - the dataset
    
    Returns:
    
    true if the dataset has just one unit.
  - product
```
public static int product(int[] qube)
```
    returns 1 for zero-length qube, the product otherwise.
    
    Parameters:
    
    qube - int array
    
    Returns:
    
    the product of the elements of the array
  - sum
```
public static int sum(int[] qube)
```
    returns 0 for zero-length qube, the sum otherwise.
    
    Parameters:
    
    qube - int array
    
    Returns:
    
    the sum of the elements of the array
  - toString
```
public static java.lang.String toString(int[] qube)
```
    return string representation of the dimensions of the qube dimensions. For example [2,4] is represented as "[2,4]"
    
    Parameters:
    
    qube - an array of integers, 4 elements or fewer.
    
    Returns:
    
    the formatted string representation
  - addQube
```
public static void addQube(MutablePropertyDataSet ds)
                    throws java.lang.IllegalArgumentException
```
    add QUBE property to dataset, maybe verifying that it is a qube. This is intended to reduce code that builds datasets, not to verify that a dataset is a qube.
    
    Parameters:
    
    ds - the dataset
    
    Throws:
    
    java.lang.IllegalArgumentException - if the dataset is not a qube
  - format
```
public static java.lang.String format(QDataSet ds)
```
    return a human-readable string representing the dataset
    
    Parameters:
    
    ds - the dataset to represent
    
    Returns:
    
    a human-readable string
  - format
```
public static java.lang.String format(QDataSet ds,
                                      boolean showContext)
```
    return a human-readable string representing the dataset
    
    Parameters:
    
    ds - the dataset to represent
    
    showContext - show the context property (@slice2=1) if present and ds is rank0.
    
    Returns:
    
    a human-readable string
    
    See Also:
    
    toString(org.das2.qds.QDataSet)
  - statsString
```
public static java.lang.String statsString(QDataSet ds)
```
    return a human readable statistical representation of the dataset. Currently this is the mean, stddev ad number of points.
    
    Parameters:
    
    ds - the data
    
    Returns:
    
    return a human readable statistical representation
  - validate
```
public static boolean validate(QDataSet ds,
                               java.util.List<java.lang.String> problems)
```
    returns true if the dataset is valid, false otherwise. If problems is non-null, then problems will be indicated here.
    
    Parameters:
    
    ds - rank N dataset.
    
    problems - insert problem descriptions here, if null then ignore
    
    Returns:
    
    true if the dataset is valid, false otherwise
  - validate
```
public static boolean validate(QDataSet xds,
                               QDataSet yds,
                               java.util.List<java.lang.String> problems)
```
    add method for validating before link is called.
    
    Parameters:
    
    xds -
    
    yds -
    
    problems - insert problem descriptions here, if null then ignore
    
    Returns:
    
    true if the datasets can be linked into a valid dataset, false otherwise
  - validate
```
public static boolean validate(QDataSet xds,
                               QDataSet yds,
                               QDataSet zds,
                               java.util.List<java.lang.String> problems)
```
    add method for validating before link is called.
    
    Parameters:
    
    xds - rank 1 tags
    
    yds - rank 1 or rank 2 tags
    
    zds - the dependent data.
    
    problems - insert problem descriptions here, if null then ignore
    
    Returns:
    
    true if the datasets can be linked into a valid dataset, false otherwise
  - totalLengthAsLong
```
public static long totalLengthAsLong(QDataSet ds)
```
    return the total number of values in the dataset, as a long. For qubes this is the product of the dimension lengths, for other datasets we create a dataset of lengths and total all the elements.
    
    Parameters:
    
    ds -
    
    Returns:
    
    the number of values in the dataset.
  - totalLength
```
public static int totalLength(QDataSet ds)
```
    return the total number of values in the dataset. For qubes this is the product of the dimension lengths, for other datasets we create a dataset of lengths and total all the elements.
    
    Parameters:
    
    ds -
    
    Returns:
    
    the number of values in the dataset.
  - makeValid
```
public static void makeValid(MutablePropertyDataSet ds)
```
    throw out DEPEND and PLANE to make dataset valid.
    
    Parameters:
    
    ds -
  - bundleWeightsDataSet
```
public static QDataSet bundleWeightsDataSet(QDataSet ds)
```
    special weightsDataSet for when there is a bundle, and each component could have its own FILL_VALID and VALID_MAX. Each component gets its own weights dataset in a JoinDataSet.
    
    Parameters:
    
    ds - rank 2 bundle dataset
    
    Returns:
    
    dataset with the same geometry but a weightsDataSet of each bundled dataset.
  - weightsDataSet
```
public static QDataSet weightsDataSet(QDataSet ds)
```
    Provide consistent valid logic to operators by providing a QDataSet with >0.0 where the data is valid, and 0.0 where the data is invalid. VALID_MIN, VALID_MAX and FILL_VALUE properties are used. Note, when FILL_VALUE is not specified, -1e31 is used. This is to support legacy logic. For convenience, the property SUGGEST_FILL is set to the fill value used.
    
    Parameters:
    
    ds - the dataset
    
    Returns:
    
    a dataset with the same geometry with zero or positive weights.
  - canonizeFill
```
public static WritableDataSet canonizeFill(QDataSet ds)
```
    Iterate through the dataset, changing all points outside of validmin, validmax and with zero weight to fill=-1e31. VALID_MIN and VALID_MAX properties are cleared, and FILL_VALUE is set to -1e31. If the dataset is writable, then the dataset is modified.
    
    Parameters:
    
    ds - rank N QUBE dataset.
    
    Returns:
    
    ds with same geometry as ds.
  - convertTo
```
public static QDataSet convertTo(QDataSet ds,
                                 Units u)
```
    convert the dataset to the given units.
    
    Parameters:
    
    ds - the dataset
    
    u - new Units
    
    Returns:
    
    equivalent dataset with the new units.
  - value
```
public static double value(RankZeroDataSet ds,
                           Units tu)
```
    get the value of the rank 0 dataset in the specified units. For example, value( ds, Units.km )
    
    Parameters:
    
    ds -
    
    tu - target units
    
    Returns:
    
    the double in target units.
  - asDatum
```
public static Datum asDatum(RankZeroDataSet ds)
```
  - asDatum
```
public static Datum asDatum(QDataSet ds)
```
    convert the rank 0 QDataSet to a Datum.
    
    Parameters:
    
    ds - rank 0 dataset.
    
    Returns:
    
    Datum
  - asDatumRange
```
public static DatumRange asDatumRange(QDataSet ds,
                                      boolean sloppy)
```
    return the DatumRange equivalent of this 2-element, rank 1 bins dataset.
    
    Parameters:
    
    ds - a rank 1, 2-element bins dataset.
    
    sloppy - true indicates we don't check BINS_0 property.
    
    Returns:
    
    an equivalent DatumRange
  - asDatumRange
```
public static DatumRange asDatumRange(QDataSet ds)
```
    return the DatumRange equivalent of this 2-element, rank 1 bins dataset. This uses the sloppy mode, which does not check the BINS_0 property.
    
    Parameters:
    
    ds - a two-element dataset
    
    Returns:
    
    a DatumRange.
  - asDatumVector
```
public static DatumVector asDatumVector(QDataSet ds)
```
    return DatumVector, which is a 1-d array of Datums.
    
    Parameters:
    
    ds - a rank 1 QDataSet
    
    Returns:
    
    a DatumVector
  - asDataSet
```
public static QDataSet asDataSet(DatumVector dv)
```
    return the rank 1 dataset equivalent to the DatumVector
    
    Parameters:
    
    dv -
    
    Returns:
    
    rank 1 QDataSet.
  - asDataSet
```
public static QDataSet asDataSet(DatumRange dr)
```
    return a 2-element rank 1 bins dataset with BINS_0=QDataSet.VALUE_BINS_MIN_MAX
    
    Parameters:
    
    dr - a Das2 DatumRange
    
    Returns:
    
    a 2-element rank 1 bins dataset.
  - asDataSet
```
public static DRank0DataSet asDataSet(double d,
                                      Units u)
```
    create a rank 0 dataset from the double and units.
    
    Parameters:
    
    d - a double, or Double.NaN
    
    u - null or the units of d.
    
    Returns:
    
    rank 0 dataset
  - asDataSet
```
public static DRank0DataSet asDataSet(double d)
```
    create a dimensionless rank 0 dataset from the double.
    
    Parameters:
    
    d - a double, or Double.NaN
    
    Returns:
    
    rank 0 dataset
  - asDataSet
```
public static DRank0DataSet asDataSet(Datum d)
```
    create a rank 0 dataset from the Datum.
    
    Parameters:
    
    d - a datum
    
    Returns:
    
    rank 0 dataset
  - asArrayOfDoubles
```
public static double[] asArrayOfDoubles(QDataSet d)
```
    convert the QDataSet to an array. Units and fill are ignored...
    
    Parameters:
    
    d - the rank 1 dataset.
    
    Returns:
    
    an array of doubles
  - as2DArrayOfDoubles
```
public static double[][] as2DArrayOfDoubles(QDataSet d)
```
    convert the QDataSet to an array. Units and fill are ignored...
    
    Parameters:
    
    d - the rank 2 dataset
    
    Returns:
    
    2-D array of doubles
  - asDataSet
```
public static QDataSet asDataSet(java.lang.Object arr)
```
    convert java arrays into QDataSets.
    
    Parameters:
    
    arr - 1-D or 2-D array of java native type.
    
    Returns:
    
    Rank 1 or Rank 2 dataset.
  - asDataSet
```
public static QDataSet asDataSet(java.lang.Object x,
                                 java.lang.Object y)
```
    convert java arrays into QDataSets.
    
    Parameters:
    
    x - array, number, or String parsed with DatumUtil.parse
    
    y - array, number, or String parsed with DatumUtil.parse
    
    Returns:
    
    dataset
    
    See Also:
    
    DatumUtil.parse(java.lang.String)
  - asDataSet
```
public static QDataSet asDataSet(java.lang.Object x,
                                 java.lang.Object y,
                                 java.lang.Object z)
```
    convert java types into QDataSets.
    
    Parameters:
    
    x - array, number, or String parsed with DatumUtil.parse
    
    y - array, number, or String parsed with DatumUtil.parse
    
    z - array, number, or String parsed with DatumUtil.parse
    
    Returns:
    
    dataset
  - addContext
```
public static void addContext(MutablePropertyDataSet ds,
                              QDataSet cds)
```
    adds the rank 0 dataset (a Datum) to the dataset's properties, after all the other CONTEXT_<i> properties.
    
    Parameters:
    
    ds -
    
    cds -
  - addContext
```
public static void addContext(java.util.Map<java.lang.String,java.lang.Object> props,
                              QDataSet cds)
```
    adds the rank 0 dataset (a Datum) to the properties, after all the other CONTEXT_<i> properties.
    
    Parameters:
    
    props - the properties
    
    cds - the context in a rank 0 dataset
  - contextAsString
```
public static java.lang.String contextAsString(QDataSet ds)
```
    provide the context as a string, for example to label a plot. The dataset CONTEXT_i properties are inspected, each of which must be one of:
    - rank 0 dataset
    - rank 1 bins dataset
    - rank 1 bundle
    Here a comma is used as the delimiter.
    Parameters:
    
    ds - the dataset containing context properties which are rank 0 datums or rank 1 datum ranges.
    
    Returns:
    
    a string describing the context.
  - contextAsString
```
public static java.lang.String contextAsString(QDataSet ds,
                                               java.lang.String delim)
```
    provide the context as a string, for example to label a plot. The dataset CONTEXT_i properties are inspected, each of which must be one of:
    - rank 0 dataset
    - rank 1 bins dataset
    - rank 1 bundle
    Parameters:
    
    ds - the dataset containing context properties which are rank 0 datums or rank 1 datum ranges.
    
    delim - the delimiter between context elements, such as "," or "!c"
    
    Returns:
    
    a string describing the context.
  - getContext
```
public static QDataSet getContext(QDataSet ds)
```
    collect the context for the dataset. This will be a rank 2 join of scalars or ranges, so CONTEXT_0 will be in the zeroth index of the result. Rank 0 CONTEXT values are joined to make them rank 1.
    
    Parameters:
    
    ds - the dataset
    
    Returns:
    
    a rank 2 join of 1- and 2-element datasets.
  - rangeOfMonotonic
```
public static int[] rangeOfMonotonic(QDataSet ds)
```
    returns the indeces of the min and max elements of the monotonic dataset. This uses DataSetUtil.isMonotonic() which would be slow if MONOTONIC is not set.
    
    Parameters:
    
    ds - monotonic, rank 1 dataset.
    
    Returns:
    
    the indeces [min,max] note max is inclusive.
    
    Throws:
    
    java.lang.IllegalArgumentException - when isMonotonic(ds) is false.
    
    See Also:
    
    which returns the range containing any data., which must be true
  - xTagBinarySearch
```
public static int xTagBinarySearch(QDataSet ds,
                                   Datum datum,
                                   int low,
                                   int high)
```
    returns the index of a tag, or the (-(insertion point) - 1). (See Arrays.binarySearch)
    
    Parameters:
    
    ds - monotonically increasing data.
    
    datum - value we are looking for
    
    low - inclusive lower bound of the search
    
    high - inclusive upper bound of the search
    
    Returns:
    
    the index of a tag, or the (-(insertion point) - 1)
  - closestIndex
```
public static int closestIndex(QDataSet ds,
                               Datum datum)
```
    returns the index of the closest index in the data. This supports rank 1 datasets, and rank 2 bins datasets where the bin is min,max.
    
    Parameters:
    
    ds - tags dataset
    
    datum - the location to find
    
    Returns:
    
    the index of the closest point.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the dataset is not rank 1.
    
    java.lang.IllegalArgumentException - if the dataset is length 0.
    
    java.lang.IllegalArgumentException - if the dataset is all fill.
  - closestIndex
```
public static int closestIndex(QDataSet table,
                               double x,
                               Units units)
```
  - getPreviousIndexStrict
```
public static java.lang.Integer getPreviousIndexStrict(QDataSet ds,
                                                       Datum datum)
```
    Returns the index of the value which is less than the value less of the datum. Note for rank 2 bins, the first bin which has an end less than the datum.
    
    Parameters:
    
    ds - rank 1 monotonic tags, or rank 2 bins.
    
    datum - a datum of the same or convertible units.
    
    Returns:
    
    the index, or null (None).
  - getNextIndexStrict
```
public static java.lang.Integer getNextIndexStrict(QDataSet ds,
                                                   Datum datum)
```
    Returns the index of the value which is greater than the value less of the datum. Note for rank 2 bins, the first bin which has an beginning less than the datum.
    
    Parameters:
    
    ds - rank 1 monotonic tags, or rank 2 bins.
    
    datum - a datum of the same or convertible units.
    
    Returns:
    
    the index, or null (None).
  - getPreviousIndex
```
public static int getPreviousIndex(QDataSet ds,
                                   Datum datum)
```
    returns the first index that is before the given datum, or zero if no data is found before the datum. PARV! if the datum identifies (==) an xtag, then the previous column is returned.
    
    Parameters:
    
    ds - the dataset
    
    datum - a datum in the same units of the dataset.
    
    Returns:
    
    the index
  - getNextIndex
```
public static int getNextIndex(QDataSet ds,
                               Datum datum)
```
    returns the first column that is after the given datum. Note the if the datum identifies (==) an xtag, then the previous column is returned.
    
    Parameters:
    
    ds - the dataset
    
    datum - a datum in the same units of the dataset.
    
    Returns:
  - getNextInterval
```
public static DatumRange getNextInterval(QDataSet ds,
                                         DatumRange dr0)
```
    return the next interval (typically time) containing data, centered on data, with the roughly the same width.
    
    Parameters:
    
    ds - the dataset
    
    dr0 - the current interval
    
    Returns:
    
    the next interval
  - isDataAt
```
public static boolean isDataAt(QDataSet ds,
                               Datum t)
```
    is data found at the time t, or might it be within a gap in the data?
    
    Parameters:
    
    ds - any time-series dataset
    
    t - the time
    
    Returns:
    
    true if t is within data.
  - getPreviousInterval
```
public static DatumRange getPreviousInterval(QDataSet ds,
                                             DatumRange dr0)
```
    return the previous interval (typically time) containing data, centered on data, with the roughly the same width.
    
    Parameters:
    
    ds - the dataset
    
    dr0 - the current interval
    
    Returns:
    
    the previous interval
  - getProperty
```
public static java.lang.Object getProperty(QDataSet ds,
                                           java.lang.String name,
                                           java.lang.Object deflt)
```
  - getStringValue
```
public static java.lang.String getStringValue(QDataSet ds,
                                              double value,
                                              int i)
```
    return the value, which gets units from index i. from rank 1 bundle dataset.
    
    Parameters:
    
    ds - the dataset providing units and format information.
    
    value - double value from the dataset
    
    i - the index of the value
    
    Returns:
  - bestFormatter
```
public static DatumFormatter bestFormatter(QDataSet datums)
```
    return a DatumFormatter that can accurately format all of the datums in the dataset. The goal is to identify a formatter which is also efficient, and doesn't waste an excess of digits. This sort of code is often needed, and is also found in:
    - QStream--where ASCII mode needs efficient representation
    TODO: make one code for this. TODO: there also needs to be an optional external context ('2017-03-15') so that 'HH:mm' is a valid response. See sftp://jbf@jfaden.net/home/jbf/ct/autoplot/script/development/bestDataSetFormatter.jy
    Parameters:
    
    datums - a rank 1 dataset, or if rank>1, then return the formatter for a slice.
    
    Returns:
    
    DatumFormatter for the dataset.
  - getStringValue
```
public static java.lang.String getStringValue(QDataSet yds,
                                              double value)
```
    return the string value of the double, considering QDataSet.FORMAT, the units and the value. formatting is done assuming someone else will report the units. If the value is invalid, then "***" is returned.
    
    Parameters:
    
    yds - the dataset, maybe with FORMAT and VALID_MIN, etc.
    
    value - the double from the dataset (presumably).
    
    Returns:
    
    human-readable string representation.
  - getStringValue
```
public static java.lang.String getStringValue(QDataSet ds)
```
    Return just the value encoded as richly as possible, for human consumption. Example results of this include "9.5 km" "Chicago" or "fill" see also format(ds), toString(ds), getStringValue(ds,d)
    
    Parameters:
    
    ds -
    
    Returns:
    
    just the value, without labels.
  - toBundleDs
```
public static MutablePropertyDataSet toBundleDs(QDataSet labels)
```
    make a proper bundle ds from a simple bundle containing ordinal units This assumes that labels is a unique set of labels. See http://autoplot.org/QDataSet#DataSet_Properties under BUNDLE_1. See DataSetOps.unbundle
    
    Parameters:
    
    labels -
    
    Returns:
    
    a BundleDescriptor to be set as BUNDLE_i. See BundleDataSet
    
    Throws:
    
    java.lang.IllegalArgumentException - if the input is not rank 1.
  - bundleNames
```
public static java.lang.String[] bundleNames(QDataSet ds)
```
    return the name for each column of the bundle. This simply calls SemanticOps.getComponentNames.
    
    Parameters:
    
    ds - dataset, presumably with BUNDLE_1 property.
    
    Returns:
    
    array of names.
  - checkListOfIndeces
```
public static void checkListOfIndeces(QDataSet ds,
                                      QDataSet indices)
```
    verify that the indeces really are indeces, and a warning may be printed if the indeces don't appear to match the array by looking at the MAX_VALUE property of the indeces.
    
    Parameters:
    
    ds - the dataset.
    
    indices - the indeces which refer to a subset of dataset.
  - repeatingSignal
```
public static int repeatingSignal(QDataSet yds)
```
    return 0 or the number of values after which the signal repeats. For example, ds= dataset([1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4,1,2]) assert repeatingSignal(ds)==4 if the data contains fill, then it is also not repeating.
    
    Parameters:
    
    yds - the rank 1 dataset.
    
    Returns:
    
    the number of samples before a repeat, or 0 if the signal is not repeating.
    
    See Also:
    
    guessCadenceNew(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

Class DataSetUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PROPERTY_TYPE_STRING

PROPERTY_TYPE_NUMBER

PROPERTY_TYPE_BOOLEAN

PROPERTY_TYPE_MAP

PROPERTY_TYPE_QDATASET

PROPERTY_TYPE_CACHETAG

PROPERTY_TYPE_UNITS

Constructor Detail

DataSetUtil

Method Detail

indexGenDataSet

tagGenDataSet

tagGenDataSet

replicateDataSet

isMonotonic

isMonotonicAndIncreasing

isMonotonicQuick

isMonotonicAndIncreasingQuick

binarySearch

closest

getUserProperty

propertyNames

copyDimensionProperties

maybeCopyRenderType

dimensionProperties

getPropertyClass

getPropertyType

isDimensionProperty

globalProperties

correlativeProperties

isInheritedProperty

sliceProperties

trimProperties

getDimensionProperties

getProperties

getProperties

getProperties

putProperties

isNotBundle

toString

firstValidPoint

validPoints

gcd

gcd

courserCadence

toSparkline

samePopulation

isLogSpacing

inferBinsRank2

inferBins

getCadenceWaveform

guessCadenceNew

nLargest

kmeansCadence

guessCadence

guessCadence

isConstant

isConstant

checkQube

isQube

qubeSubset

qubeDims

oneUnit

product

sum

toString

addQube

format

format

statsString

validate

validate

validate

totalLengthAsLong