Ops

java.lang.Object
- org.das2.qds.ops.Ops

```
public final class Ops
extends java.lang.Object
```
A fairly complete set of operations for QDataSets, including binary operations like "add" and "subtract", but also more abstract (and complex) operations like smooth and fftPower. Most operations check data units and validity, but consult the documentation for each function. These operations are all available in Jython scripts, and some, like add, are connected to operator symbols like +.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Ops.BinaryOp` BinaryOps are operations such as add, pow, atan2
`static class`	`Ops.FFTFilterType` Enumeration identifying windows applied to data before doing FFTs.
`static interface`	`Ops.LongBinaryOp` Like BinaryOp, but operands and result are long.
`static interface`	`Ops.UnaryOp` UnaryOps are one-argument operations, such as sin, abs, and sqrt

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`E` the closest double to e, the base of natural logarithms.
`static double`	`PI` closest double to π or TAU/2
`static double`	`TAU` closest double to τ or 2*PI

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static double`	`abs(double v)` return the abs of the double, to support Jython properly.
`static long`	`abs(long x)` return the abs of the long, to support Jython properly.
`static QDataSet`	`abs(java.lang.Object ds1)` promote the list, double, array etc to QDataSet before taking abs.
`static QDataSet`	`abs(QDataSet ds1)` element-wise abs.
`static QDataSet`	`accum(java.lang.Object ds)`
`static QDataSet`	`accum(java.lang.Object accumDs, java.lang.Object ds)`
`static QDataSet`	`accum(QDataSet ds)` return an array that is the running sum of each element in the array, starting with the value accum.
`static QDataSet`	`accum(QDataSet accumDs, QDataSet ds)` return an array that is the running sum of each element in the array, starting with the value accum.
`static double`	`acos(double ds)` return the acos of the real number in radians.
`static QDataSet`	`acos(java.lang.Object ds)`
`static QDataSet`	`acos(QDataSet ds)` element-wise arccos, the inverse of the cos function.
`static QDataSet`	`add(java.lang.Object ds1, java.lang.Object ds2)` add the two datasets which have the compatible geometry and units.
`static QDataSet`	`add(QDataSet ds1, QDataSet ds2)` add the two datasets which have the compatible geometry and units.
`static QDataSet`	`add(QDataSet ds1, QDataSet ds2, QDataSet ds3)` three-argument add is provided as a convenience for environments (like Java and the Mash-up tool in Autoplot) where add is not an in-fix operator.
`static QDataSet`	`and(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`and(QDataSet ds1, QDataSet ds2)` element-wise logical and function.
`static QDataSet`	`append(QDataSet ds1, QDataSet ds2)` append two datasets that are QUBEs.
`static QDataSet`	`appendEvents(QDataSet ev1, QDataSet ev2)` Deprecated. since append works with events datasets.
`static MutablePropertyDataSet`	`applyBinaryOp(java.lang.Object ds1, java.lang.Object ds2, Ops.BinaryOp op)` As with applyBinaryOp, but promote compatible objects to QDataSet first.
`static MutablePropertyDataSet`	`applyBinaryOp(QDataSet ds1, QDataSet ds2, Ops.BinaryOp op)` apply the binary operator element-for-element of the two datasets, minding dataset geometry, fill values, etc.
`static WritableDataSet`	`applyIndex(java.lang.Object dso, QDataSet r)` apply the indices
`static MutablePropertyDataSet`	`applyIndex(QDataSet ds, int dimension, QDataSet indices)` apply the indices to the given dimension.
`static WritableDataSet`	`applyIndex(QDataSet ds, QDataSet r)` apply the indices to the dataset, resorting the 0th dimension using the indices of r.
`static WritableDataSet`	`applyIndex(QDataSet vv, QDataSet ds, java.lang.Number fillValue)` apply the indices, checking for out-of-bounds values.
`static MutablePropertyDataSet`	`applyUnaryOp(java.lang.Object ds1, Ops.UnaryOp op)` apply the unary operation (such as "cos") to the dataset, propagating DEPEND_0 through DEPEND_3 and other appropriate metadata.
`static MutablePropertyDataSet`	`applyUnaryOp(QDataSet ds1, Ops.UnaryOp op)` apply the unary operation (such as "cos") to the dataset, propagating DEPEND_0 through DEPEND_3 and other appropriate metadata.
`static QDataSet`	`arange(int len0)` returns rank 1 dataset with values [0.,1.,2.,...]
`static double`	`asin(double ds)` return the asin of the real number in radians.
`static QDataSet`	`asin(java.lang.Object ds)`
`static QDataSet`	`asin(QDataSet ds)` element-wise arcsin, the inverse of the sin function.
`static double`	`atan(double ds)` arc tangent function
`static QDataSet`	`atan(java.lang.Object ds)`
`static QDataSet`	`atan(QDataSet ds)` element-wise arc tangent function
`static double`	`atan2(double y, double x)` 4-quadrant arc tangent.
`static QDataSet`	`atan2(java.lang.Object dsy, java.lang.Object dsx)`
`static QDataSet`	`atan2(QDataSet y, QDataSet x)` element-wise atan2, 4-quadrant atan.
`static QDataSet`	`autoHistogram(QDataSet ds)` AutoHistogram is a one-pass self-scaling histogram, useful in autoranging data.
`static QDataSet`	`binData(QDataSet ds, DatumRange bin)` increase the rank 1 data into rank 2 data by binning data.
`static QDataSet`	`binsWithin(QDataSet ds, QDataSet bounds)` return non-zero where the bins of ds are within the bounds.
`static QDataSet`	`binsWithout(QDataSet ds, QDataSet bounds)` return non-zero where the bins of ds are outside of the bounds.
`static QDataSet`	`bitwiseAnd(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`bitwiseAnd(QDataSet ds1, QDataSet ds2)` bitwise AND operator treats the data as (32-bit) integers, and returns the bit-wise AND.
`static QDataSet`	`bitwiseOr(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`bitwiseOr(QDataSet ds1, QDataSet ds2)` bitwise OR operator treats the data as (32-bit) integers, and returns the bit-wise OR.
`static QDataSet`	`bitwiseXor(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`bitwiseXor(QDataSet ds1, QDataSet ds2)` bitwise XOR (exclusive or) operator treats the data as (32-bit) integers, and returns the bit-wise XOR.
`static QDataSet`	`boundsDataset(java.lang.String s)` This returns one of a bounds dataset: rank 1 bounds (a datumRange) rank 2 bounding box rank 2 bounding qube (three or more dimensions) 2002-03-02/2002-03-03 2002-03-02 orbit:crres:6 5 to 50rank 1 bounds (a datumRange) 2002-03-02/2002-03-03;5 to 50rank 2 bounding box 2002-03-02T01:01/2002-03-02T01:02;5 to 50 eV;90 to 180 degrank 2 bounding qube Note dataset("5 to 50") presently parses to a rank 0 nominal dataset, not a rank 1 range.
`static QDataSet`	`buckshotInterpolate(QDataSet xy, QDataSet data, QDataSet xinterp, QDataSet yinterp)` 2-D interpolation performed by tessellating the space (with 3-point triangles) and doing interpolation.
`static QDataSet`	`buckshotInterpolate(QDataSet xyz, QDataSet data, QDataSet xinterp, QDataSet yinterp, QDataSet zinterp)` 3-D interpolation performed by tesselating the space (with 4-point tetrahedra) and doing interpolation.
`static QDataSet`	`bundle(QDataSet ds)` bundle the dataset, making an initial bundle, adding a bundle dimension.
`static QDataSet`	`bundle(QDataSet ds1, QDataSet ds2)` bundle the two datasets, adding if necessary a bundle dimension.
`static QDataSet`	`bundle(QDataSet ds1, QDataSet ds2, QDataSet ds3)` bundle three datasets, giving them a common zeroth index, typically time, unlike join.
`static QDataSet`	`bundle(QDataSet ds1, QDataSet ds2, QDataSet ds3, QDataSet ds4)` bundle four datasets, making them share their zeroth index, typically time, unlike join.
`static QDataSet`	`bundle(QDataSet ds1, QDataSet ds2, QDataSet ds3, QDataSet ds4, QDataSet ds5)` bundle five datasets, making them share their zeroth index, typically time, unlike join.
`static QDataSet`	`bundle(QDataSet ds1, QDataSet ds2, QDataSet ds3, QDataSet ds4, QDataSet ds5, QDataSet ds6)` bundle six datasets, making them share their zeroth index, typically time, unlike join.
`static QDataSet`	`bundle(QDataSet ds1, QDataSet ds2, QDataSet ds3, QDataSet ds4, QDataSet ds5, QDataSet ds6, QDataSet ds7)` bundle seven datasets, making them share their zeroth index, typically time, unlike join.
`static QDataSet`	`butterworth(QDataSet in, int order, Datum f, boolean lowp)` Perform Butterworth filter for high pass or low pass.
`static QDataSet`	`butterworth(QDataSet in, int order, Datum flow, Datum fhigh, boolean pass)` Perform Butterworth filter for notch or band pass or band reject.
`static QDataSet`	`bytarr(int len0)` create a dataset filled with zeros, stored in unsigned bytes.
`static QDataSet`	`bytarr(int len0, int len1)` create a rank 2 dataset filled with zeros, stored in unsigned bytes.
`static QDataSet`	`bytarr(int len0, int len1, int len2)` create a rank 3 dataset filled with zeros, stored in unsigned bytes.
`static double`	`ceil(double x)`
`static QDataSet`	`ceil(java.lang.Object x)`
`static QDataSet`	`ceil(QDataSet ds1)` element-wise ceil function.
`static QDataSet`	`chirp(QDataSet t, Datum df0, Datum dt1, Datum df1)` SciPy chirp function, used for testing.
`static QDataSet`	`circle(double dradius)` return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.
`static QDataSet`	`circle(double radius, double x, double y)` return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.
`static QDataSet`	`circle(QDataSet radius)` return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.
`static QDataSet`	`circle(QDataSet radius, QDataSet x, QDataSet y)` return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.
`static QDataSet`	`circle(java.lang.String sradius)` return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.
`static QDataSet`	`cleanData(QDataSet ds)` remove the data which is 3 sigmas from the mean of the data.
`static QDataSet`	`cleanData(QDataSet ds, double nsigma, int size)` remove the data which is N sigmas (stddev) from the mean.
`static QDataSet`	`cleanData(QDataSet ds, int size)` remove the data which is N sigmas (stddev) from the mean.
`static void`	`clearWritable(WritableDataSet ds)` assign zeros to all the values of the dataset.
`static QDataSet`	`collapse0(QDataSet fillDs)` this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the zeroth dimension.
`static QDataSet`	`collapse0(QDataSet fillDs, int st, int en)` this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the zeroth dimension.
`static QDataSet`	`collapse0R4(QDataSet ds, ProgressMonitor mon)` Collapse the rank 4 dataset on the zeroth index.
`static QDataSet`	`collapse1(QDataSet ds)` this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the first dimension collapse1( ds[30,20] ) → ds[30]
`static QDataSet`	`collapse1R4(QDataSet ds, ProgressMonitor mon)` Collapse the rank 4 dataset on the first index.
`static QDataSet`	`collapse2(QDataSet fillDs)` this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the first dimension collapse2( ds[30,20,10,5] ) → ds[30,20,5]
`static QDataSet`	`collapse2R4(QDataSet ds, ProgressMonitor mon)` Collapse the rank 4 dataset on the second index.
`static QDataSet`	`collapse3(QDataSet fillDs)` this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the first dimension collapse3( ds[30,20,10,5] ) → ds[30,20,10]
`static QDataSet`	`collapse3R4(QDataSet ds, ProgressMonitor mon)` Collapse the rank 4 dataset on the third index.
`static java.awt.Color`	`colorFromString(java.lang.String sval)` return the color encoded as one of: "red" or "RED" or X11 color names like "LightPink" #FF0000 255,0,0 or 1.0,0,0
`static QDataSet`	`complexConj(QDataSet ds)` return the complex conjugate of the rank 1 or rank 2 QDataSet.
`static QDataSet`	`complexDataset(QDataSet realPart, QDataSet imaginaryPart)` create a complex dataset.
`static QDataSet`	`complexMultiply(QDataSet ds1, QDataSet ds2)` perform complex multiplication, where the two datasets must have the same rank and must both end with a complex dimension.
`static QDataSet`	`concatenate(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`concatenate(QDataSet ds1, QDataSet ds2)` Deprecated. use append instead.
`static QDataSet`	`contour(java.lang.Object tds, java.lang.Object vv)`
`static QDataSet`	`contour(QDataSet tds, QDataSet vv)` contour the data in rank 2 table tds at rank 0 vv.
`static java.lang.Object`	`convertPropertyValue(QDataSet context, java.lang.String name, java.lang.Object value)` convert the object into the type needed for the property.
`static java.lang.String`	`convertToString(QDataSet bytes)` convert the bytes (or unicode up to 2**16) to a string.
`static DatumRange`	`convertUnitsTo(DatumRange dr, Units u)` convert the datumRange to the given units, which must be convertible.
`static Datum`	`convertUnitsTo(Datum d, Units u)` convert the datum to the given units, which must be convertible.
`static QDataSet`	`convertUnitsTo(QDataSet ds, Units u)` convert the dataset to the target units.
`static WritableDataSet`	`copy(QDataSet src)` copy the dataset to make a new one that is writable.
`static void`	`copyIndexedProperties(QDataSet srcds, MutablePropertyDataSet mds)` copy over all the indexed properties into the mutable property dataset.
`static java.util.Map<java.lang.String,java.lang.Object>`	`copyProperties(QDataSet ds)` copies the properties, copying depend datasets as well.
`static double`	`copysign(double x, double y)`
`static QDataSet`	`copysign(java.lang.Object x, java.lang.Object y)`
`static QDataSet`	`copysign(QDataSet magnitude, QDataSet sign)` Returns the first floating-point argument with the sign of the second floating-point argument.
`static double`	`cos(double ds)` return the cos of the real number, which is to be in radians.
`static QDataSet`	`cos(java.lang.Object ds)`
`static QDataSet`	`cos(QDataSet ds)` element-wise cos.
`static double`	`cosh(double ds)`
`static QDataSet`	`cosh(java.lang.Object ds)`
`static QDataSet`	`cosh(QDataSet ds)` element-wise hyperbolic cosine
`static QDataSet`	`createEvent(DatumRange dr, int rgbcolor, java.lang.String annotation)` tool for creating ad-hoc events datasets.
`static QDataSet`	`createEvent(QDataSet append, DatumRange dr, int rgbcolor, java.lang.String annotation)` tool for creating ad-hoc events datasets.
`static QDataSet`	`createEvent(QDataSet append, java.lang.String timeRange, int rgbcolor, java.lang.String annotation)` tool for creating ad-hoc events datasets.
`static QDataSet`	`createEvent(java.lang.String timeRange, int rgbcolor, java.lang.String annotation)` tool for creating ad-hoc events datasets.
`static QDataSet`	`createEvents(QDataSet vds)` make canonical rank 2 bundle dataset of min,max,color,text This was originally part of EventsRenderer, but it became clear that this was generally useful.
`static QDataSet`	`createEvents(QDataSet vds, java.awt.Color deftColor)` make canonical rank 2 bundle dataset of min,max,color,text This was originally part of EventsRenderer, but it became clear that this was generally useful.
`static QDataSet`	`createPolyMesh(QDataSet append, QDataSet xy)` create or append to a polyMesh, adding the points from rank 2 bundle xy.
`static QDataSet`	`crossProduct(QDataSet a, QDataSet b)` apply the cross product of a and b, where a or b may be rank 1, three-element vector, or both can be vector arrays of the same length.
`static double[]`	`cubicRoot(double a, double b, double c, double d)` Enter the coefficients for a cubic of the form: ax^3 + bx^2 + c*x + d = 0.
`static QDataSet`	`cubicRoot(QDataSet coefficients)` Solves each of a set of cubic equations of the form: ax^3 + bx^2 + c*x + d = 0.
`static QDataSet`	`cumulativeMax(QDataSet ds)` for each element i of ds, set the result[i] to the maximum of ds[0:(i+1)]
`static QDataSet`	`cumulativeMin(QDataSet ds)` for each element i of ds, set the result[i] to the minimum of ds[0:(i+1)]
`static int[]`	`dataIntersection(int[] itE, int[] itB)` return the values which occur in both rank 1 datasets.
`static QDataSet`	`dataIntersection(QDataSet tE, QDataSet tB)` return the values which occur in both rank 1 datasets.
`static QDataSet`	`dataset(java.lang.Object arg0)` coerce Java objects like arrays Lists and scalars into a QDataSet.
`static QDataSet`	`dataset(java.lang.Object arg0, Units u)` coerce Java objects like arrays Lists and scalars into a QDataSet.
`static Datum`	`datum(java.lang.Object arg0)` coerce Java objects like numbers and strings into a Datum.
`static DatumRange`	`datumRange(java.lang.Object arg0)` coerce Java objects like arrays and strings into a DatumRange.
`static QDataSet`	`dblarr(int len0)` create a rank 1 dataset filled with zeros, stored in 8-byte doubles.
`static QDataSet`	`dblarr(int len0, int len1)` create a rank 2 dataset filled with zeros, stored in 8-byte doubles.
`static QDataSet`	`dblarr(int len0, int len1, int len2)` create a rank 3 dataset filled with zeros, stored in 8-byte doubles.
`static QDataSet`	`decimate(QDataSet ds)` reduce the size of the data by keeping every 10th measurement.
`static QDataSet`	`decimate(QDataSet ds, int m)` reduce the size of the data by keeping every nth measurement (subsample), starting at the 0th measurement.
`static QDataSet`	`decimate(QDataSet ds, int m, int n)` reduce the size of the data by keeping every nth measurement (subsample).
`static MutablePropertyDataSet`	`dependsOn(QDataSet ds, int dim, QDataSet dep)` declare that the dataset is a dependent parameter of an independent parameter.
`static QDataSet`	`detrend(java.lang.Object yy, int size)`
`static QDataSet`	`detrend(QDataSet yy, int size)` remove D/C and low-frequency components from the data by subtracting out the smoothed data with a boxcar of the given size.
`static QDataSet`	`detrend1(QDataSet yy, int size)` remove D/C and low-frequency components from the data by subtracting out the smoothed data with a boxcar of the given size, along each record.
`static QDataSet`	`diff(java.lang.Object ds)`
`static QDataSet`	`diff(QDataSet ds)` return array that is the differences between each successive pair in the dataset.
`static int`	`dimensionCount(java.lang.Object dss)` returns the number of physical dimensions of the object when interpreted as a dataset.
`static int`	`dimensionCount(QDataSet dss)` returns the number of physical dimensions of a dataset.
`static QDataSet`	`dindgen(int len0)` returns rank 1 dataset with values [0.,1.,2.,...]
`static QDataSet`	`dindgen(int len0, int len1)` returns rank 2 dataset with values increasing [ [0.,1.,2.], [ 3.,4.,5.] ]
`static QDataSet`	`dindgen(int len0, int len1, int len2)` returns rank 3 dataset with values increasing
`static QDataSet`	`dindgen(int len0, int len1, int len2, int len3)` returns rank 4 dataset with values increasing
`static QDataSet`	`distance(int len0, double c0, double r0)` return a table of distances d[len0] to the indices c0; in units of r0.
`static QDataSet`	`distance(int len0, int len1, double c0, double c1, double r0, double r1)` return a table of distances d[len0,len1] to the indices c0,c1; in units of r0, r1.
`static QDataSet`	`div(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`div(QDataSet ds1, QDataSet ds2)` element-wise div of two datasets with compatible geometry.
`static QDataSet`	`divide(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`divide(QDataSet ds1, QDataSet ds2)` element-wise divide of two datasets with compatible geometry.
`static QDataSet`	`divp(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`divp(QDataSet ds1, QDataSet ds2)` This div goes with modp, where -18 divp 10 = -2 and -18 modp 10 = 8.
`static QDataSet`	`ellipse(double xwidth, double ywidth)` return a dataset with X and Y forming a ellipse, introduced as a convenient way to indicate planet location of any planet, according to Masafumi.
`static QDataSet`	`ensureMonotonic(QDataSet ds)` possibly sort the data where the DEPEND_0 tags are monotonically increasing.
`static QDataSet`	`ensureMonotonicAndIncreasingWithFill(QDataSet ds)` Return data where the DEPEND_0 tags are monotonically increasing and non repeating.
`static QDataSet`	`eq(java.lang.Object ds1, java.lang.Object ds2)` element-wise equality test, converting arguments as necessary to like units.
`static QDataSet`	`eq(QDataSet ds1, QDataSet ds2)` element-wise equality test.
`static java.util.HashMap<java.lang.String,java.lang.Object>`	`equalProperties(java.util.Map<java.lang.String,java.lang.Object> m1, java.util.Map<java.lang.String,java.lang.Object> m2)` returns the subset of two groups of properties that are equal, so these may be preserved through operations.
`static boolean`	`equivalent(java.lang.Object ds1, java.lang.Object ds2)`
`static boolean`	`equivalent(QDataSet ds1, QDataSet ds2)` returns true iff the dataset values are equivalent.
`static QDataSet`	`eventsComplement(QDataSet events, DatumRange range, int color, java.lang.String msg)` Return an events list of time intervals which are not covered in the events list.
`static QDataSet`	`eventsConjunction(QDataSet tE, QDataSet tB)` return an events list of when events are found in both events lists.
`static QDataSet`	`eventsDiff(QDataSet tE, QDataSet tB)` return an events dataset describing differences between the two events lists.
`static double`	`exp(double d)` Jython requires this be implemented
`static QDataSet`	`exp(java.lang.Object ds1)` convert array, list, double, etc to QDataSet and return exp(d)
`static QDataSet`	`exp(QDataSet ds)` element-wise exponentiate e**x.
`static double`	`exp10(double ds1)`
`static QDataSet`	`exp10(java.lang.Object ds1)`
`static QDataSet`	`exp10(QDataSet ds)` element-wise exponentiate 10**x.
`static QDataSet`	`expandToFillGaps(QDataSet ds)` Special function by the RPW Group at U.
`static QDataSet`	`expandToFillGaps(QDataSet ds, Datum cadenceMin, double multiplier)` Special function by the RPW Group at U.
`static QDataSet`	`expandToFillGaps(QDataSet ds, double factor)` Special self-configuring function by the RPW Group at U.
`static QDataSet`	`expandWaveform(QDataSet ds)` special function needed by the RPW Group at U.
`static double`	`expm1(double x)` Returns e^x -1.
`static QDataSet`	`expm1(java.lang.Object x)` Returns e^x -1.
`static QDataSet`	`expm1(QDataSet xx)` Returns e^xx -1.
`static QDataSet`	`extent(QDataSet ds)` returns a two element, rank 1 dataset containing the extent of the data.
`static QDataSet`	`extent(QDataSet ds, QDataSet range)` returns a two element, rank 1 dataset containing the extent (min to max) of the data.
`static QDataSet`	`extent(QDataSet ds, QDataSet wds, QDataSet range)` returns a two element, rank 1 dataset containing the extent (min to max) of the data, allowing an external evaluation of the weightsDataSet.
`static QDataSet`	`extent445(QDataSet ds)` Deprecated. use extentSimple
`static QDataSet`	`extentSimple(QDataSet ds, QDataSet range)` This is introduced to study effect of https://sourceforge.net/p/autoplot/feature-requests/445/ Do not use this in scripts!!! This is very interesting: Ops.extent: 53ms simpleRange: 77ms study445FastRange: 4ms Ops.extent: 76ms simpleRange: 114ms study445FastRange: 12ms This is likely showing that DataSetIterator is slow...
`static QDataSet`	`extentSimple(QDataSet ds, QDataSet wds, QDataSet range)` like extent, but does not account for DELTA_PLUS, DELTA_MINUS, BIN_PLUS, BIN_MINUS, BIN_MIN or BIN_MAX properties.
`static QDataSet`	`fft(QDataSet ds)` Performs an FFT on the provided rank 1 dataset.
`static QDataSet`	`fft(QDataSet ds, QDataSet window, int stepFraction, ProgressMonitor mon)` perform ffts on the waveform as we do with fftPower, but keep real and imaginary components.
`static QDataSet`	`fftFilter(QDataSet ds, int len, Ops.FFTFilterType filt)` Apply windows to the data to prepare for FFT.
`static QDataSet`	`fftLinearSpectralDensity(QDataSet ds, QDataSet window, int stepFraction, ProgressMonitor mon)` Perform the linear spectral density function
`static QDataSet`	`fftLinearSpectrum(QDataSet ds, QDataSet window, int stepFraction, ProgressMonitor mon)` Perform the linear spectrum function
`static QDataSet`	`fftPower(QDataSet ds)` returns the power spectrum of the waveform.
`static QDataSet`	`fftPower(QDataSet ds, int windowLen, int stepFraction, java.lang.String windowName, ProgressMonitor mon)` fftPower that matches the filter call (\|fftPower(ds,len,stepFraction,windowName)).
`static QDataSet`	`fftPower(QDataSet ds, int len, ProgressMonitor mon)` create a power spectrum on the dataset by breaking it up and doing FFTs on each segment.
`static QDataSet`	`fftPower(QDataSet ds, QDataSet window, int stepFraction, ProgressMonitor mon)` create a power spectrum on the dataset by breaking it up and doing FFTs on each segment.
`static QDataSet`	`fftPower(QDataSet ds, QDataSet window, ProgressMonitor mon)` perform the fft with the window, using no overlap.
`static QDataSet`	`fftPowerMultiThread(QDataSet ds, int len, ProgressMonitor mon)` Experiment with multi-threaded FFTPower function.
`static QDataSet`	`fftPowerSpectralDensity(QDataSet ds, QDataSet window, int stepFraction, ProgressMonitor mon)` Perform the power spectral density function
`static QDataSet`	`fftPowerSpectrum(QDataSet ds, QDataSet window, int stepFraction, ProgressMonitor mon)` Perform the linear spectrum function
`static QDataSet`	`fftWindow(QDataSet ds, int len)` perform ffts on the rank 1 dataset to make a rank2 spectrogram.
`static boolean`	`fillIsDifferent(QDataSet ds1, QDataSet ds2)` return true of the representation of fill is different in the two data sets.
`static QDataSet`	`findex(java.lang.Object x, java.lang.Object y)`
`static QDataSet`	`findex(QDataSet uu, QDataSet vv)` returns the "floating point index" of each element of vv within the monotonically increasing dataset uu.
`static QDataSet`	`findgen(int len0)` returns rank 1 dataset with values [0.,1.,2.,...]
`static QDataSet`	`findgen(int len0, int len1)` returns rank 2 dataset with values increasing [ [0.,1.,2.], [ 3.,4.,5.] ]
`static QDataSet`	`findgen(int len0, int len1, int len2)` returns rank 3 dataset with values increasing
`static QDataSet`	`findgen(int len0, int len1, int len2, int len3)` returns rank 4 dataset with values increasing
`static QDataSet`	`finite(QDataSet ds)` returns 1 where the data is not NaN, Inf, etc I needed this when I was working with the RBSP polar scatter script.
`static QDataSet`	`flatten(QDataSet ds)` flatten a rank N dataset.
`static QDataSet`	`flattenWaveform(QDataSet ds)` flatten a rank 2 dataset where the y depend variable is just an offset from the xtag.
`static double`	`floor(double x)`
`static QDataSet`	`floor(java.lang.Object ds1)`
`static QDataSet`	`floor(QDataSet ds1)` element-wise floor function.
`static QDataSet`	`fltarr(int len0)` create a dataset filled with zeros, stored in 4-byte floats.
`static QDataSet`	`fltarr(int len0, int len1)`
`static QDataSet`	`fltarr(int len0, int len1, int len2)`
`static double`	`gamma(double n)` return the gamma function for numbers greater than 0.
`static QDataSet`	`gamma(java.lang.Object n)` return the gamma function for numbers greater than 0.
`static QDataSet`	`ge(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`ge(QDataSet ds1, QDataSet ds2)` element-wise function returns 1 where ds1>=ds2.
`static java.lang.Object`	`getProperty(QDataSet ds, java.lang.String name)` retrieve a property from the dataset.
`static <T> T`	`getProperty(QDataSet ds, java.lang.String propertyName, java.lang.Class<T> clazz)` return the property, issuing a warning and returning null when the property value is not of the correct type.
`static int[]`	`getQubeDimsForArray(java.lang.Object arg0)` return the length of each index of a n-D array.
`static QDataSet`	`greaterOf(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`greaterOf(QDataSet ds1, QDataSet ds2)` element-wise function returns the greater of ds1 and ds2.
`static QDataSet`	`grid(QDataSet ds)` Opposite of the flatten function, takes rank 2 bundle (x,y,z) and makes a table from it z(x,y).
`static QDataSet`	`gridIrregularY(QDataSet t, QDataSet y, QDataSet z, QDataSet ytags)` This finds sweeps of Y and interpolates T->Y->Z to make a regular spectrogram T,yTags->Z[T,yTags] This function was once known as "LvT" because it was used to create a spectrogram of Flux(Time,Lshell) by interpolating along sweeps.
`static QDataSet`	`gt(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`gt(QDataSet ds1, QDataSet ds2)` element-wise function returns 1 where ds1>ds2.
`static java.lang.String`	`guessLabel(QDataSet ds)` get the label, using the NAME when LABEL is not available.
`static java.lang.String`	`guessLabel(QDataSet ds, java.lang.String deft)` get the label, using the NAME when LABEL is not available.
`static java.lang.String`	`guessName(QDataSet ds)` guess a name for the dataset, looking for NAME and then safeName(LABEL).
`static java.lang.String`	`guessName(QDataSet ds, java.lang.String deft)` guess a name for the dataset, looking for NAME and then safeName(LABEL).
`static QDataSet`	`hanning(QDataSet ds, int len)` Apply Hanning (Hann) windows to the data to prepare for FFT.
`static QDataSet`	`hashcodes(QDataSet ds)` return a rank 1 hashcodes of each record the dataset, with one hashcodes value for each record.
`static QDataSet`	`hilbert(QDataSet ds)` Perform the Hilbert function on the rank 1 dataset, similar to the hilbert function in IDL and Matlab.
`static QDataSet`	`hilbertSciPy(QDataSet ds)` Perform the Hilbert function on the rank 1 dataset, similar to the scipy.signal.hilbert function in SciPy.
`static QDataSet`	`histogram(QDataSet ds, Datum min, Datum max, Datum binsize)` returns a rank 1 dataset that is a histogram of the data.
`static QDataSet`	`histogram(QDataSet ds, double min, double max, double binSize)` returns a rank 1 dataset that is a histogram of the data.
`static QDataSet`	`histogram(QDataSet ds, int binCount)` returns a histogram of the dataset, based on the extent and scaletype of the data.
`static QDataSet`	`histogram(QDataSet ds, java.lang.String min, java.lang.String max, java.lang.String binsize)` returns rank 1 dataset that is a histogram of the data.
`static QDataSet`	`histogram2d(QDataSet x, QDataSet y, int[] bins, QDataSet xrange, QDataSet yrange)` make a 2-D histogram of the data in x and y.
`static QDataSet`	`identifyContinuousBlocks(Datum cadence, DatumRange extent, QDataSet lastBlocks, QDataSet times)` return events list containing start and stop times of continuous blocks in time.
`static QDataSet`	`ifft(QDataSet ds)` Performs an inverse FFT on the provided rank 2 dataset of complex numbers.
`static QDataSet`	`ifft(QDataSet ds, QDataSet window, int stepFraction, ProgressMonitor mon)` create the inverse fft of the real and imaginary spec
`static int`	`imax(java.lang.Object ds)`
`static int`	`imax(QDataSet ds)` return the index of the maximum value.
`static int`	`imin(java.lang.Object ds)`
`static int`	`imin(QDataSet ds)` return the index of the minimum value.
`static QDataSet`	`indgen(int len0)` returns rank 1 dataset with values [0,1,2,...] This returns an immutable dataset, so that it can be used in Jython like so: for i in indgen(200000).
`static QDataSet`	`indgen(int len0, int len1)` returns rank 2 dataset with values increasing [ [0,1,2], [ 3,4,5] ]
`static QDataSet`	`indgen(int len0, int len1, int len2)` returns rank 3 dataset with values increasing
`static QDataSet`	`intarr(int len0)` create a dataset filled with zeros, stored in 4-byte ints.
`static QDataSet`	`intarr(int len0, int len1)` create a rank 2 dataset filled with zeros, stored in 4-byte ints.
`static QDataSet`	`intarr(int len0, int len1, int len2)` create a rank 3 dataset filled with zeros, stored in 4-byte ints.
`static QDataSet`	`interpolate(java.lang.Object vv, java.lang.Object findex)`
`static QDataSet`	`interpolate(java.lang.Object vv, java.lang.Object findex0, java.lang.Object findex1)` interpolate values from rank 2 dataset vv using fractional indices in rank N findex, using bilinear interpolation.
`static QDataSet`	`interpolate(QDataSet vv, QDataSet findex)` interpolate values from rank 1 dataset vv using fractional indices in rank N findex.
`static QDataSet`	`interpolate(QDataSet vv, QDataSet findex0, QDataSet findex1)` interpolate values from rank 2 dataset vv using fractional indices in rank N findex, using bilinear interpolation.
`static QDataSet`	`interpolate(QDataSet vv, QDataSet findex0, QDataSet findex1, QDataSet findex2)` interpolate values from rank 2 dataset vv using fractional indices in rank N findex, using bilinear interpolation.
`static QDataSet`	`interpolateGrid(java.lang.Object x, java.lang.Object y, java.lang.Object z)`
`static QDataSet`	`interpolateGrid(QDataSet vv, QDataSet findex0, QDataSet findex1)` interpolate values from rank 2 dataset vv using fractional indices in rank N findex, using bilinear interpolation.
`static QDataSet`	`interpolateMod(QDataSet vv, QDataSet mod, QDataSet findex)` like interpolate, but the findex is recalculated when the two bracketed points are closer in the modulo space than they would be in the linear space.
`static QDataSet`	`invalid(QDataSet ds)` returns a dataset with one where the data is invalid, and zero the data is valid.
`static java.util.Iterator<java.lang.Integer>`	`irange(double max)` mimic the Jython xrange function for use in loops.
`static java.util.Iterator<java.lang.Integer>`	`irange(double min, double max)` mimic the Jython xrange function for use in loops.
`static java.util.Iterator<java.lang.Integer>`	`irange(double min, double max, int step)` mimic the Jython xrange function for use in loops.
`static java.lang.Double`	`isAngleRange(QDataSet ds, boolean strict)` return true if the dataset can be interpreted as radian degrees from 0 to PI or from 0 to 2*PI.
`static boolean`	`isBundle(QDataSet zds)` return true if the dataset is a bundle.
`static boolean`	`isLegacyBundle(QDataSet zds)` return true if DEPEND_1 is set and its units are EnumerationUnits.
`static boolean`	`isSafeName(java.lang.String name)` returns true if the name is a Java-style identifier, starting with one of a-z, A-Z, or _; followed by a-z, A-Z, 0-9, or _; and note that only ASCII characters are allowed.
`static QDataSet`	`join(QDataSet ds2)` Deprecated. use join(null,ds2) instead.
`static QDataSet`	`join(QDataSet ds1, QDataSet ds2)` Join two rank N datasets to make a rank N+1 dataset, with the first dimension having two elements.
`static QDataSet`	`labels(java.lang.String[] labels)` Deprecated. use labelsDataSet
`static QDataSet`	`labels(java.lang.String[] labels, java.lang.String context)` Deprecated. use labelsDataset
`static QDataSet`	`labelsDataset(java.lang.String label)` create a rank 0 label dataset.
`static QDataSet`	`labelsDataset(java.lang.String[] labels)` create a labels dataset for tagging rows of a dataset.
`static QDataSet`	`labelsDataset(java.lang.String[] labels, java.lang.String context)` create a labels dataset for tagging rows of a dataset.
`static QDataSet`	`labelsDataset(java.lang.String label, java.lang.String context)` create a rank 0 label dataset.
`static QDataSet`	`le(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`le(QDataSet ds1, QDataSet ds2)` element-wise function returns 1 where ds1<=ds2.
`static QDataSet`	`lesserOf(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`lesserOf(QDataSet ds1, QDataSet ds2)` element-wise function returns the smaller of ds1 and ds2.
`static QDataSet`	`link(java.lang.Object x, java.lang.Object y)`
`static QDataSet`	`link(java.lang.Object x, java.lang.Object y, java.lang.Object z)`
`static QDataSet`	`link(java.lang.Object d0, java.lang.Object d1, java.lang.Object d2, java.lang.Object z)`
`static QDataSet`	`link(QDataSet x, QDataSet y)` link is the fundamental operator where we declare that one dataset is dependent on another.
`static QDataSet`	`link(QDataSet x, QDataSet y, QDataSet z)` link is the fundamental operator where we declare that one dataset is dependent on another.
`static QDataSet`	`link(QDataSet d0, QDataSet d1, QDataSet d2, QDataSet z)` like bundle, but declare the last dataset is dependent on the first three.
`static QDataSet`	`link(QDataSet d0, QDataSet d1, QDataSet d2, QDataSet d3, QDataSet z)` like bundle, but declare the last dataset is dependent on the first three.
`static QDataSet`	`linspace(double min, double max, int len0)` return a rank 1 dataset with `len0` linearly-spaced values, the first is min and the last is max.
`static QDataSet`	`linspace(java.lang.Object omin, java.lang.Object omax, int len0)` return a rank 1 dataset with `len0` linearly-spaced values, the first is min and the last is max.
`static double`	`log(double ds1)`
`static QDataSet`	`log(java.lang.Object ds1)`
`static QDataSet`	`log(QDataSet ds)` element-wise natural logarithm.
`static double`	`log10(double ds1)`
`static QDataSet`	`log10(java.lang.Object ds1)`
`static QDataSet`	`log10(QDataSet ds)` element-wise base 10 logarithm.
`static QDataSet`	`logspace(double min, double max, int len0)` return a rank 1 dataset with `len0` logarithmically-spaced values, the first is min and the last is max.
`static QDataSet`	`logspace(java.lang.Object omin, java.lang.Object omax, int len0)` return a rank 1 dataset with `len0` logarithmically-spaced values, the first is min and the last is max.
`static QDataSet`	`lonarr(int len0)` create a dataset filled with zeros, stored in 8-byte longs, suitable for storing cdf_tt2000 times..
`static QDataSet`	`lonarr(int len0, int len1)` create a rank 2 dataset filled with zeros, stored in 8-byte longs.
`static QDataSet`	`lt(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`lt(QDataSet ds1, QDataSet ds2)` element-wise function returns 1 where ds1<ds2.
`static QDataSet`	`magnitude(java.lang.Object ds1)`
`static QDataSet`	`magnitude(QDataSet ds)` return the magnitudes of vectors in a rank 1 or greater dataset (typically rank 2).
`static java.lang.String`	`matrixFormat(QDataSet mm, java.lang.String style)` format the matrix values, using %.3f and tabs to make it legible.
`static QDataSet`	`matrixFromEuler(java.lang.String seq, Datum angle)` return the matrix rotating about one axis.
`static QDataSet`	`matrixMultiply(QDataSet m, QDataSet v)` matrix multiply the components of vector `v` by matrix `m`.
`static QDataSet`	`matrixParse(java.lang.String smat)` parse the string into a rank 2 matrix
`static WritableDataSet`	`maybeCopy(QDataSet ads0)` Copy the dataset to an ArrayDataSet only if the dataset is not already an ArrayDataSet or BufferDataSet.
`static QDataSet`	`mean(java.lang.Object o)`
`static QDataSet`	`mean(QDataSet ds)` Mean function that returns the average of the valid elements of a rank N dataset
`static QDataSet`	`meanAverageDeviation(QDataSet ds)` return the Mean Average Deviation (MAD) of the rank N dataset.
`static QDataSet`	`median(java.lang.Object o)` Median function that sorts a rank N dataset and returns its median.
`static QDataSet`	`median(QDataSet ds)` Median function that sorts a rank N dataset and returns its median.
`static QDataSet`	`medianFilter(QDataSet ds, int size)` 1-D median filter with a boxcar of the given size.
`static QDataSet`	`merge(QDataSet ds1, QDataSet ds2)` Merge the two sorted rank N datasets, using their DEPEND_0 datasets, into one rank N dataset.
`static QDataSet`	`mod(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`mod(QDataSet ds1, QDataSet ds2)` element-wise mod of two datasets with compatible geometry.
`static QDataSet`	`mode(QDataSet ds)` return the most frequently occurring element of the valid elements of a rank N dataset
`static QDataSet`	`modp(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`modp(QDataSet ds1, QDataSet ds2)` element-wise mod of two datasets with compatible geometry.
`static MutablePropertyDataSet`	`monotonicSubset(QDataSet ds)` ensure that there are no non-monotonic or repeat records, by removing the first N-1 records of N repeated records.
`static QDataSet`	`multiply(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`multiply(QDataSet ds1, QDataSet ds2)` element-wise multiply of two datasets with compatible geometry.
`static QDataSet`	`ne(java.lang.Object ds1, java.lang.Object ds2)` element-wise equality test, converting arguments as necessary to like units.
`static QDataSet`	`ne(QDataSet ds1, QDataSet ds2)` element-wise not equal test.
`static QDataSet`	`negate(java.lang.Object ds1)`
`static QDataSet`	`negate(QDataSet ds1)` return a dataset with each element negated.
`static QDataSet`	`neighborFill(QDataSet ds)` fill in the missing values by copying nearest data points.
`static QDataSet`	`normalize(QDataSet ds)` normalize the data so that the max is 1, where we normalize by the biggest value, so that the maximum is one.
`static QDataSet`	`normalize(QDataSet ds, int dim)` normalize the data so that the max at a row or column is 1, where we have normalized by the biggest value along a dimension.
`static QDataSet`	`not(java.lang.Object ds1)`
`static QDataSet`	`not(QDataSet ds1)` element-wise logical not function.
`static QDataSet`	`ones(int len0)` return new dataset filled with ones.
`static QDataSet`	`ones(int len0, int len1)` return a rank two dataset filled with ones.
`static QDataSet`	`ones(int len0, int len1, int len2)` return new dataset filled with ones.
`static QDataSet`	`ones(int len0, int len1, int len2, int len3)` return new dataset filled with ones.
`static QDataSet`	`or(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`or(QDataSet ds1, QDataSet ds2)` element-wise logical or function.
`static QDataSet`	`outerProduct(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`outerProduct(QDataSet ds1, QDataSet ds2)` returns outerProduct of two rank 1 datasets, a rank 2 dataset with elements R[i,j]= ds1[i] * ds2[j].
`static QDataSet`	`outerSum(java.lang.Object ds1, java.lang.Object ds2)`
`static QDataSet`	`outerSum(QDataSet ds1, QDataSet ds2)` returns outerSum of two rank 1 datasets, a rank 2 dataset with elements R[i,j]= ds1[i] + ds2[j].
`static QDataSet`	`polarToCartesian(QDataSet ds)` converts a rank 2 bundle of polar data, where ds[:,0] are the radii and ds[:,1] are the angles.
`static QDataSet`	`polyCenters(QDataSet polyMesh)` return an array of the centers of each triangle in the triangle mesh.
`static double`	`pow(double x, double y)` for Jython, we define this because the doubles aren't coerced.
`static long`	`pow(long x, long y)` for Jython, we define this because the doubles aren't coerced.
`static QDataSet`	`pow(java.lang.Object ds1, java.lang.Object pow)` element-wise pow (** in FORTRAN, ^ in IDL) of two datasets with the same geometry.
`static QDataSet`	`pow(QDataSet ds1, QDataSet pow)` element-wise pow (** in FORTRAN, ^ in IDL) of two datasets with the compatible geometry.
`static MutablePropertyDataSet`	`putBundleProperty(QDataSet ds, java.lang.String name, int index, java.lang.Object value)` Like putIndexedProperty, but manages the bundle for the client.
`static MutablePropertyDataSet`	`putIndexedProperty(QDataSet ds, java.lang.String name, int index, java.lang.Object value)` Like putProperty, but this inserts the value at the index.
`static MutablePropertyDataSet`	`putProperty(java.lang.Object ds, java.lang.String name, java.lang.Object value)` converts types often seen in Jython and Java codes to the correct type.
`static MutablePropertyDataSet`	`putProperty(QDataSet ds, java.lang.String name, java.lang.Object value)` converts types often seen in Jython and Java codes to the correct type.
`static WritableDataSet`	`putValues(java.lang.Object ds, java.lang.Object indices, java.lang.Object values)` like putProperty, but this inserts values into the dataset.
`static WritableDataSet`	`putValues(QDataSet ds, QDataSet indices, QDataSet value)` like putProperty, but this inserts values into the dataset.
`static QDataSet`	`rand()` Deprecated. use randu instead
`static QDataSet`	`rand(int len0)` Deprecated. use randu instead. This is used in many test programs and Jython codes, and will not be removed.
`static QDataSet`	`rand(int len0, int len1)` Deprecated. use randu instead
`static QDataSet`	`rand(int len0, int len1, int len2)` Deprecated. use randu instead
`static QDataSet`	`randn()` return a rank 0 dataset of random numbers of a Gaussian (normal) distribution.
`static QDataSet`	`randn(int len0)` return a rank 1 dataset of random numbers of a Gaussian (normal) distribution.
`static QDataSet`	`randn(int len0, int len1)` return a rank 2 dataset of random numbers of a Gaussian (normal) distribution.
`static QDataSet`	`randn(int len0, int len1, int len2)` return a rank 3 dataset of random numbers of a Gaussian (normal) distribution.
`static QDataSet`	`randn(int len0, int len1, int len2, int len3)` return a rank 4 dataset of random numbers of a Gaussian (normal) distribution.
`static QDataSet`	`randomn(long seed)` returns a rank 0 dataset of random numbers of a Gaussian (normal) distribution.
`static QDataSet`	`randomn(long seed, int len0)` returns a rank 1 dataset of random numbers of a Gaussian (normal) distribution.
`static QDataSet`	`randomn(long seed, int len0, int len1)` returns a rank 2 dataset of random numbers of a Gaussian (normal) distribution.
`static QDataSet`	`randomn(long seed, int len0, int len1, int len2)` returns a rank 3 dataset of random numbers of a gaussian (normal) distribution.
`static QDataSet`	`randomn(long seed, int len0, int len1, int len2, int len3)` returns a rank 3 dataset of random numbers of a gaussian (normal) distribution.
`static long`	`randomSeed()` restart the random sequence used by randu and randn.
`static long`	`randomSeed(long seed)` reset the random sequence used by randu and randn to the given seed.
`static QDataSet`	`randomu(long seed)` returns a rank 0 dataset of random numbers of a uniform distribution.
`static QDataSet`	`randomu(long seed, int len0)` returns a rank 1 dataset of random numbers of a uniform distribution.
`static QDataSet`	`randomu(long seed, int len0, int len1)` returns a rank 2 dataset of random numbers of a uniform distribution.
`static QDataSet`	`randomu(long seed, int len0, int len1, int len2)` returns a rank 3 dataset of random numbers of a uniform distribution.
`static QDataSet`	`randomu(long seed, int len0, int len1, int len2, int len3)` returns a rank 3 dataset of random numbers of a uniform distribution.
`static QDataSet`	`randu()` returns a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.
`static QDataSet`	`randu(int len0)` returns a rank 1 dataset of random uniform numbers from 0 to 1 but not including 1.
`static QDataSet`	`randu(int len0, int len1)` returns a rank 2 dataset of random uniform numbers from 0 to 1 but not including 1.
`static QDataSet`	`randu(int len0, int len1, int len2)` returns a rank 3 dataset of random uniform numbers from 0 to 1 but not including 1.
`static QDataSet`	`randu(int len0, int len1, int len2, int len3)` return a rank 4 dataset of random uniform numbers from 0 to 1 but not including 1.
`static QDataSet`	`rebundle(QDataSet bundle1, int[] ii)` unbundle datasets by index from the bundle, and rebundle them in the order specified.
`static QDataSet`	`rebundle(QDataSet bundle1, java.lang.String[] names)` unbundle the names from the bundle, and rebundle them in the order specified.
`static QDataSet`	`reduceBins(QDataSet dep1)` reduce each bin to its center.
`static QDataSet`	`reduceMax(QDataSet ds, int dim)` reduce the dataset's rank by reporting the max of all the elements along a dimension.
`static QDataSet`	`reduceMax(QDataSet ds, int dim, ProgressMonitor mon)` reduce the dataset's rank by reporting the max of all the elements along a dimension.
`static QDataSet`	`reduceMean(QDataSet ds, int dim)` reduce the dataset's rank by reporting the mean of all the elements along a dimension.
`static QDataSet`	`reduceMean(QDataSet ds, int dim, ProgressMonitor mon)` reduce the dataset's rank by reporting the mean of all the elements along a dimension.
`static QDataSet`	`reduceMedian(QDataSet ds, int dim, ProgressMonitor mon)` reduce the dataset's rank by reporting the median of all the elements along a dimension.
`static QDataSet`	`reduceMin(QDataSet ds, int dim)` reduce the dataset's rank by reporting the min of all the elements along a dimension.
`static QDataSet`	`reduceMin(QDataSet ds, int dim, ProgressMonitor mon)` reduce the dataset's rank by reporting the min of all the elements along a dimension.
`static QDataSet`	`reduceSum(QDataSet ds, int dim)` reduce the dataset's rank by reporting the sum of all the valid elements along a dimension.
`static QDataSet`	`reform(java.lang.Object ds, int[] qube)`
`static QDataSet`	`reform(QDataSet ds)` Reshape the dataset to remove the first dimension with length 1, reducing its rank by 1.
`static QDataSet`	`reform(QDataSet ds, int[] qube)` change the dimensionality of the elements of the QUBE dataset.
`static QDataSet`	`reform(QDataSet ds, int nrec, int[] qube)` allow reform record-by-record, which comes up often.
`static WritableDataSet`	`removeFill(QDataSet ds)` remove the fill values from the rank 1 dataset, returning a smaller dataset.
`static QDataSet`	`removeIndeces(QDataSet vv, QDataSet indices)` remove the data at the indices from the rank 1 dataset.
`static WritableDataSet`	`removeValues(java.lang.Object ds, java.lang.Object indices)`
`static WritableDataSet`	`removeValues(QDataSet ds, QDataSet indices)` put fill data for these indices
`static WritableDataSet`	`removeValuesGreaterThan(java.lang.Object ds, java.lang.Object v)`
`static WritableDataSet`	`removeValuesGreaterThan(QDataSet ds, QDataSet v)` remove values in the dataset which are greater than the value.
`static WritableDataSet`	`removeValuesLessThan(java.lang.Object ds, java.lang.Object v)`
`static WritableDataSet`	`removeValuesLessThan(QDataSet ds, QDataSet v)` remove values in the dataset which are less than the value.
`static WritableDataSet`	`replicate(double val, int len0)` returns rank 1 dataset with value
`static WritableDataSet`	`replicate(double val, int len0, int len1)` returns rank 2 dataset filled with value
`static WritableDataSet`	`replicate(double val, int len0, int len1, int len2)` returns rank 3 dataset with filled with value.
`static WritableDataSet`	`replicate(double val, int len0, int len1, int len2, int len3)` returns rank 4 dataset with filled with value.
`static WritableDataSet`	`replicate(float val, int len0)` returns rank 1 dataset with value
`static WritableDataSet`	`replicate(float val, int len0, int len1)` returns rank 2 dataset filled with value
`static WritableDataSet`	`replicate(float val, int len0, int len1, int len2)` returns rank 3 dataset with filled with value.
`static WritableDataSet`	`replicate(int val, int len0)` returns rank 1 dataset with value
`static WritableDataSet`	`replicate(int val, int len0, int len1)` returns rank 2 dataset filled with value
`static WritableDataSet`	`replicate(int val, int len0, int len1, int len2)` returns rank 3 dataset with filled with value.
`static WritableDataSet`	`replicate(long val, int len0)` returns rank 1 dataset with value
`static WritableDataSet`	`replicate(long val, int len0, int len1)` returns rank 2 dataset filled with value
`static WritableDataSet`	`replicate(long val, int len0, int len1, int len2)` returns rank 3 dataset with filled with value.
`static MutablePropertyDataSet`	`replicate(QDataSet val, int len0)` returns a rank N+1 dataset by repeating the rank N dataset, so all records will have the same value.
`static MutablePropertyDataSet`	`replicate(QDataSet val, int len0, int len1)` returns a rank N+2 dataset by repeating the rank N dataset, so all records will have the same value.
`static WritableDataSet`	`replicate(short val, int len0)` returns rank 1 dataset with value
`static WritableDataSet`	`replicate(short val, int len0, int len1)` returns rank 2 dataset filled with value
`static WritableDataSet`	`replicate(short val, int len0, int len1, int len2)` returns rank 3 dataset with filled with value.
`static QDataSet`	`rescale(QDataSet data, QDataSet min, QDataSet max)` calculate the range of data, then rescale it so that the smallest values becomes min and the largest values becomes max.
`static QDataSet`	`rescaleRange(QDataSet dr, double min, double max)` returns rank 1 QDataSet range relative to range "dr", where 0.
`static QDataSet`	`rescaleRangeLogLin(QDataSet dr, double min, double max)` like rescaleRange, but look at log/lin flag.
`static QDataSet`	`reverse(java.lang.Object ds)`
`static QDataSet`	`reverse(QDataSet ds)` returns the reverse of the rank 1 dataset.
`static QDataSet`	`rgbColorDataset(QDataSet red, QDataSet green, QDataSet blue)` create a dataset of RGB colors.
`static QDataSet`	`ripples(int len0)` rank 1 dataset for demos and testing.
`static QDataSet`	`ripples(int len0, int len1)` rank 2 dataset for demos and testing.
`static QDataSet`	`ripples(int len0, int len1, int len2)` rank 3 dataset for demos and testing.
`static QDataSet`	`ripples(int len0, int len1, int len2, int len3)` rank 4 dataset for demos and testing.
`static QDataSet`	`ripplesJoinSpectrogramTimeSeries(int len)` return fake position data for testing result is rank 3 bundle [3,len/3,27*]
`static QDataSet`	`ripplesPitchAngleDistribution()` return an example of a QDataSet containing a pitch angle distribution.
`static QDataSet`	`ripplesSpectrogramTimeSeries(int len)` return fake position data for testing result is rank 2 bundle [len,27]
`static QDataSet`	`ripplesTimeSeries(int len)` return fake rank 1 data timeseries for testing
`static QDataSet`	`ripplesVectorTimeSeries(int len)` return fake position data for testing.
`static QDataSet`	`ripplesWaveformTimeSeries(int len)` return fake waveform data for testing result is rank 2 bundle [len,512]
`static double`	`round(double x)` for Jython, we handle this because the double isn't coerced.
`static double`	`round(double x, int ndigits)` for Jython, we handle this because the double isn't coerced.
`static QDataSet`	`round(java.lang.Object x)`
`static QDataSet`	`round(java.lang.Object ds1, int ndigits)` element-wise round function, which rounds to i decimal places.
`static QDataSet`	`round(QDataSet ds1)` element-wise round function.
`static QDataSet`	`round(QDataSet ds1, int ndigits)` element-wise round function, which rounds to i decimal places.
`static java.lang.String`	`safeName(java.lang.String suggest)` made a Java-style identifier from the provided string See Autoplot/src/scripts/safeName.jy which demonstrates this.
`static java.lang.String`	`saferName(java.lang.String suggest)` extra spaces and pipes cause problems in the Operations text field.
`static QDataSet`	`sawtooth(QDataSet t)` generates a sawtooth from the tags, where a peak occurs with a period 2*PI.
`static QDataSet`	`setDepend0Cadence(QDataSet ds, java.lang.String arg)` set the cadence property for the DEPEND_0 data.
`static QDataSet`	`setDepend1Cadence(QDataSet ds, java.lang.String arg)` set the cadence property for the DEPEND_1 data.
`static QDataSet`	`setNominalRange(QDataSet ds, java.lang.String arg)` set the metadata property LIMITS_NOMINAL_MIN and LIMITS_NOMINAL_MAX, which are displayed in the series renderer as a yellow line.
`static QDataSet`	`setValidRange(QDataSet ds, java.lang.String arg)` assert that the valid data is within the given range like "10 to 50000", where the range is parsed using DatumRangeUtil.parseDatumRange.
`static QDataSet`	`setWarnRange(QDataSet ds, java.lang.String arg)` set the metadata property LIMITS_WARN_MIN and LIMITS_WARN_MAX, which are displayed in the series renderer as a red line.
`static QDataSet`	`shortarr(int len0)` create a dataset filled with zeros, stored in 2-byte signed shorts.
`static QDataSet`	`shortarr(int len0, int len1)` create a rank 2 dataset filled with zeros, stored in 2-byte shorts.
`static QDataSet`	`shortarr(int len0, int len1, int len2)` create a rank 3 dataset filled with zeros, stored in 2-byte shorts.
`static QDataSet`	`shuffle(java.lang.Object ds)` returns a rank 1 dataset of indices that shuffle the rank 1 dataset ds.
`static QDataSet`	`shuffle(QDataSet ds)` returns a rank 1 dataset of indices that shuffle the rank 1 dataset ds.
`static double`	`signum(double x)`
`static QDataSet`	`signum(java.lang.Object x)`
`static QDataSet`	`signum(QDataSet ds1)` Returns the signum function of the argument; zero if the argument is zero, 1.0 if the argument is greater than zero, -1.0 if the argument is less than zero.
`static double`	`sin(double ds)` return the sin of the real number, which is to be in radians.
`static QDataSet`	`sin(java.lang.Object ds)`
`static QDataSet`	`sin(QDataSet ds)` element-wise sin.
`static double`	`sinh(double ds)`
`static QDataSet`	`sinh(java.lang.Object ds)`
`static QDataSet`	`sinh(QDataSet ds)` element-wise sinh.
`static int[]`	`size(QDataSet ds)` returns the number of elements in each index.
`static QDataSet`	`slice0(QDataSet ds, int idx)` returns the slice at the given slice location.
`static QDataSet`	`slice0(QDataSet ds, QDataSet sliceds)` returns the slice at the given slice location.
`static QDataSet`	`slice1(QDataSet ds, int idx)` returns the slice at the given slice location.
`static QDataSet`	`slice1(QDataSet ds, QDataSet sliceds)` returns the slice at the given slice location.
`static QDataSet`	`slice2(QDataSet ds, int idx)` returns the slice at the given slice location.
`static QDataSet`	`slice2(QDataSet ds, QDataSet sliceds)` returns the slice at the given slice location.
`static QDataSet`	`slice3(QDataSet ds, int idx)` returns the slice at the given slice location.
`static QDataSet`	`slice3(QDataSet ds, QDataSet sliceds)` returns the slice at the given slice location.
`static QDataSet`	`slices(QDataSet ds, java.lang.Object... args)` slice each dimension in one call, so that chaining isn't required to slice multiple dimensions at once.
`static QDataSet`	`smooth(java.lang.Object ds, int size)`
`static QDataSet`	`smooth(QDataSet ds, int size)` run boxcar average over the dataset, returning a dataset of same geometry.
`static QDataSet`	`smooth1(QDataSet ds, int size)` smooth over the first dimension (not the zeroth).
`static QDataSet`	`smooth2d(QDataSet ds, int n0, int n1)` smooth in both the first and second dimensions.
`static QDataSet`	`smoothFit(java.lang.Object xx, java.lang.Object yy, int size)`
`static QDataSet`	`smoothFit(QDataSet xx, QDataSet yy, int size)` run boxcar average over the dataset, returning a dataset of same geometry.
`static QDataSet`	`sort(java.lang.Object ds)`
`static QDataSet`	`sort(QDataSet ds)` returns a rank 1 dataset of indices that sort the rank 1 dataset ds.
`static QDataSet`	`sortInTime(QDataSet ds)` pick out the timetags and sort the data based on these.
`static double`	`sqrt(double ds1)`
`static QDataSet`	`sqrt(java.lang.Object ds1)`
`static QDataSet`	`sqrt(QDataSet ds)` element-wise sqrt.
`static QDataSet`	`square(QDataSet t)` generates a square from the tags, where a the signal is 1 from 0-PI, 0 from PI-2*PI, etc.
`static QDataSet`	`stddev(java.lang.Object o)` standard deviation function.
`static QDataSet`	`stddev(QDataSet ds)` standard deviation function.
`static QDataSet`	`strarr(int len0)` return a QDataSet containing empty strings.
`static QDataSet`	`strarr(int len0, int len1)` return a rank 2 QDataSet containing empty strings.
`static QDataSet`	`subset(QDataSet ds, QDataSet w)` return the data at the indices given.
`static QDataSet`	`subtract(java.lang.Object ds1, java.lang.Object ds2)` subtract one dataset from another, using dataset to convert the arguments.
`static QDataSet`	`subtract(QDataSet ds1, QDataSet ds2)` subtract one dataset from another.
`static java.util.List<QDataSet>`	`synchronize(QDataSet dsTarget, QDataSet... dsSources)` The first dataset's timetags are used to synchronize the list of datasets to a set of common timetags.
`static QDataSet`	`synchronize(QDataSet ds1, QDataSet ds)` The first dataset's timetags are used to synchronize the second dataset to a set of common timetags.
`static java.util.List<QDataSet>`	`synchronizeNN(QDataSet dsTarget, QDataSet... dsSources)` The first dataset's timetags are used to synchronize the list of datasets to a set of common timetags, using nearest neighbor interpolation.
`static QDataSet`	`synchronizeNN(QDataSet ds1, QDataSet ds)` The first dataset's timetags are used to synchronize the second dataset to a set of common timetags, using nearest neighbor interpolation.
`static QDataSet`	`synchronizeOne(QDataSet dsTarget, QDataSet dsSource)` The first dataset's timetags are used to synchronize the single dataset to common timetags.
`static MutablePropertyDataSet`	`taggen(double base, double dcadence, int len0, Units units)` creates tags.
`static double`	`tan(double ds)` return the trigonometric tangent of the real number in radians.
`static QDataSet`	`tan(java.lang.Object ds)`
`static QDataSet`	`tan(QDataSet ds)` element-wise trigonometric tangent (tan) function
`static double`	`tanh(double ds)`
`static QDataSet`	`tanh(java.lang.Object ds)`
`static QDataSet`	`tanh(QDataSet ds)` element-wise tanh.
`static QDataSet`	`timegen(java.lang.String baseTime, java.lang.String cadence, int len0)` returns rank 1 dataset with values that are times.
`static QDataSet`	`timeShift(QDataSet ds, Datum delta)` Shift the DEPEND_0 or the time column of a rank 2 dataset by the amount.
`static QDataSet`	`toDegrees(java.lang.Object ds)`
`static QDataSet`	`toDegrees(QDataSet ds)` convert the data to degrees by multiplying each element by 180/PI.
`static QDataSet`	`toRadians(java.lang.Object ds)`
`static QDataSet`	`toRadians(QDataSet ds)` convert the data to radians by multiplying each element by PI/180.
`static double`	`total(java.lang.Object ds1)` return the total of all the elements in the object which can be converted to a dataset.
`static double`	`total(QDataSet ds)` return the total of all the elements in the dataset.
`static QDataSet`	`total(QDataSet ds, int dim)` reduce the dataset's rank by totaling all the elements along a dimension.
`static QDataSet`	`total(QDataSet ds, int dim, ProgressMonitor mon)` reduce the dataset's rank by totaling all the elements along a dimension.
`static double`	`total(QDataSet ds, ProgressMonitor mon)` return the total of all the elements in the dataset.
`static QDataSet`	`toTimeDataSet(java.lang.Object years, java.lang.Object mons, java.lang.Object days, java.lang.Object hour, java.lang.Object minute, java.lang.Object second, java.lang.Object nano)`
`static QDataSet`	`toTimeDataSet(QDataSet years, QDataSet mons, QDataSet days, QDataSet hour, QDataSet minute, QDataSet second, QDataSet nano)` return a rank 1 dataset of times.
`static QDataSet`	`transpose(java.lang.Object ds)`
`static QDataSet`	`transpose(QDataSet ds)` transpose the rank 2 or rank 1 dataset.
`static QDataSet`	`triangulate(QDataSet xx, QDataSet yy)` return a triangle tesselation of the space identified by rank 1 xx and yy.
`static QDataSet`	`trim(int dim, QDataSet ds, int st, int en)` trim the qube dataset on any of its indices, for example ds[:,:,5:10] would use this operation.
`static QDataSet`	`trim(int dim, QDataSet ds, QDataSet st, QDataSet en)` trim the qube dataset on any of its indices, for example ds[:,:,5:10] would use this operation.
`static QDataSet`	`trim(QDataSet ds, DatumRange dr)` return the trim of the dataset ds where its DEPEND_0 (typically xtags) are within the range dr.
`static QDataSet`	`trim(QDataSet ds, int st, int en)` trim the dataset to the indices on the zeroth dimension.
`static QDataSet`	`trim(QDataSet ds, java.lang.Object odr)` return the trim of the dataset ds where its DEPEND_0 (typically xtags) are within the range dr.
`static QDataSet`	`trim(QDataSet ds, QDataSet st, QDataSet en)` return the trim of the dataset ds where its DEPEND_0 (typically xtags) are within the range dr.
`static QDataSet`	`trim1(QDataSet ds, int st, int en)` trim on the first (not zeroth) dimension.
`static QDataSet`	`trim1(QDataSet ds, QDataSet st, QDataSet en)` return the trim of the dataset ds where its DEPEND_1 (typically ytags) are within the range dr.
`static QDataSet`	`unbundle(QDataSet ds, int i)` Extract a bundled dataset from a bundle of datasets.
`static QDataSet`	`unbundle(QDataSet ds, java.lang.String name)` Extract the named bundled dataset.
`static QDataSet`	`unbundleBins(QDataSet ds, int i)` convenient method for getting the times from an events dataset, this unbundles the startTimes at i and the stopTimes at i+1 to a bins dataset.
`static QDataSet`	`uniq(QDataSet ds)` Return the unique indices from the rank 1 dataset.
`static QDataSet`	`uniq(QDataSet ds, QDataSet sort)` Return the unique indices from the rank 1 dataset, using sort to resort the indices.
`static QDataSet`	`uniqValues(QDataSet ds, QDataSet sort)` return the unique elements from the dataset.
`static QDataSet`	`unwrap(QDataSet ds, double discont)` SciPy's unwrap function, used in demo of hilbertSciPy, which unwraps a function that exists in a modulo space so that the differences are minimal.
`static QDataSet`	`valid(QDataSet ds)` returns a dataset with zero where the data is invalid, and positive non-zero where the data is valid.
`static QDataSet`	`variance(java.lang.Object o)` variance function is the square of the stddev.
`static QDataSet`	`variance(QDataSet ds)` variance function is the square of the stddev.
`static QDataSet`	`where(java.lang.Object ds)`
`static QDataSet`	`where(QDataSet ds)` returns a dataset containing the indices of where the dataset is non-zero.
`static QDataSet`	`whereR1(QDataSet ds)` returns a dataset containing the indices of where the dataset is non-zero.
`static QDataSet`	`whereSequence(QDataSet ds, QDataSet seq)` return a list of indices, similar to the where result.
`static QDataSet`	`windowFunction(Ops.FFTFilterType filt, int len)` return a dataset for the given filter type.
`static QDataSet`	`windowFunction(java.lang.String type, int len)` return a dataset for the given filter type, added to support use in Jython.
`static QDataSet`	`within(java.lang.Object ds, java.lang.Object bounds)` return non-zero where the data in ds are within the bounds.
`static QDataSet`	`within(QDataSet ds, QDataSet bounds)` return non-zero where the data in ds are within the bounds.
`static QDataSet`	`withinSet(QDataSet ds, QDataSet set)` returns 1 where the dataset contains elements within the set, 0 where elements are not within the set.
`static QDataSet`	`without(java.lang.Object ds, java.lang.Object bounds)` return non-zero where the data in ds are outside of the bounds.
`static QDataSet`	`without(QDataSet ds, QDataSet bounds)` return non-zero where the data in ds are outside of the bounds.
`static QDataSet`	`xtags(QDataSet ds)` return the xtags of the dataset.
`static QDataSet`	`ytags(QDataSet ds)` return the ytags of the dataset.
`static WritableDataSet`	`zeros(int len0)` return new dataset filled with zeros.
`static WritableDataSet`	`zeros(int len0, int len1)` return new dataset filled with zeros.
`static WritableDataSet`	`zeros(int len0, int len1, int len2)` return new dataset filled with zeros.
`static WritableDataSet`	`zeros(int len0, int len1, int len2, int len3)` return new dataset filled with zeros.
`static WritableDataSet`	`zeros(QDataSet ds)` return a new dataset filled with zeroes that has the same geometry as the given dataset.

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

Field Detail
- PI
```
public static final double PI
```
  closest double to π or TAU/2
  
  See Also:
  
  Math.PI, Constant Field Values
- TAU
```
public static final double TAU
```
  closest double to τ or 2*PI
  
  See Also:
  
  Math.PI, Constant Field Values
- E
```
public static final double E
```
  the closest double to e, the base of natural logarithms.
  
  See Also:
  
  Math.E, Constant Field Values

Method Detail

applyUnaryOp
```
public static MutablePropertyDataSet applyUnaryOp(QDataSet ds1,
                                                  Ops.UnaryOp op)
```
apply the unary operation (such as "cos") to the dataset, propagating DEPEND_0 through DEPEND_3 and other appropriate metadata.

Parameters:

ds1 - the argument

op - the operation for each element.

Returns:

the result the the same geometry.

applyUnaryOp
```
public static MutablePropertyDataSet applyUnaryOp(java.lang.Object ds1,
                                                  Ops.UnaryOp op)
```
apply the unary operation (such as "cos") to the dataset, propagating DEPEND_0 through DEPEND_3 and other appropriate metadata.

Parameters:

ds1 - the argument which can be converted to a dataset.

op - the operation for each element.

Returns:

the result the the same geometry.

applyBinaryOp
```
public static MutablePropertyDataSet applyBinaryOp(QDataSet ds1,
                                                   QDataSet ds2,
                                                   Ops.BinaryOp op)
```
apply the binary operator element-for-element of the two datasets, minding dataset geometry, fill values, etc. The two datasets are coerced to compatible geometry, if possible (e.g.Temperature[Time]+2deg), using CoerceUtil.coerce. Structural metadata such as DEPEND_0 are preserved where this is reasonable, and dimensional metadata such as UNITS are dropped.

Parameters:

ds1 - the first argument

ds2 - the second argument

op - binary operation for each pair of elements

Returns:

the result with the same geometry as the pair.

applyBinaryOp

public static MutablePropertyDataSet applyBinaryOp(java.lang.Object ds1,
                                                   java.lang.Object ds2,
                                                   Ops.BinaryOp op)

As with applyBinaryOp, but promote compatible objects to QDataSet first.

Parameters:: ds1 - the first operand; ds2 - the second operand; op - binary operation for each pair of elements
Returns:: the result with the same geometry as the pair.
See Also:: dataset(java.lang.Object)

equalProperties
```
public static java.util.HashMap<java.lang.String,java.lang.Object> equalProperties(java.util.Map<java.lang.String,java.lang.Object> m1,
                                                                                   java.util.Map<java.lang.String,java.lang.Object> m2)
```
returns the subset of two groups of properties that are equal, so these may be preserved through operations.

Parameters:

m1 - map of dataset properties, including DEPEND properties.

m2 - map of dataset properties, including DEPEND properties.

Returns:

the subset of two groups of properties that are equal

add
```
public static QDataSet add(QDataSet ds1,
                           QDataSet ds2)
```
add the two datasets which have the compatible geometry and units. For example,
```
ds1=timegen('2014-10-15T07:23','60s',300)
ds2=dataset('30s')
print add(ds1,ds2)
```
The units handling is quite simple, and this will soon change. Note that the Jython operator + is overloaded to this method.
Parameters:

ds1 - a rank N dataset

ds2 - a rank M dataset with compatible geometry

Returns:

the element-wise sum of the two datasets.

See Also:

addGen, which shows how units are resolved., https://sourceforge.net/p/autoplot/bugs/2558/, which shows the issues with CDF_TT2000.

add
```
public static QDataSet add(java.lang.Object ds1,
                           java.lang.Object ds2)
```
add the two datasets which have the compatible geometry and units.

Parameters:

ds1 - QDataSet, array, string, scalar argument

ds2 - QDataSet, array, string, scalar argument with compatible geometry.

Returns:

the element-wise sum of the two datasets.

See Also:

dataset(java.lang.Object)

add
```
public static QDataSet add(QDataSet ds1,
                           QDataSet ds2,
                           QDataSet ds3)
```
three-argument add is provided as a convenience for environments (like Java and the Mash-up tool in Autoplot) where add is not an in-fix operator. For example, when taking the magnitude this allows for sqrt( add( pow( ds1,2), pow( ds2,2), pow( ds3,2) ) ) which is more readable than sqrt( add( add( pow( ds1,2), pow( ds2,2) ), pow( ds3,2) ) ) )

Parameters:

ds1 - a rank N dataset

ds2 - a rank N dataset or one with compatible geometry

ds3 - a rank N dataset or one with compatible geometry

Returns:

the sum

subtract
```
public static QDataSet subtract(QDataSet ds1,
                                QDataSet ds2)
```
subtract one dataset from another.

Parameters:

ds1 - a rank N dataset

ds2 - a rank M dataset with compatible geometry

Returns:

the element-wise difference of the two datasets.

subtract
```
public static QDataSet subtract(java.lang.Object ds1,
                                java.lang.Object ds2)
```
subtract one dataset from another, using dataset to convert the arguments.

Parameters:

ds1 - QDataSet, array, string, scalar argument

ds2 - QDataSet, array, string, scalar argument with compatible geometry

Returns:

the element-wise difference of the two datasets.

negate
```
public static QDataSet negate(QDataSet ds1)
```
return a dataset with each element negated. If units are specified, Units must be ratiometric units, like "5 km" or dimensionless, and not ordinal or time location units.

Parameters:

ds1 -

Returns:

See Also:

copysign(org.das2.qds.QDataSet, org.das2.qds.QDataSet), signum(org.das2.qds.QDataSet)

negate

public static QDataSet negate(java.lang.Object ds1)

magnitude
```
public static QDataSet magnitude(QDataSet ds)
```
return the magnitudes of vectors in a rank 1 or greater dataset (typically rank 2). The last index should be the cartesian dimension. For example,
```
 ds= getDataSet('http://autoplot.org/data/autoplot.cdf?BGSM') # BGSM[Epoch=24,cart=3]
 m= magnitude(ds)
```
For rank 0, this just returns the absolute value, but with the same units.
Parameters:

ds - dataset of Rank N.

Returns:

dataset of Rank N-1.

See Also:

abs(org.das2.qds.QDataSet)

magnitude

public static QDataSet magnitude(java.lang.Object ds1)

total
```
public static double total(QDataSet ds)
```
return the total of all the elements in the dataset. If there are invalid measurements, then fill is returned. Does not support BINS or BUNDLE dimensions.

Parameters:

ds -

Returns:

the unweighted total of the dataset, or -1e31 if fill was encountered.

See Also:

total, which should be used instead.

total
```
public static double total(QDataSet ds,
                           ProgressMonitor mon)
```
return the total of all the elements in the dataset. If there are invalid measurements, then fill is returned. Does not support BINS or BUNDLE dimensions.

Parameters:

ds -

mon - progress monitor

Returns:

the unweighted total of the dataset, or -1e31 if fill was encountered.

See Also:

total, which should be used instead.

total
```
public static double total(java.lang.Object ds1)
```
return the total of all the elements in the object which can be converted to a dataset.

Parameters:

ds1 - the object which can be converted to a dataset.

Returns:

See Also:

total(org.das2.qds.QDataSet)

total
```
public static QDataSet total(QDataSet ds,
                             int dim)
```
reduce the dataset's rank by totaling all the elements along a dimension. Only QUBEs are supported presently.

Parameters:

ds - rank N qube dataset. N=1,2,3,4

dim - zero-based index number.

Returns:

rank N-1 dataset.

See Also:

total(ds) total, which is an earlier deprecated routine., reduceSum, which skips invalid data.

total
```
public static QDataSet total(QDataSet ds,
                             int dim,
                             ProgressMonitor mon)
                      throws CancelledOperationException
```
reduce the dataset's rank by totaling all the elements along a dimension. Only QUBEs are supported presently.

Parameters:

ds - rank N qube dataset. N=1,2,3,4

dim - zero-based index number.

mon - progress monitor.

Returns:

the rank N-1 qube dataset.

Throws:

CancelledOperationException

reduceMax
```
public static QDataSet reduceMax(QDataSet ds,
                                 int dim)
```
reduce the dataset's rank by reporting the max of all the elements along a dimension. Only QUBEs are supported presently.

Parameters:

ds - rank N qube dataset.

dim - zero-based index number.

Returns:

rank N-1 dataset.

reduceMax
```
public static QDataSet reduceMax(QDataSet ds,
                                 int dim,
                                 ProgressMonitor mon)
```
reduce the dataset's rank by reporting the max of all the elements along a dimension. Only QUBEs are supported presently.

Parameters:

ds - rank N qube dataset.

dim - zero-based index number.

mon - progress monitor

Returns:

rank N-1 dataset.

See Also:

reduceMin(org.das2.qds.QDataSet, int, org.das2.util.monitor.ProgressMonitor), reduceMean(org.das2.qds.QDataSet, int, org.das2.util.monitor.ProgressMonitor), extent(org.das2.qds.QDataSet), extent(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

reduceSum
```
public static QDataSet reduceSum(QDataSet ds,
                                 int dim)
```
reduce the dataset's rank by reporting the sum of all the valid elements along a dimension. The property "WEIGHTS" will contain the sum of the weights. Only QUBEs are supported presently. This is like the function "total," but skips invalid values.

Parameters:

ds - rank N qube dataset.

dim - zero-based index number.

Returns:

rank N-1 dataset.

See Also:

total(org.das2.qds.QDataSet, int)

reduceMin
```
public static QDataSet reduceMin(QDataSet ds,
                                 int dim)
```
reduce the dataset's rank by reporting the min of all the elements along a dimension. Only QUBEs are supported presently.

Parameters:

ds - rank N qube dataset.

dim - zero-based index number.

Returns:

rank N-1 dataset.

reduceMin
```
public static QDataSet reduceMin(QDataSet ds,
                                 int dim,
                                 ProgressMonitor mon)
```
reduce the dataset's rank by reporting the min of all the elements along a dimension. Only QUBEs are supported presently.

Parameters:

ds - rank N qube dataset.

dim - zero-based index number.

mon - progress monitor

Returns:

rank N-1 dataset.

reduceMean
```
public static QDataSet reduceMean(QDataSet ds,
                                  int dim)
```
reduce the dataset's rank by reporting the mean of all the elements along a dimension. Only QUBEs are supported presently. Note this does not contain code that would remove large offsets from zero when making the average, so the number of points is limited.

Parameters:

ds - rank N qube dataset.

dim - zero-based index number.

Returns:

rank N-1 qube dataset.

reduceMean
```
public static QDataSet reduceMean(QDataSet ds,
                                  int dim,
                                  ProgressMonitor mon)
                           throws CancelledOperationException
```
reduce the dataset's rank by reporting the mean of all the elements along a dimension. Only QUBEs are supported presently. Note this does not contain code that would remove large offsets from zero when making the average, so the number of points is limited.

Parameters:

ds - rank N qube dataset.

dim - zero-based index number.

mon - progress monitor.

Returns:

rank N-1 qube dataset

Throws:

CancelledOperationException

reduceMedian
```
public static QDataSet reduceMedian(QDataSet ds,
                                    int dim,
                                    ProgressMonitor mon)
                             throws CancelledOperationException
```
reduce the dataset's rank by reporting the median of all the elements along a dimension. Only QUBEs are supported presently. Note the weights reported are the totals of the data going in to each median, typically the number of measurements compared (when all weights are 0 or 1).

Parameters:

ds - rank N qube dataset.

dim - zero-based index number.

mon - progress monitor.

Returns:

rank N-1 qube dataset

Throws:

CancelledOperationException

reduceBins
```
public static QDataSet reduceBins(QDataSet dep1)
```
reduce each bin to its center. If the spacing is log, then geometric centers are used.

Parameters:

dep1 - rank 2 [N,2] bins dataset, where bins are min,max boundaries.

Returns:

rank 1 N element dataset

binData
```
public static QDataSet binData(QDataSet ds,
                               DatumRange bin)
```
increase the rank 1 data into rank 2 data by binning data. For example, byOrbit= binData( density, datumRange( 'orbit:rbspa-pp:3' ) )

Parameters:

ds - rank 1 data with (time) tags

bin - datum range which is an example range

Returns:

rank 2 bins.

normalize
```
public static QDataSet normalize(QDataSet ds)
```
normalize the data so that the max is 1, where we normalize by the biggest value, so that the maximum is one.

Parameters:

ds -

Returns:

dataset with the same geometry as ds.

normalize
```
public static QDataSet normalize(QDataSet ds,
                                 int dim)
```
normalize the data so that the max at a row or column is 1, where we have normalized by the biggest value along a dimension. For example, normalize( ds, 1 ) will produce a result where each ds[i,:] will have a max of 1.0.

Parameters:

ds - the dataset

dim - the dimension to normalize

Returns:

dataset with the same geometry as ds.

See Also:

reduceMax(org.das2.qds.QDataSet, int)

decimate
```
public static QDataSet decimate(QDataSet ds)
```
reduce the size of the data by keeping every 10th measurement.

Parameters:

ds - a qube dataset.

Returns:

a decimated qube dataset.

See Also:

decimate(org.das2.qds.QDataSet, int)

decimate
```
public static QDataSet decimate(QDataSet ds,
                                int m)
```
reduce the size of the data by keeping every nth measurement (subsample), starting at the 0th measurement.

Parameters:

ds - rank 1 or more dataset.

m - the decimation factor, e.g. 2 is every other measurement.

Returns:

decimate
```
public static QDataSet decimate(QDataSet ds,
                                int m,
                                int n)
```
reduce the size of the data by keeping every nth measurement (subsample).

Parameters:

ds - rank 2 or more dataset.

m - the decimation factor for the zeroth index, e.g. 2 is every other measurement.

n - the decimation factor for the first index, e.g. 2 is every other measurement.

Returns:

new dataset which is ds.length()/m by ds.length(0)/n.

collapse0
```
public static QDataSet collapse0(QDataSet fillDs,
                                 int st,
                                 int en)
```
this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the zeroth dimension. collapse0( ds[30,20] ) → ds[20]

Parameters:

fillDs -

st - the start index

en - the non-inclusive end index

Returns:

the averaged dataset

collapse0
```
public static QDataSet collapse0(QDataSet fillDs)
```
this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the zeroth dimension. collapse0( ds[30,20] ) → ds[20]

Parameters:

fillDs -

Returns:

the averaged dataset

collapse0R4
```
public static QDataSet collapse0R4(QDataSet ds,
                                   ProgressMonitor mon)
```
Collapse the rank 4 dataset on the zeroth index.

Parameters:

ds - rank 4 dataset

mon -

Returns:

rank 3 dataset

See Also:

OperationsProcessor.sprocess(java.lang.String, org.das2.qds.QDataSet, org.das2.util.monitor.ProgressMonitor)

collapse1R4
```
public static QDataSet collapse1R4(QDataSet ds,
                                   ProgressMonitor mon)
```
Collapse the rank 4 dataset on the first index.

Parameters:

ds - rank 4 dataset

mon -

Returns:

rank 3 dataset

See Also:

OperationsProcessor.sprocess(java.lang.String, org.das2.qds.QDataSet, org.das2.util.monitor.ProgressMonitor)

collapse1
```
public static QDataSet collapse1(QDataSet ds)
```
this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the first dimension collapse1( ds[30,20] ) → ds[30]

Parameters:

ds -

Returns:

the averaged dataset

collapse2
```
public static QDataSet collapse2(QDataSet fillDs)
```
this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the first dimension collapse2( ds[30,20,10,5] ) → ds[30,20,5]

Parameters:

fillDs -

Returns:

the averaged dataset

collapse2R4
```
public static QDataSet collapse2R4(QDataSet ds,
                                   ProgressMonitor mon)
```
Collapse the rank 4 dataset on the second index.

Parameters:

ds - rank 4 dataset

mon -

Returns:

rank 3 dataset

See Also:

OperationsProcessor.sprocess(java.lang.String, org.das2.qds.QDataSet, org.das2.util.monitor.ProgressMonitor)

collapse3
```
public static QDataSet collapse3(QDataSet fillDs)
```
this is introduced to mimic the in-line function which reduces the dimensionality by averaging over the first dimension collapse3( ds[30,20,10,5] ) → ds[30,20,10]

Parameters:

fillDs -

Returns:

the averaged dataset

collapse3R4
```
public static QDataSet collapse3R4(QDataSet ds,
                                   ProgressMonitor mon)
```
Collapse the rank 4 dataset on the third index.

Parameters:

ds - rank 4 dataset

mon -

Returns:

rank 3 dataset

See Also:

OperationsProcessor.sprocess(java.lang.String, org.das2.qds.QDataSet, org.das2.util.monitor.ProgressMonitor)

trim
```
public static QDataSet trim(QDataSet ds,
                            int st,
                            int en)
```
trim the dataset to the indices on the zeroth dimension. Note the trim function can also be called directly.

Parameters:

ds - the dataset to be trimmed.

st - the start index

en - the non-inclusive end index

Returns:

trim
```
public static QDataSet trim(QDataSet ds,
                            DatumRange dr)
```
return the trim of the dataset ds where its DEPEND_0 (typically xtags) are within the range dr.

Parameters:

ds - a rank 1 or greater dataset

dr - a range in the same units as ds

Returns:

the subset of the data.

See Also:

trim(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

trim
```
public static QDataSet trim(QDataSet ds,
                            java.lang.Object odr)
```
return the trim of the dataset ds where its DEPEND_0 (typically xtags) are within the range dr.

Parameters:

ds - a rank 1 or greater dataset

odr - an object which can be interpretted as a range.

Returns:

the subset of the data.

See Also:

trim(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

trim
```
public static QDataSet trim(QDataSet ds,
                            QDataSet st,
                            QDataSet en)
```
return the trim of the dataset ds where its DEPEND_0 (typically xtags) are within the range dr. For example, if ds was 7-days from 2014-01-01 through 2014-01-07, and st=2014-01-02 and en=2014-01-03 then just the records collected on this one day would be returned.

Parameters:

ds - the dataset to be trimmed, with a rank 1 monotonic DEPEND_0.

st - rank 0 min value

en - rank 0 max value

Returns:

the subset of the data.

See Also:

slice0(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

trim
```
public static QDataSet trim(int dim,
                            QDataSet ds,
                            int st,
                            int en)
```
trim the qube dataset on any of its indices, for example ds[:,:,5:10] would use this operation.

Parameters:

dim - the index (0, 1, 2, 3, or 4) on which to trim.

ds - the dataset, which must be a qube.

st - the first index, inclusive

en - the last index, exclusive

Returns:

the trimmed dataset with same number of dimensions and fewer indices in one dimension.

trim
```
public static QDataSet trim(int dim,
                            QDataSet ds,
                            QDataSet st,
                            QDataSet en)
```
trim the qube dataset on any of its indices, for example ds[:,:,5:10] would use this operation.

Parameters:

dim - the index (0, 1, 2, 3, or 4) on which to trim.

ds - the dataset, which must be a qube.

st - rank 0 min value

en - rank 0 max value

Returns:

the trimmed dataset with same number of dimensions and fewer indices in one dimension.

trim1
```
public static QDataSet trim1(QDataSet ds,
                             QDataSet st,
                             QDataSet en)
```
return the trim of the dataset ds where its DEPEND_1 (typically ytags) are within the range dr. For example, if ds was frequencies from 10 Hz to 1e8 Hz, trim1( ds, 100Hz, 1000Hz ) would return just the data in this range.

Parameters:

ds - the dataset to be trimmed, with a rank 1 monotonic DEPEND_1.

st - rank 0 min value

en - rank 0 max value

Returns:

the subset of the data.

See Also:

slice1(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

trim1
```
public static QDataSet trim1(QDataSet ds,
                             int st,
                             int en)
```
trim on the first (not zeroth) dimension. This is to help with unbundling the timeranges from an events dataset.

Parameters:

ds - the dataset, rank 2 or greater

st - the first index

en - the last index, exclusive.

Returns:

the trimmed dataset.

setDepend0Cadence
```
public static QDataSet setDepend0Cadence(QDataSet ds,
                                         java.lang.String arg)
                                  throws java.text.ParseException
```
set the cadence property for the DEPEND_0 data. This allows scripts to assert that the data is collected at a given rate, and connecting lines should be drawn.
```
 xx= [ 0,2,4,6,8,10 ]
 yy= [ 1,1,2,2,3,3 ]
 ds= dataset(xx,yy)
 ds= setDepend0Cadence( ds, '2' )
 
```
Parameters:

ds - the data, which has a DEPEND_0 property.

arg - the string representing the cadence.

Returns:

the data, which now has a DEPEND_0 with the cadence.

Throws:

java.text.ParseException

setDepend1Cadence
```
public static QDataSet setDepend1Cadence(QDataSet ds,
                                         java.lang.String arg)
                                  throws java.text.ParseException
```
set the cadence property for the DEPEND_1 data. This allows scripts to assert that the data is collected at a given rate, and connecting lines should be drawn.
```
 xx= findgen(6)*2
 yy= findgen(6)*'10Hz'
 yy[3:]= yy[3:]+'2Hz'
 zz= randn(6,6)
 ds= dataset(xx,yy,zz)
 ds= setDepend1Cadence( ds, '12Hz' )
 plot( ds )
 
```
Parameters:

ds - the data, which has a DEPEND_1 property.

arg - the string representing the cadence.

Returns:

the data, which now has a DEPEND_1 with the cadence.

Throws:

java.text.ParseException

setValidRange
```
public static QDataSet setValidRange(QDataSet ds,
                                     java.lang.String arg)
                              throws java.text.ParseException
```
assert that the valid data is within the given range like "10 to 50000", where the range is parsed using DatumRangeUtil.parseDatumRange.

Parameters:

ds - the data

arg - the formatted range

Returns:

the data with the VALID_MIN and VALID_MAX properties set.

Throws:

java.text.ParseException - if the string cannot be parsed.

See Also:

DatumRangeUtil.parseDatumRange(java.lang.String)

setNominalRange
```
public static QDataSet setNominalRange(QDataSet ds,
                                       java.lang.String arg)
                                throws java.text.ParseException
```
set the metadata property LIMITS_NOMINAL_MIN and LIMITS_NOMINAL_MAX, which are displayed in the series renderer as a yellow line.

Parameters:

ds - a rank 1 dataset or rank 2 waveform

arg - the range, parsed as a datum range using the data units.

Returns:

the data with the METADATA tag added

Throws:

java.text.ParseException

setWarnRange
```
public static QDataSet setWarnRange(QDataSet ds,
                                    java.lang.String arg)
                             throws java.text.ParseException
```
set the metadata property LIMITS_WARN_MIN and LIMITS_WARN_MAX, which are displayed in the series renderer as a red line.

Parameters:

ds - a rank 1 dataset or rank 2 waveform

arg - the range, parsed as a datum range using the data units.

Returns:

the data with the METADATA tag added

Throws:

java.text.ParseException

sqrt
```
public static QDataSet sqrt(QDataSet ds)
```
element-wise sqrt. See Ops.pow to square a number.

Parameters:

ds - the dataset

Returns:

the square root of the dataset, which will contain NaN where the data is negative.

See Also:

pow(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

sqrt

public static double sqrt(double ds1)

sqrt

public static QDataSet sqrt(java.lang.Object ds1)

butterworth
```
public static QDataSet butterworth(QDataSet in,
                                   int order,
                                   Datum f,
                                   boolean lowp)
```
Perform Butterworth filter for high pass or low pass.

Parameters:

in - the rank 1 waveform or rank 2 waveform

order - the order of the filter (2,3,4)

f - the frequency, e.g. Units.hertz.createDatum(10)

lowp - true for low pass, false for high pass.

Returns:

the dataset in the same form.

butterworth
```
public static QDataSet butterworth(QDataSet in,
                                   int order,
                                   Datum flow,
                                   Datum fhigh,
                                   boolean pass)
```
Perform Butterworth filter for notch or band pass or band reject.

Parameters:

in - the rank 1 waveform or rank 2 waveform

order - the order of the filter (2,3,4)

flow - the lower band limit, e.g. Units.hertz.createDatum(10)

fhigh - the higher band limit, e.g. Units.hertz.createDatum(20)

pass - true for band pass, false for band reject.

Returns:

the dataset in the same form.

cubicRoot
```
public static QDataSet cubicRoot(QDataSet coefficients)
```
Solves each of a set of cubic equations of the form: a*x^3 + b*x^2 + c*x + d = 0. Takes a rank 2 dataset with each equation across the first dimension and coefficients of each equation across the second.

Parameters:

coefficients - Set of all coefficients.

Returns:

Roots of each equation. Double.NaN is returned for complex roots.

cubicRoot
```
public static double[] cubicRoot(double a,
                                 double b,
                                 double c,
                                 double d)
                          throws java.lang.ArithmeticException
```
Enter the coefficients for a cubic of the form: a*x^3 + b*x^2 + c*x + d = 0. Based on the method described at http://www.1728.org/cubic2.htm.

Parameters:

a - Coefficient of x^3.

b - Coefficient of x^2.

c - Coefficient of x.

d - Constant.

Returns:

Array containing 3 roots. NaN will be returned for imaginary roots.

Throws:

java.lang.ArithmeticException

abs
```
public static QDataSet abs(QDataSet ds1)
```
element-wise abs. For vectors, this returns the length of each element. Note Jython conflict needs to be resolved. Note the result of this will have dimensionless units, and see magnitude for the more abstract operator. For ratio-type units (Stevens) like "kms", the unit is preserved.

Parameters:

ds1 - the dataset

Returns:

dataset with the same geometry

See Also:

magnitude(ds), which preserves the sign.

abs
```
public static long abs(long x)
```
return the abs of the long, to support Jython properly.

Parameters:

x - the long

Returns:

abs of the long

abs
```
public static double abs(double v)
```
return the abs of the double, to support Jython properly.

Parameters:

v - the valye

Returns:

abs of the value

abs
```
public static QDataSet abs(java.lang.Object ds1)
```
promote the list, double, array etc to QDataSet before taking abs.

Parameters:

ds1 - list, double, array, etc

Returns:

the abs in a QDataSet

pow
```
public static QDataSet pow(QDataSet ds1,
                           QDataSet pow)
```
element-wise pow (** in FORTRAN, ^ in IDL) of two datasets with the compatible geometry.

Parameters:

ds1 - the base

pow - the exponent

Returns:

the value ds1**pow

pow
```
public static long pow(long x,
                       long y)
```
for Jython, we define this because the doubles aren't coerced. Note that pow(2,4) returns a long, not an int like Python 2.6.5

Parameters:

x - the base

y - the exponent

Returns:

the value x**y

pow
```
public static double pow(double x,
                         double y)
```
for Jython, we define this because the doubles aren't coerced. Note that pow(2,4) returns a long, not an int like Python 2.6.5

Parameters:

x - the base

y - the exponent

Returns:

the value x**y

pow
```
public static QDataSet pow(java.lang.Object ds1,
                           java.lang.Object pow)
```
element-wise pow (** in FORTRAN, ^ in IDL) of two datasets with the same geometry.

Parameters:

ds1 - the base

pow - the exponent

Returns:

the value ds1**pow

exp
```
public static QDataSet exp(QDataSet ds)
```
element-wise exponentiate e**x.

Parameters:

ds - the dataset

Returns:

dataset of the same geometry

exp
```
public static double exp(double d)
```
Jython requires this be implemented

Parameters:

d -

Returns:

e**d

exp
```
public static QDataSet exp(java.lang.Object ds1)
```
convert array, list, double, etc to QDataSet and return exp(d)

Parameters:

ds1 - requires this be implemented

Returns:

exp(ds1)

exp10
```
public static QDataSet exp10(QDataSet ds)
```
element-wise exponentiate 10**x.

Parameters:

ds -

Returns:

exp10

public static double exp10(double ds1)

exp10

public static QDataSet exp10(java.lang.Object ds1)

log
```
public static QDataSet log(QDataSet ds)
```
element-wise natural logarithm.

Parameters:

ds -

Returns:

log
```
public static double log(double ds1)
```

log

public static QDataSet log(java.lang.Object ds1)

log10
```
public static QDataSet log10(QDataSet ds)
```
element-wise base 10 logarithm.

Parameters:

ds -

Returns:

log10

public static double log10(double ds1)

log10

public static QDataSet log10(java.lang.Object ds1)

multiply
```
public static QDataSet multiply(QDataSet ds1,
                                QDataSet ds2)
```
element-wise multiply of two datasets with compatible geometry. Presently, either ds1 or ds2 should be dimensionless. TODO: units improvements.

Parameters:

ds1 -

ds2 -

Returns:

See Also:

multiplyUnits(org.das2.datum.Units, org.das2.datum.Units)

multiply

public static QDataSet multiply(java.lang.Object ds1,
                                java.lang.Object ds2)

divide
```
public static QDataSet divide(QDataSet ds1,
                              QDataSet ds2)
```
element-wise divide of two datasets with compatible geometry. Either ds1 or ds2 should be dimensionless, or the units be convertible. TODO: units improvements.

Parameters:

ds1 - the numerator

ds2 - the divisor

Returns:

the ds1/ds2

divide

public static QDataSet divide(java.lang.Object ds1,
                              java.lang.Object ds2)

mod
```
public static QDataSet mod(QDataSet ds1,
                           QDataSet ds2)
```
element-wise mod of two datasets with compatible geometry. This should support Units.t2000 mod "24 hours" to get result in hours.

Parameters:

ds1 - the numerator

ds2 - the divisor

Returns:

the remainder after the division

mod

public static QDataSet mod(java.lang.Object ds1,
                           java.lang.Object ds2)

modp
```
public static QDataSet modp(QDataSet ds1,
                            QDataSet ds2)
```
element-wise mod of two datasets with compatible geometry. This returns a positive number for -18 % 10. This is Python's behavior. This should support Units.t2000 mod "24 hours" to get result in hours.

Parameters:

ds1 - the numerator

ds2 - the divisor

Returns:

the remainder after the division

See Also:

sawtooth(org.das2.qds.QDataSet)

modp

public static QDataSet modp(java.lang.Object ds1,
                            java.lang.Object ds2)

divp
```
public static QDataSet divp(QDataSet ds1,
                            QDataSet ds2)
```
This div goes with modp, where -18 divp 10 = -2 and -18 modp 10 = 8. the div operator always goes towards zero, but divp always goes to the more negative number so the remainder is positive.

Parameters:

ds1 -

ds2 -

Returns:

divp

public static QDataSet divp(java.lang.Object ds1,
                            java.lang.Object ds2)

div

public static QDataSet div(QDataSet ds1,
                           QDataSet ds2)

element-wise div of two datasets with compatible geometry.

Parameters:: ds1 -; ds2 -
Returns:

div

public static QDataSet div(java.lang.Object ds1,
                           java.lang.Object ds2)

eq
```
public static QDataSet eq(QDataSet ds1,
                          QDataSet ds2)
```
element-wise equality test. 1.0 is returned where the two datasets are equal. Fill is returned where either measurement is invalid.

Parameters:

ds1 - rank n dataset

ds2 - rank m dataset with compatible geometry.

Returns:

rank n or m dataset.

eq
```
public static QDataSet eq(java.lang.Object ds1,
                          java.lang.Object ds2)
```
element-wise equality test, converting arguments as necessary to like units. These datasets can be nominal data as well.

Parameters:

ds1 -

ds2 -

Returns:

ne
```
public static QDataSet ne(QDataSet ds1,
                          QDataSet ds2)
```
element-wise not equal test. 1.0 is returned where elements are not equal. Fill is returned where either measurement is invalid.

Parameters:

ds1 -

ds2 -

Returns:

ne
```
public static QDataSet ne(java.lang.Object ds1,
                          java.lang.Object ds2)
```
element-wise equality test, converting arguments as necessary to like units. These datasets can be nominal data as well.

Parameters:

ds1 -

ds2 -

Returns:

gt

public static QDataSet gt(QDataSet ds1,
                          QDataSet ds2)

element-wise function returns 1 where ds1>ds2.

Parameters:: ds1 -; ds2 -
Returns:

gt

public static QDataSet gt(java.lang.Object ds1,
                          java.lang.Object ds2)

greaterOf
```
public static QDataSet greaterOf(QDataSet ds1,
                                 QDataSet ds2)
```
element-wise function returns the greater of ds1 and ds2. If an element of ds1 or ds2 is fill, then the result is fill.

Parameters:

ds1 -

ds2 -

Returns:

the bigger of the two, in the units of ds1.

greaterOf

public static QDataSet greaterOf(java.lang.Object ds1,
                                 java.lang.Object ds2)

lesserOf
```
public static QDataSet lesserOf(QDataSet ds1,
                                QDataSet ds2)
```
element-wise function returns the smaller of ds1 and ds2. If an element of ds1 or ds2 is fill, then the result is fill.

Parameters:

ds1 -

ds2 -

Returns:

the smaller of the two, in the units of ds1.

lesserOf

public static QDataSet lesserOf(java.lang.Object ds1,
                                java.lang.Object ds2)

ge

public static QDataSet ge(QDataSet ds1,
                          QDataSet ds2)

element-wise function returns 1 where ds1>=ds2.

Parameters:: ds1 -; ds2 -
Returns:

ge

public static QDataSet ge(java.lang.Object ds1,
                          java.lang.Object ds2)

lt

public static QDataSet lt(QDataSet ds1,
                          QDataSet ds2)

element-wise function returns 1 where ds1<ds2.

Parameters:: ds1 -; ds2 -
Returns:

lt

public static QDataSet lt(java.lang.Object ds1,
                          java.lang.Object ds2)

le

public static QDataSet le(QDataSet ds1,
                          QDataSet ds2)

element-wise function returns 1 where ds1<=ds2.

Parameters:: ds1 -; ds2 -
Returns:

le

public static QDataSet le(java.lang.Object ds1,
                          java.lang.Object ds2)

or
```
public static QDataSet or(QDataSet ds1,
                          QDataSet ds2)
```
element-wise logical or function. returns 1 where ds1 is non-zero or ds2 is non-zero. Note that or(fill,1) is currently fill, not 1, as are all binary operators.

Parameters:

ds1 -

ds2 -

Returns:

See Also:

bitwiseOr(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

or

public static QDataSet or(java.lang.Object ds1,
                          java.lang.Object ds2)

and
```
public static QDataSet and(QDataSet ds1,
                           QDataSet ds2)
```
element-wise logical and function. non-zero is true, zero is false.

Parameters:

ds1 -

ds2 -

Returns:

See Also:

bitwiseAnd(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

and

public static QDataSet and(java.lang.Object ds1,
                           java.lang.Object ds2)

bitwiseAnd

public static QDataSet bitwiseAnd(QDataSet ds1,
                                  QDataSet ds2)

bitwise AND operator treats the data as (32-bit) integers, and returns the bit-wise AND.

Parameters:: ds1 -; ds2 -
Returns:: bit-wise AND.

bitwiseAnd

public static QDataSet bitwiseAnd(java.lang.Object ds1,
                                  java.lang.Object ds2)

bitwiseOr

public static QDataSet bitwiseOr(QDataSet ds1,
                                 QDataSet ds2)

bitwise OR operator treats the data as (32-bit) integers, and returns the bit-wise OR.

Parameters:: ds1 -; ds2 -
Returns:: bit-wise OR.

bitwiseOr

public static QDataSet bitwiseOr(java.lang.Object ds1,
                                 java.lang.Object ds2)

bitwiseXor
```
public static QDataSet bitwiseXor(QDataSet ds1,
                                  QDataSet ds2)
```
bitwise XOR (exclusive or) operator treats the data as (32-bit) integers, and returns the bit-wise XOR. Note there is no bitwise not, and this is because there are no shorts, bytes. So to implement bitwise not for a 16 bit number you would have bitwiseXor( ds, dataset(2**16-1) ).

Parameters:

ds1 -

ds2 -

Returns:

bit-wise XOR.

See Also:

not(org.das2.qds.QDataSet)

bitwiseXor

public static QDataSet bitwiseXor(java.lang.Object ds1,
                                  java.lang.Object ds2)

not
```
public static QDataSet not(QDataSet ds1)
```
element-wise logical not function. non-zero is true, zero is false.

Parameters:

ds1 -

Returns:

See Also:

bitwiseXor(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

not

public static QDataSet not(java.lang.Object ds1)

irange
```
public static java.util.Iterator<java.lang.Integer> irange(double min,
                                                           double max,
                                                           int step)
```
mimic the Jython xrange function for use in loops. The returns the integers in the sequence, like xrange, but avoids the confusing "xrange" name and this also takes double values so that it can be used in graphics routines which use double.

Parameters:

min - the first value

max - the last value, plus one (exclusive).

step - the increment between elements.

Returns:

an iterator for the numbers in the interval.

irange
```
public static java.util.Iterator<java.lang.Integer> irange(double min,
                                                           double max)
```
mimic the Jython xrange function for use in loops. This creates an dataset which has no storage.

Parameters:

min - the first value

max - the last value, plus one (exclusive).

Returns:

an iterator for the numbers in the interval.

irange
```
public static java.util.Iterator<java.lang.Integer> irange(double max)
```
mimic the Jython xrange function for use in loops. This creates an dataset which has no storage.

Parameters:

max - the last value, plus one (exclusive).

Returns:

an iterator for the numbers in the interval.

indgen
```
public static QDataSet indgen(int len0)
```
returns rank 1 dataset with values [0,1,2,...] This returns an immutable dataset, so that it can be used in Jython like so: for i in indgen(200000). Note before February 2018, this would return a mutable dataset, and now this returns an IndexGenDataSet, which is immutable.

Parameters:

len0 -

Returns:

indgen
```
public static QDataSet indgen(int len0,
                              int len1)
```
returns rank 2 dataset with values increasing [ [0,1,2], [ 3,4,5] ]

Parameters:

len0 -

len1 -

Returns:

indgen

public static QDataSet indgen(int len0,
                              int len1,
                              int len2)

returns rank 3 dataset with values increasing

Parameters:: len0 -; len1 -; len2 -
Returns:

dindgen
```
public static QDataSet dindgen(int len0)
```
returns rank 1 dataset with values [0.,1.,2.,...]

Parameters:

len0 -

Returns:

dindgen
```
public static QDataSet dindgen(int len0,
                               int len1)
```
returns rank 2 dataset with values increasing [ [0.,1.,2.], [ 3.,4.,5.] ]

Parameters:

len0 -

len1 -

Returns:

dindgen

public static QDataSet dindgen(int len0,
                               int len1,
                               int len2)

returns rank 3 dataset with values increasing

Parameters:: len0 -; len1 -; len2 -
Returns:

dindgen

public static QDataSet dindgen(int len0,
                               int len1,
                               int len2,
                               int len3)

returns rank 4 dataset with values increasing

Parameters:: len0 -; len1 -; len2 -; len3 -
Returns:

convertToString
```
public static java.lang.String convertToString(QDataSet bytes)
```
convert the bytes (or unicode up to 2**16) to a string.

Parameters:

bytes - a QDataSet containing the data.

Returns:

arange
```
public static QDataSet arange(int len0)
```
returns rank 1 dataset with values [0.,1.,2.,...]

Parameters:

len0 -

Returns:

a rank 1 dataset

findgen
```
public static QDataSet findgen(int len0)
```
returns rank 1 dataset with values [0.,1.,2.,...]

Parameters:

len0 -

Returns:

findgen
```
public static QDataSet findgen(int len0,
                               int len1)
```
returns rank 2 dataset with values increasing [ [0.,1.,2.], [ 3.,4.,5.] ]

Parameters:

len0 -

len1 -

Returns:

findgen

public static QDataSet findgen(int len0,
                               int len1,
                               int len2)

returns rank 3 dataset with values increasing

Parameters:: len0 -; len1 -; len2 -
Returns:

findgen

public static QDataSet findgen(int len0,
                               int len1,
                               int len2,
                               int len3)

returns rank 4 dataset with values increasing

Parameters:: len0 -; len1 -; len2 -; len3 -
Returns:

strarr
```
public static QDataSet strarr(int len0)
```
return a QDataSet containing empty strings. This is used in Jython to create an array-like dataset where different strings are assigned after the array is made.

Parameters:

len0 - the number of elements.

Returns:

QDataSet with EnumerationUnits and all elements containing the value for "".

strarr
```
public static QDataSet strarr(int len0,
                              int len1)
```
return a rank 2 QDataSet containing empty strings. This is used in Jython to create an array-like dataset where different strings are assigned after the array is made.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

Returns:

QDataSet with EnumerationUnits and all elements containing the value for "".

See Also:

dblarr(int)

fltarr
```
public static QDataSet fltarr(int len0)
```
create a dataset filled with zeros, stored in 4-byte floats.

Parameters:

len0 - the zeroth dimension length

Returns:

rank 1 dataset filled with zeros.

See Also:

zeros(int), dblarr(int), strarr(int)

fltarr

public static QDataSet fltarr(int len0,
                              int len1)

fltarr

public static QDataSet fltarr(int len0,
                              int len1,
                              int len2)

bytarr
```
public static QDataSet bytarr(int len0)
```
create a dataset filled with zeros, stored in unsigned bytes. Each element can contain numbers from 0 to 255.

Parameters:

len0 - the zeroth dimension length

Returns:

rank 1 dataset filled with zeros.

See Also:

dblarr(int)

bytarr
```
public static QDataSet bytarr(int len0,
                              int len1)
```
create a rank 2 dataset filled with zeros, stored in unsigned bytes.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

Returns:

rank 2 dataset filled with zeros.

bytarr
```
public static QDataSet bytarr(int len0,
                              int len1,
                              int len2)
```
create a rank 3 dataset filled with zeros, stored in unsigned bytes.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

len2 - the length of the second dimension.

Returns:

rank 3 dataset filled with zeros.

shortarr
```
public static QDataSet shortarr(int len0)
```
create a dataset filled with zeros, stored in 2-byte signed shorts. Note that shortarr is equivalent to intarr in IDL, containing integer values from -32768 to 32767.

Parameters:

len0 - the zeroth dimension length

Returns:

rank 1 dataset filled with zeros.

See Also:

zeros(int), dblarr(int)

shortarr
```
public static QDataSet shortarr(int len0,
                                int len1)
```
create a rank 2 dataset filled with zeros, stored in 2-byte shorts.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

Returns:

rank 2 dataset filled with zeros.

shortarr
```
public static QDataSet shortarr(int len0,
                                int len1,
                                int len2)
```
create a rank 3 dataset filled with zeros, stored in 2-byte shorts.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

len2 - the length of the second dimension.

Returns:

rank 3 dataset filled with zeros.

intarr
```
public static QDataSet intarr(int len0)
```
create a dataset filled with zeros, stored in 4-byte ints.

Parameters:

len0 - the zeroth dimension length

Returns:

rank 1 dataset filled with zeros.

See Also:

zeros(int), dblarr(int)

intarr
```
public static QDataSet intarr(int len0,
                              int len1)
```
create a rank 2 dataset filled with zeros, stored in 4-byte ints.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

Returns:

rank 2 dataset filled with zeros.

intarr
```
public static QDataSet intarr(int len0,
                              int len1,
                              int len2)
```
create a rank 3 dataset filled with zeros, stored in 4-byte ints.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

len2 - the length of the second dimension.

Returns:

rank 3 dataset filled with zeros.

lonarr
```
public static QDataSet lonarr(int len0)
```
create a dataset filled with zeros, stored in 8-byte longs, suitable for storing cdf_tt2000 times..

Parameters:

len0 - the zeroth dimension length

Returns:

rank 1 dataset filled with zeros.

See Also:

zeros(int), dblarr(int)

lonarr
```
public static QDataSet lonarr(int len0,
                              int len1)
```
create a rank 2 dataset filled with zeros, stored in 8-byte longs.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

Returns:

rank 2 dataset filled with zeros.

dblarr
```
public static QDataSet dblarr(int len0)
```
create a rank 1 dataset filled with zeros, stored in 8-byte doubles.

Parameters:

len0 - the length of the zeroth dimension.

Returns:

rank 1 dataset filled with zeros.

See Also:

zeros(int), fltarr(int), bytarr(int), shortarr(int), intarr(int), lonarr(int)

dblarr
```
public static QDataSet dblarr(int len0,
                              int len1)
```
create a rank 2 dataset filled with zeros, stored in 8-byte doubles.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

Returns:

rank 2 dataset filled with zeros.

See Also:

zeros(int), fltarr(int)

dblarr
```
public static QDataSet dblarr(int len0,
                              int len1,
                              int len2)
```
create a rank 3 dataset filled with zeros, stored in 8-byte doubles.

Parameters:

len0 - the length of the zeroth dimension.

len1 - the length of the first dimension.

len2 - the length of the second dimension.

Returns:

rank 3 dataset filled with zeros.

See Also:

zeros(int), fltarr(int)

timegen

public static QDataSet timegen(java.lang.String baseTime,
                               java.lang.String cadence,
                               int len0)
                        throws java.text.ParseException

returns rank 1 dataset with values that are times.

Parameters:: baseTime - e.g. "2003-02-04T00:00"; cadence - e.g. "4.3 sec" "1 day"; len0 - the number of elements.
Returns:
Throws:: java.text.ParseException

toTimeDataSet
```
public static QDataSet toTimeDataSet(QDataSet years,
                                     QDataSet mons,
                                     QDataSet days,
                                     QDataSet hour,
                                     QDataSet minute,
                                     QDataSet second,
                                     QDataSet nano)
```
return a rank 1 dataset of times. All inputs should be rank 1 dataset (for now) or null.

Parameters:

years - the years. (2010) Less than 100 is interpreted as 19xx.

mons - the months (1..12), or null. If null, then days are day of year. These are interpreted as integers

days - the day of month (1..28) or day of year. This may be fractional.

hour - null or the hours of the day.

minute - null or the minutes of the day

second - null or the seconds of the day

nano - null or the nanoseconds (1e-9) of the day

Returns:

rank 1 time data set.

See Also:

rgbColorDataset(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

toTimeDataSet

public static QDataSet toTimeDataSet(java.lang.Object years,
                                     java.lang.Object mons,
                                     java.lang.Object days,
                                     java.lang.Object hour,
                                     java.lang.Object minute,
                                     java.lang.Object second,
                                     java.lang.Object nano)

taggen

public static MutablePropertyDataSet taggen(double base,
                                            double dcadence,
                                            int len0,
                                            Units units)

creates tags. First tag will be start and they will increase by cadence. Units specifies the units of each tag.

Parameters:: base -; dcadence -; len0 -; units -
Returns:

linspace
```
public static QDataSet linspace(double min,
                                double max,
                                int len0)
```
return a rank 1 dataset with len0 linearly-spaced values, the first is min and the last is max.

Parameters:

min - double

max - double

len0 - number of elements in the result

Returns:

rank 1 dataset of linearly spaced data.

linspace
```
public static QDataSet linspace(java.lang.Object omin,
                                java.lang.Object omax,
                                int len0)
```
return a rank 1 dataset with len0 linearly-spaced values, the first is min and the last is max.

Parameters:

omin - rank 0 dataset

omax - rank 0 dataset

len0 - number of elements in the result

Returns:

rank 1 dataset of linearly spaced data.

logspace
```
public static QDataSet logspace(double min,
                                double max,
                                int len0)
```
return a rank 1 dataset with len0 logarithmically-spaced values, the first is min and the last is max.

Parameters:

min - double

max - double

len0 - number of elements in the result

Returns:

rank 1 dataset of logarithmically spaced data.

logspace
```
public static QDataSet logspace(java.lang.Object omin,
                                java.lang.Object omax,
                                int len0)
```
return a rank 1 dataset with len0 logarithmically-spaced values, the first is min and the last is max.

Parameters:

omin - rank 0 dataset

omax - rank 0 dataset

len0 - number of elements in the result

Returns:

rank 1 dataset of logarithmically spaced data.

replicate

public static WritableDataSet replicate(short val,
                                        int len0)

returns rank 1 dataset with value

Parameters:: val - fill the dataset with this value.; len0 -
Returns:

replicate

public static WritableDataSet replicate(short val,
                                        int len0,
                                        int len1)

returns rank 2 dataset filled with value

Parameters:: val - fill the dataset with this value.; len0 -; len1 -
Returns:

replicate

public static WritableDataSet replicate(short val,
                                        int len0,
                                        int len1,
                                        int len2)

returns rank 3 dataset with filled with value.

Parameters:: val - fill the dataset with this value.; len0 -; len1 -; len2 -
Returns:

replicate

public static WritableDataSet replicate(int val,
                                        int len0)

returns rank 1 dataset with value

Parameters:: val - fill the dataset with this value.; len0 -
Returns:

replicate

public static WritableDataSet replicate(int val,
                                        int len0,
                                        int len1)

returns rank 2 dataset filled with value

Parameters:: val - fill the dataset with this value.; len0 -; len1 -
Returns:

replicate

public static WritableDataSet replicate(int val,
                                        int len0,
                                        int len1,
                                        int len2)

returns rank 3 dataset with filled with value.

Parameters:: val - fill the dataset with this value.; len0 -; len1 -; len2 -
Returns:

replicate

public static WritableDataSet replicate(long val,
                                        int len0)

returns rank 1 dataset with value

Parameters:: val - fill the dataset with this value.; len0 -
Returns:

replicate

public static WritableDataSet replicate(long val,
                                        int len0,
                                        int len1)

returns rank 2 dataset filled with value

Parameters:: val - fill the dataset with this value.; len0 -; len1 -
Returns:

replicate

public static WritableDataSet replicate(long val,
                                        int len0,
                                        int len1,
                                        int len2)

returns rank 3 dataset with filled with value.

Parameters:: val - fill the dataset with this value.; len0 -; len1 -; len2 -
Returns:

replicate

public static WritableDataSet replicate(double val,
                                        int len0)

returns rank 1 dataset with value

Parameters:: val - fill the dataset with this value.; len0 -
Returns:

replicate

public static WritableDataSet replicate(double val,
                                        int len0,
                                        int len1)

returns rank 2 dataset filled with value

Parameters:: val - fill the dataset with this value.; len0 -; len1 -
Returns:

replicate

public static WritableDataSet replicate(double val,
                                        int len0,
                                        int len1,
                                        int len2)

returns rank 3 dataset with filled with value.

Parameters:: val - fill the dataset with this value.; len0 -; len1 -; len2 -
Returns:

replicate

public static WritableDataSet replicate(double val,
                                        int len0,
                                        int len1,
                                        int len2,
                                        int len3)

returns rank 4 dataset with filled with value.

Parameters:: val - fill the dataset with this value.; len0 -; len1 -; len2 -; len3 -
Returns:

replicate

public static WritableDataSet replicate(float val,
                                        int len0)

returns rank 1 dataset with value

Parameters:: val - fill the dataset with this value.; len0 -
Returns:

replicate

public static WritableDataSet replicate(float val,
                                        int len0,
                                        int len1)

returns rank 2 dataset filled with value

Parameters:: val - fill the dataset with this value.; len0 -; len1 -
Returns:

replicate

public static WritableDataSet replicate(float val,
                                        int len0,
                                        int len1,
                                        int len2)

returns rank 3 dataset with filled with value.

Parameters:: val - fill the dataset with this value.; len0 -; len1 -; len2 -
Returns:

replicate
```
public static MutablePropertyDataSet replicate(QDataSet val,
                                               int len0)
```
returns a rank N+1 dataset by repeating the rank N dataset, so all records will have the same value. E.g. result.value(i,j)= val.value(j)

Parameters:

val - the rank N dataset

len0 - the number of times to repeat

Returns:

rank N+1 dataset. TODO: support rank N

replicate
```
public static MutablePropertyDataSet replicate(QDataSet val,
                                               int len0,
                                               int len1)
```
returns a rank N+2 dataset by repeating the rank N dataset, so all records will have the same value. E.g. result.value(i,j)= val.value()

Parameters:

val - the rank N dataset

len0 - the number of times to repeat

len1 - the length of the second index.

Returns:

rank N+2 dataset.

zeros
```
public static WritableDataSet zeros(int len0)
```
return new dataset filled with zeros.

Parameters:

len0 -

Returns:

rank 1 dataset

See Also:

fltarr, which stores the data in 4-byte floats.

zeros

public static WritableDataSet zeros(int len0,
                                    int len1)

return new dataset filled with zeros.

Parameters:: len0 -; len1 -
Returns:: rank 2 dataset

zeros

public static WritableDataSet zeros(int len0,
                                    int len1,
                                    int len2)

return new dataset filled with zeros.

Parameters:: len0 -; len1 -; len2 -
Returns:: rank 3 dataset

zeros

public static WritableDataSet zeros(int len0,
                                    int len1,
                                    int len2,
                                    int len3)

return new dataset filled with zeros.

Parameters:: len0 -; len1 -; len2 -; len3 -
Returns:: rank 4 dataset

zeros
```
public static WritableDataSet zeros(QDataSet ds)
```
return a new dataset filled with zeroes that has the same geometry as the given dataset. Only supports QUBE datasets.

Parameters:

ds -

Returns:

a new dataset with filled with zeroes with the same geometry.

ones
```
public static QDataSet ones(int len0)
```
return new dataset filled with ones.

Parameters:

len0 - the length of the first index.

Returns:

dataset filled with ones.

ones
```
public static QDataSet ones(int len0,
                            int len1)
```
return a rank two dataset filled with ones. This is currently mutable, but future versions may not be.

Parameters:

len0 - the length of the first index.

len1 - the length of the second index.

Returns:

dataset filled with ones.

ones
```
public static QDataSet ones(int len0,
                            int len1,
                            int len2)
```
return new dataset filled with ones.

Parameters:

len0 - the length of the first index.

len1 - the length of the second index.

len2 - the length of the third index.

Returns:

dataset filled with ones.

ones
```
public static QDataSet ones(int len0,
                            int len1,
                            int len2,
                            int len3)
```
return new dataset filled with ones.

Parameters:

len0 - the length of the first index.

len1 - the length of the second index.

len2 - the length of the third index.

len3 - the length of the fourth index.

Returns:

dataset filled with ones.

concatenate
```
public static QDataSet concatenate(QDataSet ds1,
                                   QDataSet ds2)
```
Deprecated. use append instead.

concatenates the two datasets together, appending the datasets on the zeroth dimension. The two datasets must be QUBES have similar geometry on the higher dimensions. If one of the datasets is rank 0 and the geometry of the other is rank 1, then the lower rank dataset is promoted before appending. If the first dataset is null and the second is non-null, then return the second dataset.

Parameters:

ds1 - null or a dataset of length m.

ds2 - dataset of length n to be concatenated.

Returns:

a dataset length m+n.

Throws:

java.lang.IllegalArgumentException - if the two datasets don't have the same rank.

See Also:

merge(ds1,ds2), which will interleave to preserve monotonic., append(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

concatenate

public static QDataSet concatenate(java.lang.Object ds1,
                                   java.lang.Object ds2)

rand
```
public static QDataSet rand()
```
Deprecated. use randu instead

returns a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.

Returns:

a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.

rand
```
public static QDataSet rand(int len0)
```
Deprecated. use randu instead. This is used in many test programs and Jython codes, and will not be removed.

returns a rank 1 dataset of random uniform numbers from 0 to 1 but not including 1.

Parameters:

len0 - the number of elements in the result.

Returns:

a rank 1 dataset of random uniform numbers from 0 to 1 but not including 1.

rand
```
public static QDataSet rand(int len0,
                            int len1)
```
Deprecated. use randu instead

returns a rank 2 dataset of random uniform numbers from 0 to 1 but not including 1.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

Returns:

a rank 2 dataset of random uniform numbers from 0 to 1 but not including 1.

rand
```
public static QDataSet rand(int len0,
                            int len1,
                            int len2)
```
Deprecated. use randu instead

returns a rank 3 dataset of random uniform numbers from 0 to 1 but not including 1.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

len2 - the number of elements in the third index.

Returns:

a rank 3 dataset of random uniform numbers from 0 to 1 but not including 1.

randu
```
public static QDataSet randu()
```
returns a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.

Returns:

a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.

randu
```
public static QDataSet randu(int len0)
```
returns a rank 1 dataset of random uniform numbers from 0 to 1 but not including 1.

Parameters:

len0 - the number of elements in the result.

Returns:

a rank 1 dataset of random uniform numbers from 0 to 1 but not including 1.

randu
```
public static QDataSet randu(int len0,
                             int len1)
```
returns a rank 2 dataset of random uniform numbers from 0 to 1 but not including 1.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

Returns:

a rank 2 dataset of random uniform numbers from 0 to 1 but not including 1.

randu
```
public static QDataSet randu(int len0,
                             int len1,
                             int len2)
```
returns a rank 3 dataset of random uniform numbers from 0 to 1 but not including 1.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

len2 - the number of elements in the third index.

Returns:

a rank 3 dataset of random uniform numbers from 0 to 1 but not including 1.

randu
```
public static QDataSet randu(int len0,
                             int len1,
                             int len2,
                             int len3)
```
return a rank 4 dataset of random uniform numbers from 0 to 1 but not including 1.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

len2 - the number of elements in the third index.

len3 - the number of elements in the fourth index.

Returns:

a rank 4 dataset of random uniform numbers from 0 to 1 but not including 1.

randn
```
public static QDataSet randn()
```
return a rank 0 dataset of random numbers of a Gaussian (normal) distribution.

Returns:

a rank 0 dataset of random numbers of a Gaussian (normal) distribution.

randn
```
public static QDataSet randn(int len0)
```
return a rank 1 dataset of random numbers of a Gaussian (normal) distribution.

Parameters:

len0 - the number of elements in the first index.

Returns:

a rank 1 dataset of random numbers of a Gaussian (normal) distribution.

randn
```
public static QDataSet randn(int len0,
                             int len1)
```
return a rank 2 dataset of random numbers of a Gaussian (normal) distribution.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

Returns:

a rank 2 dataset of random numbers of a Gaussian (normal) distribution.

randn
```
public static QDataSet randn(int len0,
                             int len1,
                             int len2)
```
return a rank 3 dataset of random numbers of a Gaussian (normal) distribution.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

len2 - the number of elements in the third index.

Returns:

a rank 3 dataset of random numbers of a Gaussian (normal) distribution.

randn
```
public static QDataSet randn(int len0,
                             int len1,
                             int len2,
                             int len3)
```
return a rank 4 dataset of random numbers of a Gaussian (normal) distribution.

Parameters:

len0 - the number of elements in the first index.

len1 - the number of elements in the second index.

len2 - the number of elements in the third index.

len3 - the number of elements in the fourth index.

Returns:

a rank 4 dataset of random numbers of a Gaussian (normal) distribution.

randomSeed
```
public static long randomSeed()
```
restart the random sequence used by randu and randn. Note if there if there are multiple threads using random functions, this becomes unpredictable.

Returns:

the seed is returned.

randomSeed
```
public static long randomSeed(long seed)
```
reset the random sequence used by randu and randn to the given seed.

Parameters:

seed - the new seed for the sequence.

Returns:

the seed (which will be the same as the input).

randomn
```
public static QDataSet randomn(long seed)
```
returns a rank 0 dataset of random numbers of a Gaussian (normal) distribution. System.currentTimeMillis() may be used for the seed. Note this is unlike the IDL randomn function because the seed is not modified. (Any long parameter in Jython and Java is read-only.) System.currentTimeMillis() may be used for the seed.

Parameters:

seed - basis for the random number (which will not be modified).

Returns:

rank 0 dataset

randomn
```
public static QDataSet randomn(long seed,
                               int len0)
```
returns a rank 1 dataset of random numbers of a Gaussian (normal) distribution. System.currentTimeMillis() may be used for the seed.

Parameters:

seed - basis for the random number (which will not be modified).

len0 - number of elements in the first index

Returns:

rank 1 dataset of normal distribution

randomn
```
public static QDataSet randomn(long seed,
                               int len0,
                               int len1)
```
returns a rank 2 dataset of random numbers of a Gaussian (normal) distribution.

Parameters:

seed - basis for the random number (which will not be modified).

len0 - number of elements in the first index

len1 - number of elements in the second index

Returns:

rank 2 dataset of normal distribution

randomn
```
public static QDataSet randomn(long seed,
                               int len0,
                               int len1,
                               int len2)
```
returns a rank 3 dataset of random numbers of a gaussian (normal) distribution.

Parameters:

seed - basis for the random number (which will not be modified).

len0 - number of elements in the first index

len1 - number of elements in the second index

len2 - number of elements in the third index

Returns:

rank 3 dataset of normal distribution

randomn
```
public static QDataSet randomn(long seed,
                               int len0,
                               int len1,
                               int len2,
                               int len3)
```
returns a rank 3 dataset of random numbers of a gaussian (normal) distribution.

Parameters:

seed - basis for the random number (which will not be modified).

len0 - number of elements in the first index

len1 - number of elements in the second index

len2 - number of elements in the third index

len3 - number of elements in the fourth index

Returns:

rank 4 dataset of normal distribution

randomu
```
public static QDataSet randomu(long seed)
```
returns a rank 0 dataset of random numbers of a uniform distribution. System.currentTimeMillis() may be used for the seed. Note this is unlike the IDL randomn function because the seed is not modified. (Any long parameter in Jython and Java is read-only.)

Parameters:

seed - basis for the random number (which will not be modified).

Returns:

a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.

randomu
```
public static QDataSet randomu(long seed,
                               int len0)
```
returns a rank 1 dataset of random numbers of a uniform distribution. System.currentTimeMillis() may be used for the seed.

Parameters:

seed - basis for the random number (which will not be modified).

len0 - number of elements in the first index

Returns:

a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.

randomu
```
public static QDataSet randomu(long seed,
                               int len0,
                               int len1)
```
returns a rank 2 dataset of random numbers of a uniform distribution.

Parameters:

seed - basis for the random number (which will not be modified).

len0 - number of elements in the first index

len1 - number of elements in the second index

Returns:

a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.

randomu
```
public static QDataSet randomu(long seed,
                               int len0,
                               int len1,
                               int len2)
```
returns a rank 3 dataset of random numbers of a uniform distribution.

Parameters:

seed - basis for the random number (which will not be modified).

len0 - number of elements in the first index

len1 - number of elements in the second index

len2 - number of elements in the third index

Returns:

a rank 0 dataset of random uniform numbers from 0 to 1 but not including 1.

randomu
```
public static QDataSet randomu(long seed,
                               int len0,
                               int len1,
                               int len2,
                               int len3)
```
returns a rank 3 dataset of random numbers of a uniform distribution.

Parameters:

seed - basis for the random number (which will not be modified).

len0 - number of elements in the first index

len1 - number of elements in the second index

len2 - number of elements in the third index

len3 - number of elements in the fourth index

Returns:

rank 4 dataset of random uniform numbers from 0 to 1 but not including 1.

distance
```
public static QDataSet distance(int len0,
                                double c0,
                                double r0)
```
return a table of distances d[len0] to the indices c0; in units of r0. This is motivated by a need for more interesting datasets for testing.

Parameters:

len0 - the length of the dataset

c0 - the center point 0

r0 - the units to normalize in the 0 direction

Returns:

rank 2 table

distance
```
public static QDataSet distance(int len0,
                                int len1,
                                double c0,
                                double c1,
                                double r0,
                                double r1)
```
return a table of distances d[len0,len1] to the indices c0,c1; in units of r0, r1. This is motivated by a need for more interesting datasets for testing.

Parameters:

len0 - the length of the dataset

len1 - the length of each row of the dataset

c0 - the center point 0

c1 - the center point 1

r0 - the units to normalize in the 0 direction

r1 - the units to normalize in the 1 direction

Returns:

rank 2 table

ripples
```
public static QDataSet ripples(int len0)
```
rank 1 dataset for demos and testing.

Parameters:

len0 - number of elements in the first index

Returns:

rank 1 dataset for demos and testing.

ripples
```
public static QDataSet ripples(int len0,
                               int len1)
```
rank 2 dataset for demos and testing.

Parameters:

len0 - number of elements in the first index

len1 - number of elements in the second index

Returns:

rank 2 dataset for demos and testing.

ripples
```
public static QDataSet ripples(int len0,
                               int len1,
                               int len2)
```
rank 3 dataset for demos and testing.

Parameters:

len0 - number of elements in the first index

len1 - number of elements in the second index

len2 - number of elements in the third index

Returns:

rank 3 dataset for demos and testing.

ripples
```
public static QDataSet ripples(int len0,
                               int len1,
                               int len2,
                               int len3)
```
rank 4 dataset for demos and testing.

Parameters:

len0 - number of elements in the first index

len1 - number of elements in the second index

len2 - number of elements in the third index

len3 - number of elements in the fourth index

Returns:

rank 4 dataset for demos and testing.

ripplesTimeSeries
```
public static QDataSet ripplesTimeSeries(int len)
```
return fake rank 1 data timeseries for testing

Parameters:

len - number of records

Returns:

fake rank 1 data timeseries for testing

ripplesWaveformTimeSeries
```
public static QDataSet ripplesWaveformTimeSeries(int len)
```
return fake waveform data for testing result is rank 2 bundle [len,512]

Parameters:

len - number of 512-element waveforms.

Returns:

rank 2 waveform

ripplesVectorTimeSeries
```
public static QDataSet ripplesVectorTimeSeries(int len)
```
return fake position data for testing. result is rank 2 bundle [len,3]

Parameters:

len - number of records

Returns:

vector time series.

ripplesSpectrogramTimeSeries
```
public static QDataSet ripplesSpectrogramTimeSeries(int len)
```
return fake position data for testing result is rank 2 bundle [len,27]

Parameters:

len - the number of records

Returns:

fake position data for testing

ripplesJoinSpectrogramTimeSeries
```
public static QDataSet ripplesJoinSpectrogramTimeSeries(int len)
```
return fake position data for testing result is rank 3 bundle [3,len/3,27*]

Parameters:

len - the total number of records.

Returns:

an example join spectrogram time series.

See Also:

Schemes.irregularJoin()

ripplesPitchAngleDistribution
```
public static QDataSet ripplesPitchAngleDistribution()
```
return an example of a QDataSet containing a pitch angle distribution. This is a rank 2 dataset with angle in radians for DEPEND_0 and radius for DEPEND_1.

Returns:

an example pitch angle distribution.

sawtooth
```
public static QDataSet sawtooth(QDataSet t)
```
generates a sawtooth from the tags, where a peak occurs with a period 2*PI. All values of T should be ge zero.

Parameters:

t - the independent values

Returns:

/|/|/| sawtooth wave with a period of 2 PI.

See Also:

modp(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

square
```
public static QDataSet square(QDataSet t)
```
generates a square from the tags, where a the signal is 1 from 0-PI, 0 from PI-2*PI, etc.

Parameters:

t - the independent values.

Returns:

square wave with a period of 2 PI.

appendEvents
```
public static QDataSet appendEvents(QDataSet ev1,
                                    QDataSet ev2)
```
Deprecated. since append works with events datasets.

provide explicit method for appending two events scheme datasets. This will probably be deprecated, and this was added at 17:30 for a particular need.

Parameters:

ev1 - an events dataset which is rank 2 with records of [start,stop,color,label]

ev2 - an events dataset which is rank 2 with records of [start,stop,color,label]

Returns:

events list containing both events

See Also:

append(org.das2.qds.QDataSet, org.das2.qds.QDataSet), https://github.com/autoplot/dev/blob/master/demos/2023/20230909/demoCreateEvent.jy

createEvent
```
public static QDataSet createEvent(java.lang.String timeRange,
                                   int rgbcolor,
                                   java.lang.String annotation)
```
tool for creating ad-hoc events datasets.

Parameters:

timeRange - a timerange like "2010-01-01" or "2010-01-01/2010-01-10" or "2010-01-01 through 2010-01-09"

rgbcolor - and RGB color like 0xFF0000 (red), 0x00FF00 (green), or 0x0000FF (blue),

annotation - label for event, possibly including granny codes.

Returns:

a rank 2 QDataSet with [[ startTime, stopTime, rgbColor, annotation ]]

See Also:

#eventsComplement(org.das2.qds.QDataSet, int, java.lang.String)

createEvent
```
public static QDataSet createEvent(QDataSet append,
                                   java.lang.String timeRange,
                                   int rgbcolor,
                                   java.lang.String annotation)
```
tool for creating ad-hoc events datasets.

Parameters:

append - null or a dataset to append the result. This events dataset must have [starttime, endtime, RBG color, string] for each record.

timeRange - a timerange like "2010-01-01" or "2010-01-01/2010-01-10" or "2010-01-01 through 2010-01-09" or "64-96"

rgbcolor - an RGB color like 0xFF0000 (red), 0x00FF00 (green), or 0x0000FF (blue).

annotation - label for event, possibly including granny codes.

Returns:

a rank 2 QDataSet with [[ startTime, stopTime, rgbColor, annotation ]]

createEvent
```
public static QDataSet createEvent(DatumRange dr,
                                   int rgbcolor,
                                   java.lang.String annotation)
```
tool for creating ad-hoc events datasets.

Parameters:

dr - a datum range like "1496 to 1627"

rgbcolor - and RGB color like 0xFF0000 (red), 0x00FF00 (green), or 0x0000FF (blue),

annotation - label for event, possibly including granny codes.

Returns:

a rank 2 QDataSet with [[ start, stop, rgbColor, annotation ]]

See Also:

#eventsComplement(org.das2.qds.QDataSet, int, java.lang.String)

createEvent
```
public static QDataSet createEvent(QDataSet append,
                                   DatumRange dr,
                                   int rgbcolor,
                                   java.lang.String annotation)
```
tool for creating ad-hoc events datasets. For example

Parameters:

append - null or a dataset to append the result. This events dataset must have [starttime, endtime, RBG color, string] for each record.

dr - a datum range

rgbcolor - an RGB color like 0xFF0000 (red), 0x00FF00 (green), or 0x0000FF (blue)

annotation - label for event, possibly including granny codes.

Returns:

a rank 2 QDataSet with [[ startTime, stopTime, rgbColor, annotation ]]

createEvents
```
public static QDataSet createEvents(QDataSet vds)
```
make canonical rank 2 bundle dataset of min,max,color,text This was originally part of EventsRenderer, but it became clear that this was generally useful.

Parameters:

vds - dataset in a number of forms that can be converted to an events dataset.

Returns:

rank 2 QDataSet [ index; 4( time, stopTime, rgbColor, label ) ]

createEvents
```
public static QDataSet createEvents(QDataSet vds,
                                    java.awt.Color deftColor)
```
make canonical rank 2 bundle dataset of min,max,color,text This was originally part of EventsRenderer, but it became clear that this was generally useful.

Parameters:

vds - dataset in a number of forms that can be converted to an events dataset.

deftColor - the color to use as the default color.

Returns:

rank 2 QDataSet [ index; time, stopTime, rgbColor, label ]

dataIntersection
```
public static int[] dataIntersection(int[] itE,
                                     int[] itB)
```
return the values which occur in both rank 1 datasets. Each dataset is sorted.

Parameters:

itE - a bunch of values.

itB - a bunch of values.

Returns:

the set of values found in both.

See Also:

eventsConjunction(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

dataIntersection
```
public static QDataSet dataIntersection(QDataSet tE,
                                        QDataSet tB)
```
return the values which occur in both rank 1 datasets. Each dataset is sorted.

Parameters:

tE - a bunch of values.

tB - a bunch of values.

Returns:

the set of values found in both.

See Also:

eventsConjunction(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

eventsDiff
```
public static QDataSet eventsDiff(QDataSet tE,
                                  QDataSet tB)
```
return an events dataset describing differences between the two events lists. The list will contain labels starting with insert, delete, and update, and the values.

Parameters:

tE - sorted rank 2 events dataset with records of [start, stop, color, label ]

tB - sorted rank 2 events dataset with records of [start, stop, color, label ]

Returns:

events list of differences

eventsConjunction
```
public static QDataSet eventsConjunction(QDataSet tE,
                                         QDataSet tB)
```
return an events list of when events are found in both events lists. (This might have been better called "eventsIntersection") This is the overlap between two sets. TODO: what if the two lists are not in order? Handle this.

Parameters:

tE - rank 2 canonical events list

tB - rank 2 canonical events list

Returns:

rank 2 canonical events list

See Also:

Schemes.eventsList(), dataIntersection(org.das2.qds.QDataSet, org.das2.qds.QDataSet), eventsComplement(org.das2.qds.QDataSet, org.das2.datum.DatumRange, int, java.lang.String)

eventsComplement
```
public static QDataSet eventsComplement(QDataSet events,
                                        DatumRange range,
                                        int color,
                                        java.lang.String msg)
```
Return an events list of time intervals which are not covered in the events list. A new events list is returned, containing events with the given color and message. This is expected to have a number of uses, one being identifying where data is missing. Note this assumes events are not overlapping.

Parameters:

events - an events list

range - find gaps in events within this range

color - color for the missing events

msg - message to attach to these events

Returns:

the events data set.

See Also:

createEvent(java.lang.String, int, java.lang.String), eventsConjunction(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

circle
```
public static QDataSet circle(QDataSet radius,
                              QDataSet x,
                              QDataSet y)
```
return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.

Parameters:

x - the x coordinate of the circle

y - the y coordinate of the circle

radius - rank 0 dataset

Returns:

QDataSet that when plotted is a circle.

circle
```
public static QDataSet circle(double radius,
                              double x,
                              double y)
```
return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location. Note this is presently returned as Y[X], but should probably return a rank 2 dataset that is a bundle.

Parameters:

x - the x coordinate of the circle

y - the y coordinate of the circle

radius - rank 0 dataset

Returns:

QDataSet that when plotted is a circle.

circle
```
public static QDataSet circle(QDataSet radius)
```
return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.

Parameters:

radius - rank 0 dataset

Returns:

QDataSet that when plotted is a circle.

circle
```
public static QDataSet circle(double dradius)
```
return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.

Parameters:

dradius - a real number representing the dimensionless radius

Returns:

QDataSet that when plotted is a circle.

circle
```
public static QDataSet circle(java.lang.String sradius)
                       throws java.text.ParseException
```
return a dataset with X and Y forming a circle, introduced as a convenient way to indicate planet location.

Parameters:

sradius - string parsed into rank 0 dataset

Returns:

QDataSet that when plotted is a circle.

Throws:

java.text.ParseException

ellipse
```
public static QDataSet ellipse(double xwidth,
                               double ywidth)
```
return a dataset with X and Y forming a ellipse, introduced as a convenient way to indicate planet location of any planet, according to Masafumi.

Parameters:

xwidth - a real number representing the width of the ellipse in the X direction

ywidth - a real number representing the width of the ellipse in the Y direction

Returns:

QDataSet that when plotted is an ellipse.

copyProperties
```
public static java.util.Map<java.lang.String,java.lang.Object> copyProperties(QDataSet ds)
```
copies the properties, copying depend datasets as well. TODO: This is not thorough, and this needs to be reviewed.

Parameters:

ds - the data from which the properties are extracted.

Returns:

a map of the properties.

See Also:

DataSetUtil.getProperties(org.das2.qds.QDataSet)

copyIndexedProperties
```
public static void copyIndexedProperties(QDataSet srcds,
                                         MutablePropertyDataSet mds)
```
copy over all the indexed properties into the mutable property dataset. This was introduced to support DataSetOps.unbundle, but should probably always be used. See https://sourceforge.net/p/autoplot/bugs/1704/

Parameters:

srcds - the source dataset

mds - the destination dataset

copy
```
public static WritableDataSet copy(QDataSet src)
```
copy the dataset to make a new one that is writable. When a join dataset is copied, a WritableJoinDataSet is used to copy each dataset. This is a deep copy, so for example DEPEND_0 is copied as well. Note that BufferDataSets will be copied to BufferDataSets, and ArrayDataSets will be copied to ArrayDataSets.

Parameters:

src -

Returns:

a copy of src.

maybeCopy
```
public static WritableDataSet maybeCopy(QDataSet ads0)
```
Copy the dataset to an ArrayDataSet only if the dataset is not already an ArrayDataSet or BufferDataSet. Note this does not consider the mutability of the data. If the dataset is not mutable, then the original data could be returned (probably).

Parameters:

ads0 - a dataset.

Returns:

an ArrayDataSet or BufferDataSet

sortInTime
```
public static QDataSet sortInTime(QDataSet ds)
```
pick out the timetags and sort the data based on these. This only works when a dataset has DEPEND_0.

Parameters:

ds - a dataset with tags in DEPEND_0.

Returns:

the data sorted by DEPEND_0.

monotonicSubset
```
public static MutablePropertyDataSet monotonicSubset(QDataSet ds)
```
ensure that there are no non-monotonic or repeat records, by removing the first N-1 records of N repeated records. Warning: this was extracted from AggregatingDataSource to support BufferDataSets, and is minimally implemented. When ds has property QDataSet.DEPEND_0, then this is used to identify the monotonic subset. When ds is a set of timetags, then these are used.

Parameters:

ds - MutablePropertyDataSet, which must be writable.

Returns:

dataset, possibly with records removed.

sin
```
public static QDataSet sin(QDataSet ds)
```
element-wise sin.

Parameters:

ds - the angles in radians or degrees, and data without units are treated as radians.

Returns:

the sin of the angles

sin
```
public static double sin(double ds)
```
return the sin of the real number, which is to be in radians.

Parameters:

ds - the angle in radians

Returns:

the sin of the angle

See Also:

Math.sin(double)

sin

public static QDataSet sin(java.lang.Object ds)

asin
```
public static QDataSet asin(QDataSet ds)
```
element-wise arcsin, the inverse of the sin function.

Parameters:

ds - the values

Returns:

the angles for the values in radians

See Also:

Math.asin(double)

asin
```
public static double asin(double ds)
```
return the asin of the real number in radians.

Parameters:

ds - the sin of the angle

Returns:

the angle in radians

asin

public static QDataSet asin(java.lang.Object ds)

cos
```
public static QDataSet cos(QDataSet ds)
```
element-wise cos.

Parameters:

ds - the angles in radians or degrees, and data without units are treated as radians.

Returns:

the cos of the angles

cos
```
public static double cos(double ds)
```
return the cos of the real number, which is to be in radians.

Parameters:

ds - the angle in radians

Returns:

the cos of the angle

See Also:

Math.cos(double)

cos

public static QDataSet cos(java.lang.Object ds)

acos
```
public static QDataSet acos(QDataSet ds)
```
element-wise arccos, the inverse of the cos function.

Parameters:

ds - the values

Returns:

the angles for the values in radians

See Also:

Math.acos(double)

acos
```
public static double acos(double ds)
```
return the acos of the real number in radians.

Parameters:

ds - the cos of the angle

Returns:

the angle in radians

acos

public static QDataSet acos(java.lang.Object ds)

tan
```
public static QDataSet tan(QDataSet ds)
```
element-wise trigonometric tangent (tan) function

Parameters:

ds - the angles for the values in radians or degrees

Returns:

the tangent of each angle

See Also:

Math.tan(double)

tan
```
public static double tan(double ds)
```
return the trigonometric tangent of the real number in radians.

Parameters:

ds - the angle in radians

Returns:

the tan in radians

tan

public static QDataSet tan(java.lang.Object ds)

atan
```
public static QDataSet atan(QDataSet ds)
```
element-wise arc tangent function

Parameters:

ds - the values

Returns:

the angles in radians

See Also:

Math.atan(double)

atan
```
public static double atan(double ds)
```
arc tangent function

Parameters:

ds - the value

Returns:

the angle in radians

See Also:

Math.atan(double)

atan

public static QDataSet atan(java.lang.Object ds)

atan2
```
public static QDataSet atan2(QDataSet y,
                             QDataSet x)
```
element-wise atan2, 4-quadrant atan. From the Java atan2 documentation: "Returns the angle theta from the conversion of rectangular coordinates (x, y) to polar coordinates (r, theta). This method computes the phase theta by computing an arc tangent of y/x in the range of -pi to pi."
Note different languages have different argument order. Microsoft Office uses atan2(x,y); IDL uses atan(y,x); Matlab uses atan2(y,x); and NumPy uses arctan2(y,x).

Parameters:

y - the y values

x - the x values

Returns:

angles between -PI and PI

See Also:

Math.atan2(double, double)

atan2
```
public static double atan2(double y,
                           double x)
```
4-quadrant arc tangent. From the Java atan2 documentation: "Returns the angle theta from the conversion of rectangular coordinates (x, y) to polar coordinates (r, theta). This method computes the phase theta by computing an arc tangent of y/x in the range of -pi to pi."
Note different languages have different argument order. Microsoft Office uses atan2(x,y); IDL uses atan(y,x); Matlab uses atan2(y,x); and NumPy uses arctan2(y,x).

Parameters:

y - the y position

x - the x position

Returns:

the angle in radians

See Also:

Math.atan2(double, double)

atan2

public static QDataSet atan2(java.lang.Object dsy,
                             java.lang.Object dsx)

cosh
```
public static QDataSet cosh(QDataSet ds)
```
element-wise hyperbolic cosine

Parameters:

ds - the data

Returns:

the hyperbolic cosine of each element of ds

See Also:

Math.cosh(double)

cosh
```
public static double cosh(double ds)
```

cosh

public static QDataSet cosh(java.lang.Object ds)

sinh

public static QDataSet sinh(QDataSet ds)

element-wise sinh.

Parameters:: ds -
Returns:

sinh
```
public static double sinh(double ds)
```

sinh

public static QDataSet sinh(java.lang.Object ds)

tanh

public static QDataSet tanh(QDataSet ds)

element-wise tanh.

Parameters:: ds -
Returns:

tanh
```
public static double tanh(double ds)
```

tanh

public static QDataSet tanh(java.lang.Object ds)

expm1
```
public static QDataSet expm1(QDataSet xx)
```
Returns e^xx -1. Note that for values of x near 0, the exact sum of expm1(x) + 1 is much closer to the true result of e^xx than exp(x).

Parameters:

xx - the values

Returns:

the values e^x -1

expm1
```
public static double expm1(double x)
```
Returns e^x -1. Note that for values of x near 0, the exact sum of expm1(x) + 1 is much closer to the true result of e^x than exp(x).

Parameters:

x - a double

Returns:

e^x -1

expm1
```
public static QDataSet expm1(java.lang.Object x)
```
Returns e^x -1. Note that for values of x near 0, the exact sum of expm1(x) + 1 is much closer to the true result of e^x than exp(x).

Parameters:

x - an object which can be interpretted as a double or dataset.

Returns:

e^x -1

getQubeDimsForArray
```
public static int[] getQubeDimsForArray(java.lang.Object arg0)
```
return the length of each index of a n-D array. In Java these are arrays of arrays, and no test is made to verify that the array is really a qube. This was introduced when it appeared that Python/jpype was producing arrays without the getClass method. For example, if we have an array of 3 arrays, each having 5 elements, then [ 3,5 ] is returned.

Parameters:

arg0 - an array, or array of arrays, or array of array of arrays, etc.

Returns:

the n dimensions of each index of the array.

dataset
```
public static QDataSet dataset(java.lang.Object arg0)
```
coerce Java objects like arrays Lists and scalars into a QDataSet. This is introduced to mirror the useful Jython dataset command. This is a nasty business that is surely going to cause all sorts of problems, so we should do it all in one place. See http://jfaden.net/jenkins/job/autoplot-test029/ This supports:
- int, float, double, etc to Rank 0 datasets
- List<Number> to Rank 1 datasets.
- Java arrays of Number to Rank 1-4 qubes datasets
- Strings to rank 0 datasets with units ("5 s" or "2014-01-01T00:00")
- Datums to rank 0 datasets
- DatumRanges to rank 1 bins
- DatumVector to rank 1 datasets.
Parameters:

arg0 - null,QDataSet,Number,Datum,DatumRange,String,List,or array.

Returns:

QDataSet

Throws:

java.lang.IllegalArgumentException - if the argument cannot be parsed or converted.

dataset
```
public static QDataSet dataset(java.lang.Object arg0,
                               Units u)
```
coerce Java objects like arrays Lists and scalars into a QDataSet. This is introduced to mirror the useful Jython dataset command. This is a nasty business that is surely going to cause all sorts of problems, so we should do it all in one place. See https://cottagesystems.com/jenkins/job/autoplot-test029/ This supports:
- int, float, double, etc to Rank 0 datasets
- List<Number> to Rank 1 datasets.
- Java arrays of Number to Rank 1-4 qubes datasets
- Strings to rank 0 datasets with units ("5 s" or "2014-01-01T00:00")
- Datums to rank 0 datasets
- DatumRanges to rank 1 bins
Parameters:

arg0 - null,QDataSet,Number,Datum,DatumRange,String,List,or array.

u - units providing context

Returns:

QDataSet

Throws:

java.lang.IllegalArgumentException - if the argument cannot be parsed or converted.

See Also:

JythonOps#dataset(PyObject, org.das2.datum.Units)

datum
```
public static Datum datum(java.lang.Object arg0)
```
coerce Java objects like numbers and strings into a Datum. This is introduced to mirror the useful Jython dataset command. This is a nasty business that is surely going to cause all sorts of problems, so we should do it all in one place. See https://cottagesystems.com/jenkins/job/autoplot-test029/ This supports:
- int, float, double, etc to Rank 0 datasets
- Strings to rank 0 datasets with units ("5 s" or "2014-01-01T00:00")
- rank 0 datasets
Parameters:

arg0 - null,QDataSet,Number,Datum, or String.

Returns:

Datum

Throws:

java.lang.IllegalArgumentException - if the argument cannot be parsed or converted.

datumRange
```
public static DatumRange datumRange(java.lang.Object arg0)
```
coerce Java objects like arrays and strings into a DatumRange. This is introduced to mirror the useful Jython dataset command. This is a nasty business that is surely going to cause all sorts of problems, so we should do it all in one place. See https://cottagesystems.com/jenkins/job/autoplot-test029/ This supports:
- 2-element rank 1 QDataSet
- Strings like ("5 to 15 s" or "2014-01-01")
- 2-element arrays and lists
Parameters:

arg0 - null, QDataSet, String, array or List.

Returns:

DatumRange

Throws:

java.lang.IllegalArgumentException - if the argument cannot be parsed or converted.

See Also:

boundsDataset(java.lang.String)

toRadians
```
public static QDataSet toRadians(QDataSet ds)
```
convert the data to radians by multiplying each element by PI/180. This does not check the units of the data, but a future version might.

Parameters:

ds - data values in degrees

Returns:

the data in radians

toRadians

public static QDataSet toRadians(java.lang.Object ds)

toDegrees
```
public static QDataSet toDegrees(QDataSet ds)
```
convert the data to degrees by multiplying each element by 180/PI. This does not check the units of the data, but a future version might.

Parameters:

ds - values in radians

Returns:

the data in degrees

toDegrees

public static QDataSet toDegrees(java.lang.Object ds)

imax
```
public static int imax(QDataSet ds)
```
return the index of the maximum value. This is to avoid inefficient code like "where(slice.eq( max(slice) ))[0]"

Parameters:

ds - rank 1 dataset

Returns:

the index of the maximum value, or -1 if the data is all fill.

imax

public static int imax(java.lang.Object ds)

imin
```
public static int imin(QDataSet ds)
```
return the index of the minimum value. This is to avoid inefficient code like "where(slice.eq( min(slice) ))[0]"

Parameters:

ds - rank 1 dataset

Returns:

the index of the maximum value, or -1 if the data is all fill.

imin

public static int imin(java.lang.Object ds)

subset
```
public static QDataSet subset(QDataSet ds,
                              QDataSet w)
```
return the data at the indices given. This will be a rank 1 QDataSet. Often the indices are created with the "where" function, for example: QDataSet r= Ops.subset( ds, Ops.where( Ops.gt( ds, 1 ) ) ) will return the subset of ds where ds is greater than 1.

Parameters:

ds - rank N array, N > 0.

w - rank 1 dataset of length l indexing a rank 1 array, or rank 2 ds[l,N] indexing a rank N array.

Returns:

rank 1 indices.

See Also:

applyIndex, which does the same thing.

whereR1
```
public static QDataSet whereR1(QDataSet ds)
```
returns a dataset containing the indices of where the dataset is non-zero. This is used when the code using this assumes a rank 1 result.

Parameters:

ds - a rank 1 QDataSet

Returns:

rank 1 array of index where the data is valid and non-zero.

See Also:

where(org.das2.qds.QDataSet)

where
```
public static QDataSet where(QDataSet ds)
```
returns a dataset containing the indices of where the dataset is non-zero. For a rank 1 dataset, returns a rank 1 dataset with indices for the values. For a higher rank dataset, returns a rank 2 qube dataset with ds.rank() elements in the first dimension. Note when the dataset is all zeros (false), the result is a zero-length array, as opposed to IDL which would return a -1 scalar. Note fill values are not included in the list, so it is not necessary that where(A).length + where(not A).length != where( A.or(not(A) ).length Note this is different from the SciPy "where" and similar to Matlab "find."

Parameters:

ds - of any rank M, M>0.

Returns:

a rank 1 or rank 2 dataset with N by M elements, where N is the number of non-zero elements found.

See Also:

putValues(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

where

public static QDataSet where(java.lang.Object ds)

withinSet
```
public static QDataSet withinSet(QDataSet ds,
                                 QDataSet set)
```
returns 1 where the dataset contains elements within the set, 0 where elements are not within the set. Note this cannot be used to check for fill data.

Parameters:

ds - a dataset

set - a dataset, typically rank 1, of values.

Returns:

1 where the dataset contains elements within the set, 0 otherwise.

See Also:

not(org.das2.qds.QDataSet), within(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

within
```
public static QDataSet within(QDataSet ds,
                              QDataSet bounds)
```
return non-zero where the data in ds are within the bounds. In Jython,
```
print within( [0,1,2,3,4], '2 to 4' ) --> [ 0,0,1,1,0 ]
print within( ttag, 'orbit:rbspa-pp:172' )
```
Parameters:

ds - rank N dataset where N > 0

bounds - a rank 1 bounding box, or rank 2 array of bounding boxes, or rank 2 events list

Returns:

rank N dataset containing non-zero where the condition is true.

See Also:

without(org.das2.qds.QDataSet, org.das2.qds.QDataSet), binsWithin(org.das2.qds.QDataSet, org.das2.qds.QDataSet), withinSet(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

within
```
public static QDataSet within(java.lang.Object ds,
                              java.lang.Object bounds)
```
return non-zero where the data in ds are within the bounds. In Jython,
```
print within( [0,1,2,3,4], '2 to 4' ) --> [ 0,0,1,1,0 ]
print within( ttag, 'orbit:rbspa-pp:172' )
```
Note, before March 2, 2015, this would incorrectly return the where of the result.
Parameters:

ds - object which can be converted to rank N dataset where N > 0

bounds - a rank 1 bounding box, DatumRange, or two-element array.

Returns:

rank N dataset containing non-zero where the condition is true.

See Also:

without(org.das2.qds.QDataSet, org.das2.qds.QDataSet), where(java.lang.Object), binsWithin(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

binsWithin
```
public static QDataSet binsWithin(QDataSet ds,
                                  QDataSet bounds)
```
return non-zero where the bins of ds are within the bounds.

Parameters:

ds - rank 2 bins dataset

bounds - a rank 1 bounding box.

Returns:

rank 1 dataset containing non-zero where the condition is true.

See Also:

within(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

without
```
public static QDataSet without(QDataSet ds,
                               QDataSet bounds)
```
return non-zero where the data in ds are outside of the bounds. In Jython,
```
print without( [0,1,2,3,4], '2 to 4' ) --> [ 1,1,0,0,1 ]
print without( ttag, 'orbit:rbspa-pp:172' )
```
Note if bounds contain fill, then everything is fill.
Parameters:

ds - rank N dataset where N > 0

bounds - a rank 1 bounding box.

Returns:

rank N dataset containing non-zero where the condition is true.

See Also:

within(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

without
```
public static QDataSet without(java.lang.Object ds,
                               java.lang.Object bounds)
```
return non-zero where the data in ds are outside of the bounds. In Jython,
```
print without( [0,1,2,3,4], '2 to 4' ) --> [ 1,1,0,0,1 ]
print without( ttag, 'orbit:rbspa-pp:172' )
```
Note if bounds contain fill, then everything is fill.
Parameters:

ds - rank N dataset where N > 0

bounds - a rank 1 bounding box.

Returns:

rank N dataset containing non-zero where the condition is true.

See Also:

within(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

binsWithout
```
public static QDataSet binsWithout(QDataSet ds,
                                   QDataSet bounds)
```
return non-zero where the bins of ds are outside of the bounds.

Parameters:

ds - rank 2 bins dataset

bounds - a rank 1 bounding box.

Returns:

rank 1 dataset containing non-zero where the condition is true.

See Also:

binsWithin(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

sort
```
public static QDataSet sort(QDataSet ds)
```
returns a rank 1 dataset of indices that sort the rank 1 dataset ds. This is not the dataset sorted. For example:
```
ds= randn(2000)
s= sort( ds )
dsSorted= ds[s]
```
Note the result will have the property MONOTONIC==Boolean.TRUE if the data was sorted already.
Parameters:

ds - rank 1 dataset

Returns:

rank 1 dataset of indices that sort the input dataset.

See Also:

shuffle(org.das2.qds.QDataSet)

sort

public static QDataSet sort(java.lang.Object ds)

uniq
```
public static QDataSet uniq(QDataSet ds)
```
Return the unique indices from the rank 1 dataset. If the set is not monotonic, then return unique indices from the monotonic portions.

Parameters:

ds - rank 1 dataset, sorted, or mostly sorted.

Returns:

the element indices.

See Also:

sort(java.lang.Object), uniq(org.das2.qds.QDataSet, org.das2.qds.QDataSet), uniqValues(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

hashcodes
```
public static QDataSet hashcodes(QDataSet ds)
```
return a rank 1 hashcodes of each record the dataset, with one hashcodes value for each record. The value of hashcodes should repeat if the record repeats. For a rank 1 dataset, the values are returned. NOTE: This is under-implemented and should not be used without understanding the code.

Parameters:

ds - dataset with rank greater than 0.

Returns:

rank 1 dataset.

uniq
```
public static QDataSet uniq(QDataSet ds,
                            QDataSet sort)
```
Return the unique indices from the rank 1 dataset, using sort to resort the indices. If sort is null, then the dataset is assumed to be monotonic, and only repeating values are coalesced. If sort is non-null, then it is the result of the function "sort" and should be a rank 1 list of indices that sort the data.

Parameters:

ds - rank 1 dataset, sorted, or mostly sorted.

sort - null, or the rank 1 dataset of indices

Returns:

the indices of the unique elements.

See Also:

uniqValues, which returns the values.

uniqValues
```
public static QDataSet uniqValues(QDataSet ds,
                                  QDataSet sort)
```
return the unique elements from the dataset. If sort is null, then the dataset is assumed to be monotonic, and only repeating values are coalesced. If sort is non-null, then it is the result of the function "sort" and should be a rank 1 list of indices that sort the data. renamed uniqValues from uniq to avoid confusion with the IDL command. This needs example code and should not be used for now. See VirboAutoplot/src/scripts/test/testUniq.jy

Parameters:

ds - rank 1 dataset, sorted, or mostly sorted.

sort - null, or the rank 1 dataset of indices

Returns:

the subset of the data which is uniq.

See Also:

uniq, which returns the indices., uniq(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

getProperty
```
public static java.lang.Object getProperty(QDataSet ds,
                                           java.lang.String name)
```
retrieve a property from the dataset. This was introduced for use in the Data Mash Up tool.

Parameters:

ds - the dataset

name - the property name

Returns:

the property or null (None) if the dataset doesn't have the property.

putProperty
```
public static MutablePropertyDataSet putProperty(java.lang.Object ds,
                                                 java.lang.String name,
                                                 java.lang.Object value)
```
converts types often seen in Jython and Java codes to the correct type. For example,
```
ds= putProperty( [1400,2800], 'UNITS', 'seconds since 2012-01-01')
```
will convert the string 'seconds since 2012-01-01' into a Unit before assigning it to the dataset.
Parameters:

ds - the object which can be interpreted as a dataset, such as a number or array of numbers.

name - the property name

value - the property value, which can converted to the proper type.

Returns:

the dataset, possibly converted to a mutable dataset.

putProperty
```
public static MutablePropertyDataSet putProperty(QDataSet ds,
                                                 java.lang.String name,
                                                 java.lang.Object value)
```
converts types often seen in Jython and Java codes to the correct type. For example, ds= putProperty( ds, 'UNITS', 'seconds since 2012-01-01'). The dataset may be copied to make it mutable.

Parameters:

ds - the dataset to which the property is to be set.

name - the property name

value - the property value, which can converted to the proper type.

Returns:

the dataset, possibly converted to a mutable dataset.

convertPropertyValue
```
public static java.lang.Object convertPropertyValue(QDataSet context,
                                                    java.lang.String name,
                                                    java.lang.Object value)
```
convert the object into the type needed for the property.

Parameters:

context - the dataset to which we are assigning the value.

name - the property name

value - the value

Returns:

the correct value.

See Also:

PyQDataSet.convertPropertyValue(org.das2.qds.QDataSet, java.lang.String, java.lang.Object)

putIndexedProperty
```
public static MutablePropertyDataSet putIndexedProperty(QDataSet ds,
                                                        java.lang.String name,
                                                        int index,
                                                        java.lang.Object value)
```
Like putProperty, but this inserts the value at the index. This was introduced to make it easier to work with bundles. This converts types often seen in Jython and Java codes to the correct type. For example, bds= putProperty( bds, 'UNITS', 0, 'seconds since 2012-01-01'). The dataset may be copied to make it mutable.

Parameters:

ds - the dataset to which the property is to be set.

name - the property name

index - the property index

value - the property value, which can converted to the proper type.

Returns:

the dataset, possibly converted to a mutable dataset.

putBundleProperty
```
public static MutablePropertyDataSet putBundleProperty(QDataSet ds,
                                                       java.lang.String name,
                                                       int index,
                                                       java.lang.Object value)
```
Like putIndexedProperty, but manages the bundle for the client. This was introduced to make it easier to work with bundles. This converts types often seen in Jython and Java codes to the correct type. For example, ds= putBundleProperty( ds, 'UNITS', 0, 'seconds since 2012-01-01'). The dataset may be copied to make it mutable. If the bundle descriptor dataset is not found, it is added, making the rank 2 dataset a bundle.

Parameters:

ds - the rank 1 or rank 2 bundle dataset to which the property is to be set.

name - the property name

index - the property index

value - the property value, which can converted to the proper type.

Returns:

the dataset, possibly converted to a mutable dataset.

putValues
```
public static WritableDataSet putValues(java.lang.Object ds,
                                        java.lang.Object indices,
                                        java.lang.Object values)
```
like putProperty, but this inserts values into the dataset. If the dataset is not mutable, then this will make a copy of the data and return the copy.

Parameters:

ds - the rank 1 or greater dataset

indices - rank 1 indices when ds is rank 1, or rank 2 [:,m] indices for a rank m dataset.

values - null for fill, or the rank 0 value or rank 1 values to assign.

Returns:

the dataset with the indices assigned new values.

See Also:

where(org.das2.qds.QDataSet), removeValues(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

putValues
```
public static WritableDataSet putValues(QDataSet ds,
                                        QDataSet indices,
                                        QDataSet value)
```
like putProperty, but this inserts values into the dataset. If the dataset is not mutable, then this will make a copy of the data and return the copy.

Parameters:

ds - the rank 1 or greater dataset

indices - rank 1 indices when ds is rank 1, or rank 2 [:,m] indices for a rank m dataset.

value - null for fill, or the rank 0 value or rank 1 values to assign.

Returns:

the dataset with the indices assigned new values.

See Also:

where(org.das2.qds.QDataSet), removeValues(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

removeValues
```
public static WritableDataSet removeValues(QDataSet ds,
                                           QDataSet indices)
```
put fill data for these indices

Parameters:

ds - the rank 1 or greater dataset

indices - rank 1 indices when ds is rank 1, or rank 2 [:,m] indices for a rank m dataset.

Returns:

the dataset with the data at the indices made invalid.

See Also:

putValues(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet), where(org.das2.qds.QDataSet), which copies the data to remove the indices.

removeValues

public static WritableDataSet removeValues(java.lang.Object ds,
                                           java.lang.Object indices)

removeValuesGreaterThan
```
public static WritableDataSet removeValuesGreaterThan(QDataSet ds,
                                                      QDataSet v)
```
remove values in the dataset which are greater than the value. This is a convenient method for the common case where we want to filter data by values within the data, introduced to support the data mash up dialog.

Parameters:

ds - rank N dataset

v - the value, a rank 0 scalar or dataset with compatible geometry

Returns:

the dataset with these

removeValuesGreaterThan

public static WritableDataSet removeValuesGreaterThan(java.lang.Object ds,
                                                      java.lang.Object v)

removeValuesLessThan
```
public static WritableDataSet removeValuesLessThan(QDataSet ds,
                                                   QDataSet v)
```
remove values in the dataset which are less than the value. This is a convenient method for the common case where we want to filter data by values within the data, introduced to support the data mash up dialog. Note that this inserts fill where data is to be removed.

Parameters:

ds - rank N dataset

v - the value, a rank 0 scalar or dataset with compatible geometry

Returns:

the dataset with these

removeValuesLessThan

public static WritableDataSet removeValuesLessThan(java.lang.Object ds,
                                                   java.lang.Object v)

removeFill
```
public static WritableDataSet removeFill(QDataSet ds)
```
remove the fill values from the rank 1 dataset, returning a smaller dataset. This was introduced to support the mash-up dialog.

Parameters:

ds - the dataset, with VALID_MIN, VALID_MAX, or FILL_VALUE indicating the invalid data points.

Returns:

dataset with the values removed.

applyIndex
```
public static WritableDataSet applyIndex(QDataSet vv,
                                         QDataSet ds,
                                         java.lang.Number fillValue)
```
apply the indices, checking for out-of-bounds values.

Parameters:

vv - values to return, a rank 1, N-element dataset.

ds - the indices.

fillValue - the value to use when the index is out-of-bounds.

Returns:

data a dataset with the geometry of ds and the units of values.

See Also:

subset, which does the same thing., applyIndex(org.das2.qds.QDataSet, int, org.das2.qds.QDataSet)

applyIndex
```
public static WritableDataSet applyIndex(QDataSet ds,
                                         QDataSet r)
```
apply the indices to the dataset, resorting the 0th dimension using the indices of r.

Parameters:

ds - values to return, a rank 1 N-element dataset, or rank 2 N by m element dataset.

r - the indices.

Returns:

data a dataset with the geometry of ds and the units of values.

See Also:

subset, which does the same thing., applyIndex(org.das2.qds.QDataSet, int, org.das2.qds.QDataSet)

applyIndex
```
public static WritableDataSet applyIndex(java.lang.Object dso,
                                         QDataSet r)
```
apply the indices

Parameters:

dso - values to return, a rank 1, N-element dataset.

r - the indices.

Returns:

data a dataset with the geometry of ds and the units of values.

See Also:

applyIndex(org.das2.qds.QDataSet, int, org.das2.qds.QDataSet)

applyIndex
```
public static MutablePropertyDataSet applyIndex(QDataSet ds,
                                                int dimension,
                                                QDataSet indices)
```
apply the indices to the given dimension.

Parameters:

ds - rank N qube of data.

dimension - the dimension on which the indices should be applied.

indices - the indices to apply.

Returns:

the data with in indices applied.

See Also:

https://github.com/autoplot/dev/blob/master/demos/2023/20230909/demoApplyIndex.jy, SubsetDataSet

removeIndeces
```
public static QDataSet removeIndeces(QDataSet vv,
                                     QDataSet indices)
```
remove the data at the indices from the rank 1 dataset. This can be used for example like so:
```
 
 ds= ripples(20)
 ds= removeIndeces( ds, where( valid(ds).eq(0) ) )
 print ds.length()
 
 
```
Parameters:

vv - a rank 1 dataset

indices - the indices to remove.

Returns:

a dataset with the values removed.

See Also:

https://github.com/autoplot/dev/blob/master/rfe/20190208/demoRemoveIndeces.jy, which inserts fill., where(org.das2.qds.QDataSet)

reverse
```
public static QDataSet reverse(QDataSet ds)
```
returns the reverse of the rank 1 dataset.

Parameters:

ds -

Returns:

reverse

public static QDataSet reverse(java.lang.Object ds)

shuffle
```
public static QDataSet shuffle(QDataSet ds)
```
returns a rank 1 dataset of indices that shuffle the rank 1 dataset ds.
```
s= shuffle( ds )
dsShuffled= ds[s]
```
Parameters:

ds - rank 1 dataset

Returns:

rank 1 dataset of integer indices.

See Also:

sort(org.das2.qds.QDataSet)

shuffle
```
public static QDataSet shuffle(java.lang.Object ds)
```
returns a rank 1 dataset of indices that shuffle the rank 1 dataset ds.
```
s= shuffle( ds )
dsShuffled= ds[s]
```
Parameters:

ds - an object which can be interpretted as a rank 1 dataset.

Returns:

rank 1 dataset of integer indices.

See Also:

sort(org.das2.qds.QDataSet)

slice0
```
public static QDataSet slice0(QDataSet ds,
                              int idx)
```
returns the slice at the given slice location.

Parameters:

ds - the rank N (N>0) or more dataset

idx - the index

Returns:

rank N-1 dataset

See Also:

QDataSet.slice(int)

slice0
```
public static QDataSet slice0(QDataSet ds,
                              QDataSet sliceds)
```
returns the slice at the given slice location. The dataset must have monotonic DEPEND_0.

Parameters:

ds - ripples(20,20). Presently this must be a simple table.

sliceds - dataset("10.3")

Returns:

the slice at the given location

See Also:

trim(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

slice1
```
public static QDataSet slice1(QDataSet ds,
                              int idx)
```
returns the slice at the given slice location.

Parameters:

ds - the rank N where N≥2 dataset, which is also a qube.

idx - the index to slice at.

Returns:

rank N-1 dataset.

See Also:

DataSetOps.slice1(org.das2.qds.QDataSet, int)

slice1
```
public static QDataSet slice1(QDataSet ds,
                              QDataSet sliceds)
```
returns the slice at the given slice location.

Parameters:

ds - the rank N where N≥2 dataset, which is also a qube.

sliceds - dataset("10.3")

Returns:

rank N-1 dataset.

slice2
```
public static QDataSet slice2(QDataSet ds,
                              int idx)
```
returns the slice at the given slice location.

Parameters:

ds - the rank N where N≥3 dataset, which is also a qube.

idx - the index to slice at.

Returns:

rank N-1 dataset.

See Also:

DataSetOps.slice2(org.das2.qds.QDataSet, int)

slice2
```
public static QDataSet slice2(QDataSet ds,
                              QDataSet sliceds)
```
returns the slice at the given slice location.

Parameters:

ds - ripples(20,20). Presently this must be a simple table.

sliceds - dataset("10.3")

Returns:

slice3
```
public static QDataSet slice3(QDataSet ds,
                              int idx)
```
returns the slice at the given slice location.

Parameters:

ds - the rank N where N≥4 dataset, which is also a qube.

idx - the index to slice at.

Returns:

rank N-1 dataset.

See Also:

DataSetOps.slice3(org.das2.qds.QDataSet, int)

slice3
```
public static QDataSet slice3(QDataSet ds,
                              QDataSet sliceds)
```
returns the slice at the given slice location.

Parameters:

ds - ripples(20,20). Presently this must be a simple table.

sliceds - dataset("10.3")

Returns:

fftFilter
```
public static QDataSet fftFilter(QDataSet ds,
                                 int len,
                                 Ops.FFTFilterType filt)
```
Apply windows to the data to prepare for FFT. The data is reformed into a rank 2 dataset [N,len]. The filter is applied to the data to remove noise caused by the discontinuity. This is deprecated, and windowFunction should be used so that the filter is applied to records just before each fft is performed to save space.

Parameters:

ds - rank 1, 2, or 3 data

len - size of the window.

filt - FFTFilterType.Hanning or FFTFilterType.TenPercentEdgeCosine

Returns:

data[N,len] with the window applied.

hanning
```
public static QDataSet hanning(QDataSet ds,
                               int len)
```
Apply Hanning (Hann) windows to the data to prepare for FFT. The data is reformed into a rank 2 dataset [N,len]. Hanning windows taper the ends of the interval to remove noise caused by the discontinuity. This is deprecated, and windowFunction should be used.

Parameters:

ds, - rank 1, 2, or 3 data

len -

Returns:

data[N,len] with the hanning window applied.

See Also:

windowFunction(org.das2.qds.ops.Ops.FFTFilterType, int)

fftPower
```
public static QDataSet fftPower(QDataSet ds,
                                int len,
                                ProgressMonitor mon)
```
create a power spectrum on the dataset by breaking it up and doing FFTs on each segment. A unity (or "boxcar") window is used. data may be rank 1, rank 2, or rank 3. Looks for DEPEND_1.USER_PROPERTIES.FFT_Translation, which should be a rank 0 or rank 1 QDataSet. If it is rank 1, then it should correspond to the DEPEND_0 dimension.

Parameters:

ds - rank 2 dataset ds(N,M) with M>len

len - the number of elements to have in each fft.

mon - a ProgressMonitor for the process

Returns:

rank 2 FFT spectrum

windowFunction
```
public static QDataSet windowFunction(Ops.FFTFilterType filt,
                                      int len)
```
return a dataset for the given filter type. The result will be rank 1 and length len.

Parameters:

filt - the type of the window, such as FFTFilterType.Hann or TenPercentEdgeCosine.TenPercentEdgeCosine

len - the length of the window.

Returns:

rank 1 QDataSet with length len.

See Also:

Ops.FFTFilterType

windowFunction
```
public static QDataSet windowFunction(java.lang.String type,
                                      int len)
```
return a dataset for the given filter type, added to support use in Jython. The result will be rank 1 and length len.

Parameters:

type - the type of the window, one of Hanning, Hann, TenPercentEdgeCosine, Unity or Boxcar.

len - the length of the window.

Returns:

rank 1 QDataSet with length len.

fftPower
```
public static QDataSet fftPower(QDataSet ds,
                                QDataSet window,
                                ProgressMonitor mon)
```
perform the fft with the window, using no overlap.

Parameters:

ds - rank 1,2 or 3 waveform dataset.

window - the window

mon - a ProgressMonitor for the process

Returns:

rank 2 fft spectrum

See Also:

fftPower(org.das2.qds.QDataSet, org.das2.qds.QDataSet, int, org.das2.util.monitor.ProgressMonitor), windowFunction(org.das2.qds.ops.Ops.FFTFilterType, int)

fftPower
```
public static QDataSet fftPower(QDataSet ds,
                                int windowLen,
                                int stepFraction,
                                java.lang.String windowName,
                                ProgressMonitor mon)
```
fftPower that matches the filter call (|fftPower(ds,len,stepFraction,windowName)).

Parameters:

ds - rank 2 dataset ds(N,M) with M>len

windowLen - the length of the window.

stepFraction - size, expressed as a fraction of the length (1 for no slide, 2 for half steps, 4 for quarters)

windowName - name for the window, including "Hanning" "Hann" "TenPercentEdgeCosine", "Unity", "Boxcar"

mon - a ProgressMonitor for the process

Returns:

rank 2 fft spectrum

See Also:

fftPower(org.das2.qds.QDataSet, org.das2.qds.QDataSet, int, org.das2.util.monitor.ProgressMonitor)

getProperty
```
public static <T> T getProperty(QDataSet ds,
                                java.lang.String propertyName,
                                java.lang.Class<T> clazz)
```
return the property, issuing a warning and returning null when the property value is not of the correct type.

Type Parameters:

T - the property value

Parameters:

ds - the dataset

propertyName - the property name

clazz - the class of the property.

Returns:

the property, guaranteed to be of the correct type, or null.

Throws:

java.lang.IllegalArgumentException - if the class given is not of the right type for the property.

fftPowerSpectralDensity

public static QDataSet fftPowerSpectralDensity(QDataSet ds,
                                               QDataSet window,
                                               int stepFraction,
                                               ProgressMonitor mon)

Perform the power spectral density function

Parameters:: ds - waveform data; window - the window to apply; stepFraction - advance by this much for each window (2 means 50% overlap, 4 means 75% overlap, etc.); mon - a progress monitor
Returns:: the power spectral density
See Also:: page 7

fftLinearSpectralDensity

public static QDataSet fftLinearSpectralDensity(QDataSet ds,
                                                QDataSet window,
                                                int stepFraction,
                                                ProgressMonitor mon)

Perform the linear spectral density function

Parameters:: ds - waveform data; window - the window to apply window to apply; stepFraction - advance by this much for each window (2 means 50% overlap, 4 means 75% overlap, etc.); mon - progress monitor
Returns:: the linear spectral density
See Also:: page 7

fftLinearSpectrum

public static QDataSet fftLinearSpectrum(QDataSet ds,
                                         QDataSet window,
                                         int stepFraction,
                                         ProgressMonitor mon)

Perform the linear spectrum function

Parameters:: ds - waveform data; window - the window to apply window to apply; stepFraction - advance by this much for each window (2 means 50% overlap, 4 means 75% overlap, etc.); mon - progress monitor
Returns:: the linear spectral density
See Also:: page 7

fftPowerSpectrum

public static QDataSet fftPowerSpectrum(QDataSet ds,
                                        QDataSet window,
                                        int stepFraction,
                                        ProgressMonitor mon)

Perform the linear spectrum function

Parameters:: ds - waveform data; window - the window to apply window to apply; stepFraction - advance by this much for each window (2 means 50% overlap, 4 means 75% overlap, etc.); mon - progress monitor
Returns:: the linear spectral density
See Also:: page 7

fftPower
```
public static QDataSet fftPower(QDataSet ds,
                                QDataSet window,
                                int stepFraction,
                                ProgressMonitor mon)
```
create a power spectrum on the dataset by breaking it up and doing FFTs on each segment. data may be rank 1, rank 2, or rank 3. Looks for DEPEND_1.USER_PROPERTIES.FFT_Translation, which should be a rank 0 or rank 1 QDataSet. If it is rank 1, then it should correspond to the DEPEND_0 dimension. This is used to indicate that the waveform collected with respect to a carrier tone, and the result should be translated. Normalization is done with non-unity windows. (See https://github.com/autoplot/dev/bugs/sf/1317/testWindowFunctionNormalization.jy )

Parameters:

ds - rank 2 dataset ds(N,M) with M>len, rank 3 with the same cadence, or rank 1.

window - window to apply to the data before performing FFT (Hann,Unity,etc.)

stepFraction - size, expressed as a fraction of the length (1 for no slide, 2 for half steps, 4 for quarters)

mon - a ProgressMonitor for the process

Returns:

rank 2 FFT spectrum, or rank 3 if the rank 3 input has differing cadences.

See Also:

Ops.FFTFilterType

fftPower
```
public static QDataSet fftPower(QDataSet ds)
```
returns the power spectrum of the waveform. Positive frequencies are returned for DEPEND_0, and square of the magnitude is returned for the values.

Parameters:

ds - rank 1 waveform or rank 2 array of waveforms

Returns:

rank 1 dataset, or rank 2 for rank 2 input.

fft
```
public static QDataSet fft(QDataSet ds)
```
Performs an FFT on the provided rank 1 dataset. A rank 2 dataset of complex numbers is returned. The data must not contain fill and must be uniformly spaced. DEPEND_0 is used to identify frequencies if available.

Parameters:

ds - a rank 1 dataset.

Returns:

a rank 2 dataset of complex numbers.

See Also:

Schemes.rank2ComplexNumbers(), ifft(org.das2.qds.QDataSet)

ifft
```
public static QDataSet ifft(QDataSet ds)
```
Performs an inverse FFT on the provided rank 2 dataset of complex numbers. A rank 2 dataset of complex numbers is returned.

Parameters:

ds - a rank 2 dataset.

Returns:

a rank 2 dataset of complex numbers.

See Also:

fft(org.das2.qds.QDataSet)

complexConj
```
public static final QDataSet complexConj(QDataSet ds)
```
return the complex conjugate of the rank 1 or rank 2 QDataSet.

Parameters:

ds - ds[2] or ds[n,2] or ds[n,m,2]

Returns:

ds[2] or ds[n,2] or ds[n,m,2]

See Also:

complexMultiply(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

complexMultiply
```
public static final QDataSet complexMultiply(QDataSet ds1,
                                             QDataSet ds2)
```
perform complex multiplication, where the two datasets must have the same rank and must both end with a complex dimension.

Parameters:

ds1 - ds[2] or ds[n,2] or ds[n,m,2]

ds2 - ds[2] or ds[n,2] or ds[n,m,2]

Returns:

ds[2] or ds[n,2] or ds[n,m,2]

See Also:

complexConj(org.das2.qds.QDataSet)

crossProduct
```
public static QDataSet crossProduct(QDataSet a,
                                    QDataSet b)
```
apply the cross product of a and b, where a or b may be rank 1, three-element vector, or both can be vector arrays of the same length. In the case where only X and Y are provided (two-element vectors instead of three), then Z is automatically assumed to be zero.

Parameters:

a - rank 1 ds[3] or rank 2 ds[n,3] or rank 3 ds[m,n,3]

b - rank 1 ds[3] or rank 2 ds[n,3] or rank 3 ds[m,n,3]

Returns:

ds[3] or rank 2 ds[n,3]

complexDataset
```
public static QDataSet complexDataset(QDataSet realPart,
                                      QDataSet imaginaryPart)
```
create a complex dataset.

Parameters:

realPart - the real component.

imaginaryPart - the complex component.

Returns:

complex dataset

See Also:

Schemes.rank2ComplexNumbers()

expandWaveform
```
public static QDataSet expandWaveform(QDataSet ds)
```
special function needed by the RPW Group at U. Iowa, which reassigns timetags so the small waveform packets are visible.

Parameters:

ds - rank 2 waveform

Returns:

See Also:

Schemes.rank2Waveform(), expandToFillGaps(org.das2.qds.QDataSet)

expandToFillGaps
```
public static QDataSet expandToFillGaps(QDataSet ds)
```
Special function by the RPW Group at U. Iowa, which reassigns timetags so the small waveform packets are visible, or bursty spectrograms are more easily viewed. This just calls expandToFillGaps with a 90 percent overlap (expandToFillGaps( ds, 0.9 )).

Parameters:

ds - the dataset

Returns:

the dataset with new DEPEND_0 values.

See Also:

expandWaveform(org.das2.qds.QDataSet)

expandToFillGaps
```
public static QDataSet expandToFillGaps(QDataSet ds,
                                        Datum cadenceMin,
                                        double multiplier)
```
Special function by the RPW Group at U. Iowa, which reassigns timetags so the small waveform packets are visible, or bursty spectrograms are more easily viewed. When there are gaps longer than twiceCadenceMin, multiply the timetags preceding by multiplier to fill the gap.

Parameters:

ds - the data, presumably containing burst of continuous packets between long gaps.

cadenceMin - sets threshold to identify continuous bursts of packets.

multiplier - the scale to by which to expand the packet into the gap.

Returns:

See Also:

expandToFillGaps(org.das2.qds.QDataSet, double)

expandToFillGaps
```
public static QDataSet expandToFillGaps(QDataSet ds,
                                        double factor)
```
Special self-configuring function by the RPW Group at U. Iowa, which reassigns timetags so the small waveform packets are visible, or bursty spectrograms are more easily viewed.

Parameters:

ds - the data, presumably containing burst of continuous packets between long gaps.

factor - duty cycle factor (0.5=50% duty cycle)

Returns:

ds with new timetags.

See Also:

expandWaveform(org.das2.qds.QDataSet), expandToFillGaps(org.das2.qds.QDataSet, org.das2.datum.Datum, double)

identifyContinuousBlocks
```
public static QDataSet identifyContinuousBlocks(Datum cadence,
                                                DatumRange extent,
                                                QDataSet lastBlocks,
                                                QDataSet times)
```
return events list containing start and stop times of continuous blocks in time. The parameter lastBlocks allows serial processing of data, so that intervals spanning extent boundaries will be correctly identified, once. If the last timetag of times is within the cadence of the stop of the extent, then this block will be dropped, but its start is noted in the property "partialBlockStart." If first timetag is within cadence of the start, then the last block of lastTimes will be added. Note the labels for each interval are the indices of the first and last (exclusive) continuous segment.

Parameters:

cadence - null or the cadence

extent - null or the interval containing the times.

lastBlocks - null or the preceding interval times.

times - the times for the interval

Returns:

an events list containing the start and stop times.

Throws:

java.lang.IllegalArgumentException - if the cadence cannot be guessed and cadence is not specified.

chirp

public static QDataSet chirp(QDataSet t,
                             Datum df0,
                             Datum dt1,
                             Datum df1)

SciPy chirp function, used for testing.

Parameters:: t - Times at which to evaluate the waveform.; df0 - Frequency (e.g. Hz) at time t=0.; dt1 - Time at which `f1` is specified.; df1 - Frequency (e.g. Hz) of the waveform at time `t1`.
Returns:

hilbertSciPy
```
public static QDataSet hilbertSciPy(QDataSet ds)
```
Perform the Hilbert function on the rank 1 dataset, similar to the scipy.signal.hilbert function in SciPy. The result is form differently than hilbert.

Parameters:

ds - rank 1 dataset of length n.

Returns:

ds[n,2], complex array

See Also:

hilbert(org.das2.qds.QDataSet)

hilbert
```
public static QDataSet hilbert(QDataSet ds)
```
Perform the Hilbert function on the rank 1 dataset, similar to the hilbert function in IDL and Matlab.

Parameters:

ds - rank 1 dataset of length n.

Returns:

ds[n,2], complex array

See Also:

hilbert(org.das2.qds.QDataSet)

unwrap
```
public static QDataSet unwrap(QDataSet ds,
                              double discont)
```
SciPy's unwrap function, used in demo of hilbertSciPy, which unwraps a function that exists in a modulo space so that the differences are minimal.

Parameters:

ds - rank 1 dataset, containing values from 0 to discont

discont - the discont, such as PI, TAU, 24, 60, 360, etc.

Returns:

isAngleRange
```
public static java.lang.Double isAngleRange(QDataSet ds,
                                            boolean strict)
```
return true if the dataset can be interpreted as radian degrees from 0 to PI or from 0 to 2*PI.

Parameters:

ds - any QDataSet.

strict - return null if it's not clear that the units are degrees.

Returns:

the multiplier to make the dataset into radians, or null.

polarToCartesian
```
public static QDataSet polarToCartesian(QDataSet ds)
```
converts a rank 2 bundle of polar data, where ds[:,0] are the radii and ds[:,1] are the angles. Any additional bundled datasets are left alone.

Parameters:

ds -

Returns:

bundle of X, Y, and remaining data.

ifft

public static QDataSet ifft(QDataSet ds,
                            QDataSet window,
                            int stepFraction,
                            ProgressMonitor mon)

create the inverse fft of the real and imaginary spec

Parameters:: ds - rank 3 dataset of N,FFTLength,2; window -; stepFraction -; mon -
Returns:

fft
```
public static QDataSet fft(QDataSet ds,
                           QDataSet window,
                           int stepFraction,
                           ProgressMonitor mon)
```
perform ffts on the waveform as we do with fftPower, but keep real and imaginary components.

Parameters:

ds - the waveform rank 1,2,or 3 dataset.

window - the window function, like ones(1024) or windowFunction( FFTFilterType.Hanning, 1024 ). This is used to infer window size.

stepFraction - step this fraction of the window size. 1 is no overlap, 2 is 50% overlap, 4 is 75% overlap, etc.

mon - progress monitor.

Returns:

result[ntime,nwindow,2]

fftWindow
```
public static QDataSet fftWindow(QDataSet ds,
                                 int len)
```
perform ffts on the rank 1 dataset to make a rank2 spectrogram.

Parameters:

ds - rank 1 dataset

len - the window length

Returns:

rank 2 dataset.

extent
```
public static QDataSet extent(QDataSet ds)
```
returns a two element, rank 1 dataset containing the extent of the data. Note this accounts for DELTA_PLUS, DELTA_MINUS properties. Note this accounts for BIN_PLUS, BIN_MINUS properties. The property QDataSet.SCALE_TYPE is set to lin or log. The property count is set to the number of valid measurements. TODO: this could use MONOTONIC, but it doesn't. DELTA_PLUS, DELTA_MINUS make that more difficult.

Parameters:

ds - the dataset to measure the extent

Returns:

two element, rank 1 "bins" dataset.

See Also:

DataSetUtil.rangeOfMonotonic(org.das2.qds.QDataSet), in Autoplot., reduceMax(org.das2.qds.QDataSet, int, org.das2.util.monitor.ProgressMonitor)

extent
```
public static QDataSet extent(QDataSet ds,
                              QDataSet range)
```
returns a two element, rank 1 dataset containing the extent (min to max) of the data. Note this accounts for DELTA_PLUS, DELTA_MINUS properties. Note this accounts for BIN_PLUS, BIN_MINUS properties. If no valid data is found then [fill,fill] is returned. The property QDataSet.SCALE_TYPE is set to lin or log. The property count is set to the number of valid measurements. 2010-10-14: add branch for monotonic datasets.

Parameters:

ds - the dataset to measure the extent

range - if non-null, return the union of this range and the extent. This must not contain fill!

Returns:

two element, rank 1 "bins" dataset.

extentSimple
```
public static QDataSet extentSimple(QDataSet ds,
                                    QDataSet wds,
                                    QDataSet range)
```
like extent, but does not account for DELTA_PLUS, DELTA_MINUS, BIN_PLUS, BIN_MINUS, BIN_MIN or BIN_MAX properties. This was introduced to provide a fast way to identify constant datasets and the extent that non-constant datasets vary.

Parameters:

ds - the dataset to measure the extent rank 1 or rank 2 bins

wds - a weights dataset, containing zero where the data is not valid, positive non-zero otherwise. If null, then all finite data is treated as valid.

range - if non-null, return the union of this range and the extent. This must not contain fill!

Returns:

two element, rank 1 "bins" dataset.

See Also:

extent(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

extent
```
public static QDataSet extent(QDataSet ds,
                              QDataSet wds,
                              QDataSet range)
```
returns a two element, rank 1 dataset containing the extent (min to max) of the data, allowing an external evaluation of the weightsDataSet. If no valid data is found then [fill,fill] is returned.

Parameters:

ds - the dataset to measure the extent rank 1 or rank 2 bins

wds - a weights dataset, containing zero where the data is not valid, positive non-zero otherwise. If null, then all finite data is treated as valid.

range - if non-null, return the union of this range and the extent. This must not contain fill!

Returns:

two element, rank 1 "bins" dataset.

See Also:

reduceMax(org.das2.qds.QDataSet, int, org.das2.util.monitor.ProgressMonitor)

extent445
```
public static QDataSet extent445(QDataSet ds)
```
Deprecated. use extentSimple

fast extent needed at some point, which will be removed. It simply calls extentSimple.

Parameters:

ds - a dataset.

Returns:

the extent of the data.

See Also:

extentSimple(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

extentSimple
```
public static QDataSet extentSimple(QDataSet ds,
                                    QDataSet range)
```
This is introduced to study effect of https://sourceforge.net/p/autoplot/feature-requests/445/ Do not use this in scripts!!! This is very interesting: Ops.extent: 53ms simpleRange: 77ms study445FastRange: 4ms Ops.extent: 76ms simpleRange: 114ms study445FastRange: 12ms This is likely showing that DataSetIterator is slow...

Parameters:

ds - the dataset

range - null, or rank 1 bins dataset

Returns:

rank 1, two-element range, or when all data is fill result[0] will be Double.POSITIVE_INFINITY.

See Also:

extentSimple(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

rescale

public static QDataSet rescale(QDataSet data,
                               QDataSet min,
                               QDataSet max)

calculate the range of data, then rescale it so that the smallest values becomes min and the largest values becomes max.

Parameters:: data - rank N dataset; min - rank 0 min; max - rank 0 max
Returns:: rescaled data.

rescaleRange
```
public static QDataSet rescaleRange(QDataSet dr,
                                    double min,
                                    double max)
```
returns rank 1 QDataSet range relative to range "dr", where 0. is the minimum, and 1. is the maximum. For example rescaleRange(ds,1,2) is scanNext, rescaleRange(ds,0.5,1.5) is zoomOut. This is similar to the DatumRange rescale functions.

Parameters:

dr - a QDataSet with bins and with nonzero width.

min - the new min normalized with respect to this range. 0. is this range's min, 1 is this range's max, -1 is min-width.

max - the new max normalized with respect to this range. 0. is this range's min, 1 is this range's max, -1 is min-width.

Returns:

new rank 1 QDataSet range.

rescaleRangeLogLin

public static QDataSet rescaleRangeLogLin(QDataSet dr,
                                          double min,
                                          double max)

like rescaleRange, but look at log/lin flag.

Parameters:: dr -; min -; max -
Returns:: two-element rank 1 QDataSet
See Also:: QDataSet.SCALE_TYPE

histogram2d
```
public static QDataSet histogram2d(QDataSet x,
                                   QDataSet y,
                                   int[] bins,
                                   QDataSet xrange,
                                   QDataSet yrange)
```
make a 2-D histogram of the data in x and y. For example
```
x= randn(10000)+1
y= randn(10000)+4
zz= histogram2d( x,y, [30,30], dataset([0,8]), dataset([-2,6]) )
plot( zz )
```
The result will be a rank 2 dataset with DEPEND_0 and DEPEND_1 indicating the bin locations. If the xrange or yrange is dimensionless, then use the units of x or y.
Parameters:

x - the x values

y - the y values

bins - number of bins in x and y

xrange - a rank 1 2-element bounds dataset, so that Units can be specified.

yrange - a rank 1 2-element bounds dataset, so that Units can be specified.

Returns:

a rank 2 dataset

See Also:

histogram(org.das2.qds.QDataSet, double, double, double), Reduction.histogram2D(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

histogram
```
public static QDataSet histogram(QDataSet ds,
                                 double min,
                                 double max,
                                 double binSize)
```
returns a rank 1 dataset that is a histogram of the data. Note there will also be in the properties: count, the total number of valid values. nonZeroMin, the smallest non-zero, positive number

Parameters:

ds - rank N dataset

min - the min of the first bin. If min=-1 and max=-1, then automatically set the min and max.

max - the max of the last bin.

binSize - the size of each bin.

Returns:

a rank 1 dataset with each bin's count. DEPEND_0 indicates the bin locations.

histogram
```
public static QDataSet histogram(QDataSet ds,
                                 Datum min,
                                 Datum max,
                                 Datum binsize)
```
returns a rank 1 dataset that is a histogram of the data. Note there will also be in the properties: count, the total number of valid values. nonZeroMin, the smallest non-zero, positive number

Parameters:

ds - rank N dataset

min - the center of the first bin. If min=-1 and max=-1, then automatically set the min and max.

max - the center of the last bin.

binsize - the size of each bin.

Returns:

a rank 1 dataset with each bin's count. DEPEND_0 indicates the bin locations.

histogram
```
public static QDataSet histogram(QDataSet ds,
                                 java.lang.String min,
                                 java.lang.String max,
                                 java.lang.String binsize)
                          throws java.text.ParseException
```
returns rank 1 dataset that is a histogram of the data. This will use the units of ds to interpret min, max, and binsize.

Parameters:

ds - rank N dataset

min - the center of the first bin. If min=-1 and max=-1, then automatically set the min and max.

max - the center of the last bin.

binsize - the size of each bin.

Returns:

Throws:

java.text.ParseException

histogram
```
public static QDataSet histogram(QDataSet ds,
                                 int binCount)
```
returns a histogram of the dataset, based on the extent and scaletype of the data.

Parameters:

ds -

binCount - number of bins

Returns:

autoHistogram
```
public static QDataSet autoHistogram(QDataSet ds)
```
AutoHistogram is a one-pass self-scaling histogram, useful in autoranging data. The data is fed into the routine, and bins will grow as more and more data is added, to result in about 100 bins. For example, if the initial binsize is 1.0 unit, and the data extent is 0-200, then bins are combined so that the new binsize is 2.0 units and 100 bins are used.

Parameters:

ds - rank N dataset (all ranks are supported).

Returns:

rank 1 dataset

outerProduct
```
public static QDataSet outerProduct(QDataSet ds1,
                                    QDataSet ds2)
```
returns outerProduct of two rank 1 datasets, a rank 2 dataset with elements R[i,j]= ds1[i] * ds2[j].

Parameters:

ds1 - rank 1 dataset length m.

ds2 - rank 1 dataset of length n.

Returns:

rank 2 dataset that is m by n.

outerProduct

public static QDataSet outerProduct(java.lang.Object ds1,
                                    java.lang.Object ds2)

outerSum
```
public static QDataSet outerSum(QDataSet ds1,
                                QDataSet ds2)
```
returns outerSum of two rank 1 datasets, a rank 2 dataset with elements R[i,j]= ds1[i] + ds2[j].

Parameters:

ds1 - a rank 1 dataset of length m

ds2 - a rank 1 dataset of length n

Returns:

a rank 2 dataset[m,n]

outerSum

public static QDataSet outerSum(java.lang.Object ds1,
                                java.lang.Object ds2)

floor
```
public static QDataSet floor(QDataSet ds1)
```
element-wise floor function.

Parameters:

ds1 -

Returns:

floor
```
public static double floor(double x)
```

floor

public static QDataSet floor(java.lang.Object ds1)

ceil
```
public static QDataSet ceil(QDataSet ds1)
```
element-wise ceil function.

Parameters:

ds1 -

Returns:

ceil
```
public static double ceil(double x)
```

ceil

public static QDataSet ceil(java.lang.Object x)

round
```
public static QDataSet round(QDataSet ds1)
```
element-wise round function. 0.5 is round up.

Parameters:

ds1 -

Returns:

round
```
public static double round(double x)
```
for Jython, we handle this because the double isn't coerced.

Parameters:

x -

Returns:

round

public static QDataSet round(java.lang.Object x)

round
```
public static QDataSet round(QDataSet ds1,
                             int ndigits)
```
element-wise round function, which rounds to i decimal places. 0.5 is round up.

Parameters:

ds1 - the dataset.

ndigits - round to this number of digits after the decimal point (e.g. 1=0.1 2=0.01 -1=10)

Returns:

dataset with the same geometry with each value rounded.

round
```
public static double round(double x,
                           int ndigits)
```
for Jython, we handle this because the double isn't coerced.

Parameters:

x - the double

ndigits - round to this number of digits after the decimal point (e.g. 1=0.1 2=0.01 -1=10)

Returns:

the rounded double.

round
```
public static QDataSet round(java.lang.Object ds1,
                             int ndigits)
```
element-wise round function, which rounds to i decimal places. 0.5 is round up.

Parameters:

ds1 - the dataset.

ndigits - round to this number of digits after the decimal point (e.g. 1=0.1 2=0.01 -1=10)

Returns:

dataset with the same geometry with each value rounded.

signum
```
public static QDataSet signum(QDataSet ds1)
```
Returns the signum function of the argument; zero if the argument is zero, 1.0 if the argument is greater than zero, -1.0 if the argument is less than zero.

Parameters:

ds1 -

Returns:

See Also:

copysign(org.das2.qds.QDataSet, org.das2.qds.QDataSet), negate(org.das2.qds.QDataSet)

signum

public static double signum(double x)

signum

public static QDataSet signum(java.lang.Object x)

copysign
```
public static QDataSet copysign(QDataSet magnitude,
                                QDataSet sign)
```
Returns the first floating-point argument with the sign of the second floating-point argument.

Parameters:

magnitude -

sign -

Returns:

See Also:

signum(org.das2.qds.QDataSet), negate(org.das2.qds.QDataSet)

copysign

public static double copysign(double x,
                              double y)

copysign

public static QDataSet copysign(java.lang.Object x,
                                java.lang.Object y)

whereSequence
```
public static QDataSet whereSequence(QDataSet ds,
                                     QDataSet seq)
```
return a list of indices, similar to the where result.

Parameters:

ds - rank 1 dataset of length N

seq - rank 1 dataset, with length much less than N.

Returns:

rank 1 list of indices.

See Also:

https://github.com/autoplot/dev/blob/master/demos/2021/20210115/whereSequence.jy

findex
```
public static QDataSet findex(QDataSet uu,
                              QDataSet vv)
```
returns the "floating point index" of each element of vv within the monotonically increasing dataset uu. This handy number is the index of the lower bound plus the fractional position between the two bounds. For example, findex([100,110,120],111.2) is 1.12 because it is just after the 1st element (110) and is 12% of the way from 110 to 120. The result dataset will have the same geometry as vv. The result will be negative when the element of vv is below the smallest element of uu. The result will be greater than or equal to the length of uu minus one when it is greater than all elements. When the monotonic dataset contains repeat values, the index of the first is returned. Paul Ricchiazzi wrote this routine first for IDL as a fast replacement for the interpol routine, but it is useful in other situations as well.

Parameters:

uu - rank 1 monotonically increasing dataset, non-repeating, containing no fill values.

vv - rank N dataset with values in the same physical dimension as uu. Fill is allowed.

Returns:

rank N dataset with the same geometry as vv. It will have DEPEND_0=vv when vv is rank 1.

findex

public static QDataSet findex(java.lang.Object x,
                              java.lang.Object y)

interpolate
```
public static QDataSet interpolate(QDataSet vv,
                                   QDataSet findex)
```
interpolate values from rank 1 dataset vv using fractional indices in rank N findex. For example, findex=1.5 means interpolate the 1st and 2nd indices with equal weight, 1.1 means 90% of the first mixed with 10% of the second. Only modest extrapolations where findex>=-0.5 and findex<=L-0.5 are allowed, where L is the number of points. The findex parameter must be dimensionless, to ensure that the caller is not passing in physical data. Note there is no check on CADENCE. Note nothing is done with DEPEND_0, presumably because was already calculated and used for findex. Here is an example use of this in Autoplot's Jython code:
```
 
xx= [1,2,3,4]
yy= [2,4,5,4]
xxx= linspace(0,5,100)
yyy= interpolate( yy, findex(xx,xxx) )

plot( xx, yy, symbolSize=20 )
plot( addPlotElement(0), xxx, yyy )
 
 
```
This looks at the AVERAGE_TYPE metadata, and when it is present, linear, geometric, none, mod360, mod24, modpi, and modtau are respected.
Parameters:

vv - rank 1 dataset having length L that is the data to be interpolated.

findex - rank N dataset of fractional indices. This must be dimensionless, between -0.5 and L-0.5 and is typically calculated by the findex command.

Returns:

the result.

See Also:

interpolateMod, for data like longitude where 259 deg is 2 degrees away from 1 deg

interpolate
```
public static QDataSet interpolate(java.lang.Object vv,
                                   java.lang.Object findex)
```
Parameters:

vv - object that can be converted to rank 1 dataset, such as array. These are the rank 1 dataset that is the data to be interpolated.

findex - object that can be converted to a rank N dataset, such as an array. These are the rank N dataset of fractional indices.

Returns:

rank N dataset.

interpolate
```
public static QDataSet interpolate(QDataSet vv,
                                   QDataSet findex0,
                                   QDataSet findex1)
```
interpolate values from rank 2 dataset vv using fractional indices in rank N findex, using bilinear interpolation. See also interpolateGrid.

Parameters:

vv - rank 2 dataset.

findex0 - rank N dataset of fractional indices for the zeroth index. This must be dimensionless, between -0.5 and L-0.5 and is typically calculated by the findex command.

findex1 - rank N dataset of fractional indices for the first index. This must be dimensionless, between -0.5 and L-0.5 and is typically calculated by the findex command.

Returns:

rank N dataset

See Also:

findex, the 1-D findex command, interpolateGrid(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

interpolate
```
public static QDataSet interpolate(java.lang.Object vv,
                                   java.lang.Object findex0,
                                   java.lang.Object findex1)
```
interpolate values from rank 2 dataset vv using fractional indices in rank N findex, using bilinear interpolation. See also interpolateGrid.

Parameters:

vv - object convertible to rank 2 dataset.

findex0 - object convertible to rank N dataset of fractional indices for the zeroth index.

findex1 - object convertible to rank N dataset of fractional indices for the first index.

Returns:

rank N dataset

See Also:

findex, the 1-D findex command

interpolate
```
public static QDataSet interpolate(QDataSet vv,
                                   QDataSet findex0,
                                   QDataSet findex1,
                                   QDataSet findex2)
```
interpolate values from rank 2 dataset vv using fractional indices in rank N findex, using bilinear interpolation. See also interpolateGrid.

Parameters:

vv - rank 2 dataset.

findex0 - rank N dataset of fractional indices for the zeroth index. This must be dimensionless, between -0.5 and L-0.5 and is typically calculated by the findex command.

findex1 - rank N dataset of fractional indices for the first index. This must be dimensionless, between -0.5 and L-0.5 and is typically calculated by the findex command.

findex2 - rank N dataset of fractional indices for the second index. This must be dimensionless, between -0.5 and L-0.5 and is typically calculated by the findex command.

Returns:

rank N dataset

See Also:

findex, the 1-D findex command, interpolateGrid(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

interpolateMod
```
public static QDataSet interpolateMod(QDataSet vv,
                                      QDataSet mod,
                                      QDataSet findex)
```
like interpolate, but the findex is recalculated when the two bracketed points are closer in the modulo space than they would be in the linear space.

Parameters:

vv - rank 1 dataset that is the data to be interpolated. (e.g. longitude from 0 to 360deg)

mod - rank 0 dataset that is the mod of the space (e.g. 360deg), or rank 1 where the range is specified (e.g. -180 to 180).

findex - rank N dataset of fractional indices. This must be dimensionless and is typically calculated by the findex command.

Returns:

the result, a rank 1 dataset with one element for each findex.

See Also:

interpolate(QDataSet,QDataSet)

interpolateGrid
```
public static QDataSet interpolateGrid(QDataSet vv,
                                       QDataSet findex0,
                                       QDataSet findex1)
```
interpolate values from rank 2 dataset vv using fractional indices in rank N findex, using bilinear interpolation. Here the two rank1 indexes form a grid and the result is rank 2.

Parameters:

vv - rank 2 dataset.

findex0 - rank 1 dataset of fractional indices for the zeroth index.

findex1 - rank 1 dataset of fractional indices for the first index.

Returns:

rank 2 dataset

See Also:

findex, the 1-D findex command

interpolateGrid

public static QDataSet interpolateGrid(java.lang.Object x,
                                       java.lang.Object y,
                                       java.lang.Object z)

valid
```
public static QDataSet valid(QDataSet ds)
```
returns a dataset with zero where the data is invalid, and positive non-zero where the data is valid. (This just returns the weights plane of the dataset.)
```
r= where( valid( ds ) )
```
Parameters:

ds - a rank N dataset that might have FILL_VALUE, VALID_MIN or VALID_MAX set.

Returns:

a rank N dataset with the same geometry, with zeros where the data is invalid and >0 where the data is valid.

See Also:

invalid(org.das2.qds.QDataSet)

invalid
```
public static QDataSet invalid(QDataSet ds)
```
returns a dataset with one where the data is invalid, and zero the data is valid. (This just returns the weights plane of the dataset.)
```
r= where( invalid( ds ) )
```
The purpose of this is to make this commonly used logic easier to find.
Parameters:

ds - a rank N dataset

Returns:

a rank N dataset

See Also:

valid(org.das2.qds.QDataSet)

clearWritable
```
public static void clearWritable(WritableDataSet ds)
```
assign zeros to all the values of the dataset. The dataset must be mutable. This was used to verify Jython behavior.

Parameters:

ds -

finite
```
public static QDataSet finite(QDataSet ds)
```
returns 1 where the data is not NaN, Inf, etc I needed this when I was working with the RBSP polar scatter script. Note valid should be used to check for valid data, which also checks for NaN.

Parameters:

ds - qdataset of any rank.

Returns:

1 where the data is not Nan or Inf, 0 otherwise.

smooth1
```
public static QDataSet smooth1(QDataSet ds,
                               int size)
```
smooth over the first dimension (not the zeroth). For example, for ds[Time,Energy], this will smooth over energy.

Parameters:

ds - rank 2 dataset.

size - the boxcar size

Returns:

smoothed dataset with the same geometry.

See Also:

detrend1(org.das2.qds.QDataSet, int)

smooth2d
```
public static QDataSet smooth2d(QDataSet ds,
                                int n0,
                                int n1)
```
smooth in both the first and second dimensions. Presently, this just calls smooth and then smooth1.

Parameters:

ds - rank 2 data

n0 - the boxcar size in the first dimension

n1 - the boxcar size in the second dimension

Returns:

data with the same geometry

See Also:

smooth(org.das2.qds.QDataSet, int), smooth1(org.das2.qds.QDataSet, int)

smooth
```
public static QDataSet smooth(QDataSet ds,
                              int size)
```
run boxcar average over the dataset, returning a dataset of same geometry. Points near the edge are simply copied from the source dataset. The result dataset contains a property "weights" that is the weights for each point. For rank 2 datasets, the smooth is done on the zeroth dimension, typically time. Note IDL does the smooth in both X and Y.

Parameters:

ds - a rank 1 or rank 2 dataset of length N

size - the number of adjacent bins to average

Returns:

rank 1 or rank 2 dataset of length N

See Also:

smooth2d(org.das2.qds.QDataSet, int, int)

smooth

public static QDataSet smooth(java.lang.Object ds,
                              int size)

smoothFit
```
public static QDataSet smoothFit(QDataSet xx,
                                 QDataSet yy,
                                 int size)
```
run boxcar average over the dataset, returning a dataset of same geometry. Points near the edge are fit to a line and replaced. The result dataset contains a property "weights" that is the weights for each point.

Parameters:

xx - a rank 1 dataset of size N

yy - a rank 1 dataset of size N

size - the number of adjacent bins to average. If size is greater than yy.length, size is reset to yy.length.

Returns:

rank 1 dataset of size N

smoothFit

public static QDataSet smoothFit(java.lang.Object xx,
                                 java.lang.Object yy,
                                 int size)

detrend
```
public static QDataSet detrend(QDataSet yy,
                               int size)
```
remove D/C and low-frequency components from the data by subtracting out the smoothed data with a boxcar of the given size. Points on the end are zero.

Parameters:

yy - rank 1 dataset

size - size of the boxcar

Returns:

dataset

detrend

public static QDataSet detrend(java.lang.Object yy,
                               int size)

detrend1
```
public static QDataSet detrend1(QDataSet yy,
                                int size)
```
remove D/C and low-frequency components from the data by subtracting out the smoothed data with a boxcar of the given size, along each record. Points on the end are zero.

Parameters:

yy - rank 2 dataset

size - size of the boxcar

Returns:

dataset

See Also:

smooth1(org.das2.qds.QDataSet, int)

cleanData
```
public static QDataSet cleanData(QDataSet ds)
```
remove the data which is 3 sigmas from the mean of the data.

Parameters:

ds - rank 1 dataset.

Returns:

cleaned dataset of the same geometry.

cleanData
```
public static QDataSet cleanData(QDataSet ds,
                                 int size)
```
remove the data which is N sigmas (stddev) from the mean. This is to replicate the "clean_data" function used by CDAWeb at NASA/Goddard.

Parameters:

ds - rank 1 dataset.

size - size for a boxcar, or -1 for the whole dataset.

Returns:

cleaned dataset of the same geometry.

cleanData
```
public static QDataSet cleanData(QDataSet ds,
                                 double nsigma,
                                 int size)
```
remove the data which is N sigmas (stddev) from the mean.

Parameters:

ds - rank 1 dataset.

nsigma - remove data more than this many stddevs from mean.

size - size for a boxcar, or -1 for the whole dataset.

Returns:

cleaned dataset of the same geometry.

mean
```
public static QDataSet mean(QDataSet ds)
```
Mean function that returns the average of the valid elements of a rank N dataset

Parameters:

ds - rank N dataset

Returns:

rank 0 dataset

See Also:

mode(org.das2.qds.QDataSet), median(java.lang.Object), variance(org.das2.qds.QDataSet), meanAverageDeviation(org.das2.qds.QDataSet)

mean

public static QDataSet mean(java.lang.Object o)

mode
```
public static QDataSet mode(QDataSet ds)
```
return the most frequently occurring element of the valid elements of a rank N dataset

Parameters:

ds - rank N dataset.

Returns:

the rank 0 dataset

See Also:

mean(org.das2.qds.QDataSet), median(java.lang.Object)

median
```
public static QDataSet median(java.lang.Object o)
```
Median function that sorts a rank N dataset and returns its median. If lists are equal in size (even number of elements), always choose first element of 'more' list

Parameters:

o - object which can be interpreted as a dataset.

Returns:

rank 0 dataset

See Also:

mean(org.das2.qds.QDataSet), mode(org.das2.qds.QDataSet)

median
```
public static QDataSet median(QDataSet ds)
```
Median function that sorts a rank N dataset and returns its median. If lists are equal in size (even number of elements), always choose first element of 'more' list

Parameters:

ds - rank N dataset.

Returns:

rank 0 dataset

See Also:

mean(org.das2.qds.QDataSet), mode(org.das2.qds.QDataSet)

stddev
```
public static QDataSet stddev(java.lang.Object o)
```
standard deviation function.

Parameters:

o - an object which can be interpreted as a rank N dataset.

Returns:

rank 0 dataset with units matching those of the input.

stddev
```
public static QDataSet stddev(QDataSet ds)
```
standard deviation function.

Parameters:

ds - rank N dataset.

Returns:

rank 0 dataset with units matching those of the input.

variance
```
public static QDataSet variance(java.lang.Object o)
```
variance function is the square of the stddev.

Parameters:

o - object which can be interpreted as rank 1 dataset.

Returns:

Rank 0 QDataSet containing the variance. The result is currently dimensionless, but this will change.

See Also:

stddev(java.lang.Object)

variance
```
public static QDataSet variance(QDataSet ds)
```
variance function is the square of the stddev.

Parameters:

ds - rank 1 dataset.

Returns:

Rank 0 QDataSet containing the variance. The result is currently dimensionless, but this will change.

See Also:

stddev(java.lang.Object)

meanAverageDeviation
```
public static QDataSet meanAverageDeviation(QDataSet ds)
```
return the Mean Average Deviation (MAD) of the rank N dataset. The result will contain the USER_PROPERTIES with a map containing the mean and number of points.

Parameters:

ds - the rank N dataset.

Returns:

the rank 0 mean average deviation of the dataset.

See Also:

mean(org.das2.qds.QDataSet), BinAverage.binMeanAverageDeviation(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

neighborFill
```
public static QDataSet neighborFill(QDataSet ds)
```
fill in the missing values by copying nearest data points. All data in the result will be copies of elements found in the result, but no regard is given to how far a point is shifted. This was motivated by supporting fill in median.

Parameters:

ds -

Returns:

dataset that does not contain fill.

medianFilter
```
public static QDataSet medianFilter(QDataSet ds,
                                    int size)
```
1-D median filter with a boxcar of the given size. The first size/2 elements, and the last size/2 elements are copied from the input.

Parameters:

ds - rank 1 or rank 2 dataset. Future implementations may support higher rank data.

size - the boxcar size

Returns:

rank 1 or rank 2 dataset.

See Also:

smooth(org.das2.qds.QDataSet, int)

contour
```
public static QDataSet contour(QDataSet tds,
                               QDataSet vv)
```
contour the data in rank 2 table tds at rank 0 vv. The result is a rank 2 bundle of [:,'x,y,z'] where i is the contour number. The result will have DEPEND_0 be an monotonically increasing sequence with jumps indicating new contours.

Parameters:

tds - rank 2 table

vv - rank 2 bundle

Returns:

contour

public static QDataSet contour(java.lang.Object tds,
                               java.lang.Object vv)

diff
```
public static QDataSet diff(QDataSet ds)
```
return array that is the differences between each successive pair in the dataset. Result[i]= ds[i+1]-ds[i], so that for an array with N elements, an array with N-1 elements is returned. When the data has a DEPEND_0, the result will have a DEPEND_0 which contains the average of the corresponding points.

Parameters:

ds - a rank 1 dataset with N elements.

Returns:

a rank 1 dataset with N-1 elements.

See Also:

accum(org.das2.qds.QDataSet)

diff

public static QDataSet diff(java.lang.Object ds)

accum
```
public static QDataSet accum(QDataSet accumDs,
                             QDataSet ds)
```
return an array that is the running sum of each element in the array, starting with the value accum.
Result[i]= accum + total( ds[0:i] ) + ds[i]
If a fill value is encountered, then zero is added to the accumulation.

Parameters:

accumDs - the initial value of the running sum. Last value of Rank 0 or Rank 1 dataset is used, or may be null.

ds - each element is added to the running sum

Returns:

the running of each element in the array.

See Also:

diff(org.das2.qds.QDataSet)

accum

public static QDataSet accum(java.lang.Object accumDs,
                             java.lang.Object ds)

accum
```
public static QDataSet accum(QDataSet ds)
```
return an array that is the running sum of each element in the array, starting with the value accum. Result[i]= total( ds[0:i+1] )

Parameters:

ds - each element is added to the running sum

Returns:

the running of each element in the array.

See Also:

diff(org.das2.qds.QDataSet)

accum

public static QDataSet accum(java.lang.Object ds)

cumulativeMax
```
public static QDataSet cumulativeMax(QDataSet ds)
```
for each element i of ds, set the result[i] to the maximum of ds[0:(i+1)]

Parameters:

ds - rank 1 dataset

Returns:

the cumulative maximum

cumulativeMin
```
public static QDataSet cumulativeMin(QDataSet ds)
```
for each element i of ds, set the result[i] to the minimum of ds[0:(i+1)]

Parameters:

ds - rank 1 dataset

Returns:

the cumulative minimum

append
```
public static QDataSet append(QDataSet ds1,
                              QDataSet ds2)
```
append two datasets that are QUBEs. DEPEND_0 and other metadata is handled as well. So for example:
```
ds1= findgen(10)
ds2= findgen(12)
print append(ds1,ds2)  ; dataSet[22] (dimensionless)
```
If both datasets are ArrayDataSets and of the same component type, then the result will have this type as well. Otherwise DDataSet is returned.
Parameters:

ds1 - null or rank N dataset

ds2 - rank N dataset with compatible geometry.

Returns:

See Also:

which is the same thing.

timeShift
```
public static QDataSet timeShift(QDataSet ds,
                                 Datum delta)
```
Shift the DEPEND_0 or the time column of a rank 2 dataset by the amount. For example, to compare two time series recorded with times from different time zones.

Parameters:

ds - the data which is a time series.

delta - the amount to add to each timetag.

Returns:

data in the same form but with the times shifted.

See Also:

Schemes.isTimeSeries(org.das2.qds.QDataSet)

synchronizeOne
```
public static QDataSet synchronizeOne(QDataSet dsTarget,
                                      QDataSet dsSource)
```
The first dataset's timetags are used to synchronize the single dataset to common timetags. Presently, data from dsSource will be linearly interpolated to create data at dsTarget timetag locations, but other methods may be introduced soon. Ordinal units use the nearest neighbor interpolation.

Parameters:

dsTarget - the dataset providing timetags, or the timetags themselves.

dsSource - the dataset to synch up. Its timetags must be monotonically increasing and non-repeating.

Returns:

the one dataset, synchronized.

See Also:

synchronize(org.das2.qds.QDataSet, org.das2.qds.QDataSet...)

synchronize
```
public static QDataSet synchronize(QDataSet ds1,
                                   QDataSet ds)
```
The first dataset's timetags are used to synchronize the second dataset to a set of common timetags. Presently, only linear interpolation is used, but other methods may be introduced soon. Note that when one of the dataset's DEPEND_0 is not monotonic, a monotonic subset of its points will be used. Ordinal units use the nearest neighbor interpolation.

Parameters:

ds1 - the dataset providing timetags, or the timetags themselves.

ds - the single datasets to synch up.

Returns:

the single dataset evaluated at the other dataset's timetags.

See Also:

synchronizeNN(org.das2.qds.QDataSet, org.das2.qds.QDataSet), synchronize(org.das2.qds.QDataSet, org.das2.qds.QDataSet...), flattenWaveform(org.das2.qds.QDataSet)

synchronize
```
public static java.util.List<QDataSet> synchronize(QDataSet dsTarget,
                                                   QDataSet... dsSources)
```
The first dataset's timetags are used to synchronize the list of datasets to a set of common timetags. Presently, only linear interpolation is used, but other methods may be introduced soon. Note that when one of the dataset's DEPEND_0 is not monotonic, a monotonic subset of its points will be used. Ordinal units use the nearest neighbor interpolation. Note in the case where dsTarget is the set of timeTags, then it must be monotonic. (TODO: why?)

Parameters:

dsTarget - the dataset providing timetags, or the timetags themselves.

dsSources - the N datasets to synch up, where each should have monotonic timetags.

Returns:

a list of N datasets, synchronized

See Also:

synchronizeNN(org.das2.qds.QDataSet, org.das2.qds.QDataSet...), synchronize(org.das2.qds.QDataSet, org.das2.qds.QDataSet), flattenWaveform(org.das2.qds.QDataSet)

synchronizeNN
```
public static QDataSet synchronizeNN(QDataSet ds1,
                                     QDataSet ds)
```
The first dataset's timetags are used to synchronize the second dataset to a set of common timetags, using nearest neighbor interpolation. Note that when one of the dataset's DEPEND_0 is not monotonic, a monotonic subset of its points will be used. Ordinal units use the nearest neighbor interpolation.

Parameters:

ds1 - the dataset providing timetags, or the timetags themselves.

ds - the single datasets to synch up.

Returns:

the single dataset evaluated at the other dataset's timetags.

See Also:

synchronize(org.das2.qds.QDataSet, org.das2.qds.QDataSet), synchronizeNN(org.das2.qds.QDataSet, org.das2.qds.QDataSet...), flattenWaveform(org.das2.qds.QDataSet)

synchronizeNN
```
public static java.util.List<QDataSet> synchronizeNN(QDataSet dsTarget,
                                                     QDataSet... dsSources)
```
The first dataset's timetags are used to synchronize the list of datasets to a set of common timetags, using nearest neighbor interpolation. Note that when one of the dataset's DEPEND_0 is not monotonic, a monotonic subset of its points will be used.

Parameters:

dsTarget - the dataset providing timetags, or the timetags themselves.

dsSources - the N datasets, each either rank 1 or rank 2, all should have DEPEND_0 which is monotonic.

Returns:

a list of N datasets, synchronized

See Also:

synchronize(org.das2.qds.QDataSet, org.das2.qds.QDataSet...), synchronizeNN(org.das2.qds.QDataSet, org.das2.qds.QDataSet), flattenWaveform(org.das2.qds.QDataSet)

convertUnitsTo
```
public static QDataSet convertUnitsTo(QDataSet ds,
                                      Units u)
```
convert the dataset to the target units. y= ytags(spectrogramds) y= convertUnitsTo( y, Units.Hz ) spectrogramDs= link( xtags( spectrogramDs ), y, spectrogramDs )

Parameters:

ds - the original dataset.

u - units of the new dataset

Returns:

a new dataset with all the same properties but with the new units.

convertUnitsTo
```
public static DatumRange convertUnitsTo(DatumRange dr,
                                        Units u)
```
convert the datumRange to the given units, which must be convertible. For example: y= ytags(spectrogramds) y= convertUnitsTo( y, Units.Hz ) spectrogramDs= link( xtags( spectrogramDs ), y, spectrogramDs )

Parameters:

dr - the datum range, e.g. '5 to 50 MHz'

u - the new units. e.g. 'Hz'

Returns:

DatumRange in the new units, e.g. '5000000 to 50000000 Hz'

Throws:

InconvertibleUnitsException

convertUnitsTo
```
public static Datum convertUnitsTo(Datum d,
                                   Units u)
```
convert the datum to the given units, which must be convertible.

Parameters:

d - the datum, e.g. '5 MHz'

u - the new units, e.g. 'Hz'

Returns:

Datum in the new units, e.g. '5000000 Hz'

Throws:

InconvertibleUnitsException

flatten
```
public static QDataSet flatten(QDataSet ds)
```
flatten a rank N dataset. The result for rank 2 is an n,3 dataset of [x,y,z], or if there are no tags, just [z]. The last index will be the dependent variable, and the first indices will be the independent variables sorted by dimension.

Parameters:

ds - the rank N dataset

Returns:

rank 2 dataset bundle

See Also:

DataSetOps.flattenRank2(org.das2.qds.QDataSet), grid(org.das2.qds.QDataSet), flattenWaveform(org.das2.qds.QDataSet)

flattenWaveform
```
public static QDataSet flattenWaveform(QDataSet ds)
```
flatten a rank 2 dataset where the y depend variable is just an offset from the xtag. Note the new DEPEND_0 may have different units from ds.property(DEPEND_0).

Parameters:

ds - rank 2 waveform with tags for DEPEND_0 and offsets for DEPEND_1

Returns:

rank 1 waveform

See Also:

flatten(org.das2.qds.QDataSet), DataSetOps.flattenWaveform(org.das2.qds.QDataSet), synchronizeNN(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

grid
```
public static QDataSet grid(QDataSet ds)
```
Opposite of the flatten function, takes rank 2 bundle (x,y,z) and makes a table from it z(x,y). This presumes that the rank 1 X and Y data contain repeating elements for the rows and columns of the grid.

Parameters:

ds - rank 2 bundle of X,Y, and Z data.

Returns:

rank 2 table.

See Also:

flatten(org.das2.qds.QDataSet)

gridIrregularY
```
public static QDataSet gridIrregularY(QDataSet t,
                                      QDataSet y,
                                      QDataSet z,
                                      QDataSet ytags)
```
This finds sweeps of Y and interpolates T->Y->Z to make a regular spectrogram T,yTags->Z[T,yTags] This function was once known as "LvT" because it was used to create a spectrogram of Flux(Time,Lshell) by interpolating along sweeps.

Parameters:

t - the rank 1 x values (often time)

y - the rank 1 y values (for example, L)

z - the rank 1 z values at each y.

ytags - the rank 1 y tags for the result.

Returns:

the rank 2 spectrogram.

labels
```
public static QDataSet labels(java.lang.String[] labels,
                              java.lang.String context)
```
Deprecated. use labelsDataset

create a labels dataset for tagging rows of a dataset. If the context has been used already, including "default", then the EnumerationUnit for the data will be preserved. labels(["red","green","blue"],"default") will always return an equivalent (and comparable) result during a session. Example: dep1= labels( ["X","Y","Z"], "GSM" )

Parameters:

labels - array of string labels

context - the namespace for the labels, to provide control over String→int mapping.

Returns:

rank 1 QDataSet

See Also:

labelsDataset(java.lang.String[])

labels
```
public static QDataSet labels(java.lang.String[] labels)
```
Deprecated. use labelsDataSet

create a labels dataset for tagging rows of a dataset. Example: dep1= labels( ["red","green","blue"] )

Parameters:

labels - array of string labels

Returns:

rank 1 QDataSet

See Also:

labelsDataset(java.lang.String[])

labelsDataset
```
public static QDataSet labelsDataset(java.lang.String[] labels,
                                     java.lang.String context)
```
create a labels dataset for tagging rows of a dataset. If the context has been used already, including "default", then the EnumerationUnit for the data will be preserved. labelsDataset(['red','green','blue'],'default') will always return an equivalent (and comparable) result during a session. Example: dep1= labelsDataset( ['X','Y','Z'], 'GSM' )

Parameters:

labels - array of string labels

context - the namespace for the labels, to provide control over String→int mapping.

Returns:

rank 1 QDataSet

labelsDataset
```
public static QDataSet labelsDataset(java.lang.String[] labels)
```
create a labels dataset for tagging rows of a dataset. Example: array of string labels dep1= labelsDataset( ['red','green','blue'] )

Parameters:

labels -

Returns:

rank 1 QDataSet

labelsDataset
```
public static QDataSet labelsDataset(java.lang.String label)
```
create a rank 0 label dataset. dep1= labelsDataset( 'Chicago' )

Parameters:

label - the string label

Returns:

rank 0 QDataSet

labelsDataset
```
public static QDataSet labelsDataset(java.lang.String label,
                                     java.lang.String context)
```
create a rank 0 label dataset. dep1= labelsDataset( 'Chicago', 'cities' )

Parameters:

label - the string label

context - the namespace for the labels, to provide control over String→int mapping.

Returns:

rank 0 QDataSet

rgbColorDataset
```
public static QDataSet rgbColorDataset(QDataSet red,
                                       QDataSet green,
                                       QDataSet blue)
```
create a dataset of RGB colors. The output is int(red)*256*256 + int(green)*256 + int(blue) with the units of Units.rgbColor

Parameters:

red - the red component, from 0 to 255

green - the green component, from 0 to 255

blue - the blue component, from 0 to 255

Returns:

the rgb encoded colors.

See Also:

toTimeDataSet(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

size
```
public static int[] size(QDataSet ds)
```
returns the number of elements in each index. E.g:
```
 ds= zeros(3,4)
 print size(ds) # returns "3,4"
 
```
Note datasets need not have the same number of elements in each record. This is often the case however, and a "qube" dataset has this property.
Parameters:

ds - a qube dataset.

Returns:

the array containing number of elements in each index.

Throws:

java.lang.IllegalArgumentException - if the dataset is not a qube.

colorFromString
```
public static java.awt.Color colorFromString(java.lang.String sval)
```
return the color encoded as one of:
- "red" or "RED" or X11 color names like "LightPink"
- #FF0000
- 255,0,0 or 1.0,0,0
Parameters:

sval - the string representation

Returns:

the color

Throws:

java.lang.IllegalArgumentException - if the color cannot be parsed.

slices
```
public static QDataSet slices(QDataSet ds,
                              java.lang.Object... args)
```
slice each dimension in one call, so that chaining isn't required to slice multiple dimensions at once.

Parameters:

ds - the dataset

args - varargs list of integers that are slice indices, or "" or ":" to mean don't slice

Returns:

the dataset with slices performed.

reform
```
public static QDataSet reform(QDataSet ds)
```
Reshape the dataset to remove the first dimension with length 1, reducing its rank by 1. Dependencies are also preserved. If no indices are found, then the dataset is returned.

Parameters:

ds - rank N dataset

Returns:

the dataset, or rank N-1 dataset with the first 1-element dimension removed.

reform
```
public static QDataSet reform(QDataSet ds,
                              int nrec,
                              int[] qube)
```
allow reform record-by-record, which comes up often.

Parameters:

ds - rank 2 or greater dataset of length nrec.

nrec - number of records in ds

qube - length nn array with the new geometry of each record.

Returns:

ds of rank nn+1.

reform
```
public static QDataSet reform(QDataSet ds,
                              int[] qube)
```
change the dimensionality of the elements of the QUBE dataset. For example, convert [1,2,3,4,5,6] to [[1,2],[3,4],[5,6]].

Parameters:

ds - dataset

qube - the dimensions of the result dataset.

Returns:

a new dataset with the specified dimensions, and the properties (e.g. UNITS) of the input dataset.

reform

public static QDataSet reform(java.lang.Object ds,
                              int[] qube)

xtags
```
public static QDataSet xtags(QDataSet ds)
```
return the xtags of the dataset.

Parameters:

ds - the dataset

Returns:

the dataset for the xtags.

See Also:

SemanticOps.xtagsDataSet(org.das2.qds.QDataSet)

ytags
```
public static QDataSet ytags(QDataSet ds)
```
return the ytags of the dataset.

Parameters:

ds - the dataset

Returns:

the dataset for the xtags.

See Also:

SemanticOps.ytagsDataSet(org.das2.qds.QDataSet)

boundsDataset

public static QDataSet boundsDataset(java.lang.String s)

This returns one of a bounds dataset:

rank 1 bounds (a datumRange)
rank 2 bounding box
rank 2 bounding qube (three or more dimensions)

2002-03-02/2002-03-03 2002-03-02 orbit:crres:6 5 to 50	rank 1 bounds (a datumRange)
2002-03-02/2002-03-03;5 to 50	rank 2 bounding box
2002-03-02T01:01/2002-03-02T01:02;5 to 50 eV;90 to 180 deg	rank 2 bounding qube

Note dataset("5 to 50") presently parses to a rank 0 nominal dataset, not a rank 1 range.

Parameters:: s - string representation of a dataset
Returns:: a rank 1 or rank 2 bounds dataset.
See Also:: datumRange(java.lang.Object)

bundle
```
public static QDataSet bundle(QDataSet ds)
```
bundle the dataset, making an initial bundle, adding a bundle dimension.

Parameters:

ds - a rank N dataset

Returns:

rank N+1 bundle dataset

bundle
```
public static QDataSet bundle(QDataSet ds1,
                              QDataSet ds2)
```
bundle the two datasets, adding if necessary a bundle dimension. This will try to bundle on the second dimension, unlike join. This will also isolate the semantics of bundle dimensions as it's introduced. Note the first argument can be null in order to simplify loops in client code.

Parameters:

ds1 - null, rank N dataset with n records or rank N+1 bundle dataset

ds2 - rank N dataset.

Returns:

rank N+1 bundle dataset, presently with mutable properties.

See Also:

join(org.das2.qds.QDataSet, org.das2.qds.QDataSet), DataSetOps.unbundle(org.das2.qds.QDataSet, java.lang.String)

bundle
```
public static QDataSet bundle(QDataSet ds1,
                              QDataSet ds2,
                              QDataSet ds3)
```
bundle three datasets, giving them a common zeroth index, typically time, unlike join. This bundles on the second dimension, unlike join. This is just like bundle(ds1,ds2), in fact this just calls bundle( bundle( ds1,ds2 ), ds3 )

Parameters:

ds1 - rank 1 (for now) dataset with n records or rank 2 bundle dataset

ds2 - rank 1 (for now) dataset with n records

ds3 - rank 1 (for now) dataset with n records

Returns:

rank 2 [n,3] bundle dataset

See Also:

join(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

bundle
```
public static QDataSet bundle(QDataSet ds1,
                              QDataSet ds2,
                              QDataSet ds3,
                              QDataSet ds4)
```
bundle four datasets, making them share their zeroth index, typically time, unlike join. This is just like bundle(ds1,ds2), in fact this just calls bundle( bundle( bundle( ds1,ds2 ), ds3 ), ds4 )

Parameters:

ds1 - rank 1 (for now) dataset with n records or rank 2 bundle dataset

ds2 - rank 1 (for now) dataset with n records

ds3 - rank 1 (for now) dataset with n records

ds4 - rank 1 (for now) dataset with n records

Returns:

rank 2 [n,4] bundle dataset

See Also:

join(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

bundle
```
public static QDataSet bundle(QDataSet ds1,
                              QDataSet ds2,
                              QDataSet ds3,
                              QDataSet ds4,
                              QDataSet ds5)
```
bundle five datasets, making them share their zeroth index, typically time, unlike join. This is just like bundle(ds1,ds2), in fact this just calls bundle( bundle( bundle( ds1,ds2 ), ds3 ), ds4 )

Parameters:

ds1 - rank 1 (for now) dataset with n records or rank 2 bundle dataset

ds2 - rank 1 (for now) dataset with n records

ds3 - rank 1 (for now) dataset with n records

ds4 - rank 1 (for now) dataset with n records

ds5 - rank 1 (for now) dataset with n records

Returns:

rank 2 [n,4] bundle dataset

See Also:

join(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

bundle
```
public static QDataSet bundle(QDataSet ds1,
                              QDataSet ds2,
                              QDataSet ds3,
                              QDataSet ds4,
                              QDataSet ds5,
                              QDataSet ds6)
```
bundle six datasets, making them share their zeroth index, typically time, unlike join. This is just like bundle(ds1,ds2), in fact this just calls bundle( bundle( bundle( ds1,ds2 ), ds3 ), ds4 )

Parameters:

ds1 - rank 1 (for now) dataset with n records or rank 2 bundle dataset

ds2 - rank 1 (for now) dataset with n records

ds3 - rank 1 (for now) dataset with n records

ds4 - rank 1 (for now) dataset with n records

ds5 - rank 1 (for now) dataset with n records

ds6 - rank 1 (for now) dataset with n records

Returns:

rank 2 [n,4] bundle dataset

See Also:

join(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

bundle
```
public static QDataSet bundle(QDataSet ds1,
                              QDataSet ds2,
                              QDataSet ds3,
                              QDataSet ds4,
                              QDataSet ds5,
                              QDataSet ds6,
                              QDataSet ds7)
```
bundle seven datasets, making them share their zeroth index, typically time, unlike join. This is just like bundle(ds1,ds2), in fact this just calls bundle( bundle( bundle( ds1,ds2 ), ds3 ), ds4 )

Parameters:

ds1 - rank 1 (for now) dataset with n records or rank 2 bundle dataset

ds2 - rank 1 (for now) dataset with n records

ds3 - rank 1 (for now) dataset with n records

ds4 - rank 1 (for now) dataset with n records

ds5 - rank 1 (for now) dataset with n records

ds6 - rank 1 (for now) dataset with n records

ds7 - rank 1 (for now) dataset with n records

Returns:

rank 2 [n,4] bundle dataset

See Also:

join(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

unbundle
```
public static QDataSet unbundle(QDataSet ds,
                                java.lang.String name)
```
Extract the named bundled dataset. For example, extract B_x from bundle of components.

Parameters:

ds - the bundle of datasets, often rank 2 with BUNDLE_1 property

name - the name of the bundled dataset, or "ch_<i>" where i is the dataset number

Returns:

the named dataset

Throws:

java.lang.IllegalArgumentException - if no named dataset is found.

See Also:

unbundle(org.das2.qds.QDataSet, int), DataSetOps.bundleNames(org.das2.qds.QDataSet)

unbundle
```
public static QDataSet unbundle(QDataSet ds,
                                int i)
```
Extract a bundled dataset from a bundle of datasets. The input should be a rank 2 dataset with the property BUNDLE_1 set to a bundle descriptor dataset. See BundleDataSet for more semantics. Note we support the case where DEPEND_1 has EnumerationUnits, and this is the same as slice1.

Parameters:

ds - the bundle dataset.

i - index of the dataset to extract. If the index is within a high-rank dataset, then the entire dataset is returned.

Returns:

the i-th dataset from the bundle.

Throws:

java.lang.IndexOutOfBoundsException - if the index is invalid.

java.lang.IllegalArgumentException - if the dataset is not a bundle dataset, with either BUNDLE_1 or DEPEND_1 set.

unbundleBins
```
public static QDataSet unbundleBins(QDataSet ds,
                                    int i)
```
convenient method for getting the times from an events dataset, this unbundles the startTimes at i and the stopTimes at i+1 to a bins dataset. The second column can be durations as well.

Parameters:

ds - the bundle.

i - the index, 0 for a canonical events dataset.

Returns:

rank 2 bins dataset.

rebundle
```
public static QDataSet rebundle(QDataSet bundle1,
                                java.lang.String[] names)
```
unbundle the names from the bundle, and rebundle them in the order specified.

Parameters:

bundle1 - a bundle of datasets

names - the bundled dataset names

Returns:

the new bundle

Since:

v2020a_15

See Also:

unbundle(org.das2.qds.QDataSet, java.lang.String)

rebundle
```
public static QDataSet rebundle(QDataSet bundle1,
                                int[] ii)
```
unbundle datasets by index from the bundle, and rebundle them in the order specified.

Parameters:

bundle1 - a bundle of datasets

ii - the index of each dataset

Returns:

the new bundle

Since:

v2020a_15

See Also:

unbundle(org.das2.qds.QDataSet, java.lang.String)

isLegacyBundle
```
public static boolean isLegacyBundle(QDataSet zds)
```
return true if DEPEND_1 is set and its units are EnumerationUnits. This was the pre-bundle way of representing a bundle of datasets. It might be supported indefinitely, because it has some nice rules about the data. For example, bundled data must be of the same units since there is no place to put the property, and each bundled item must be rank 1.

Parameters:

zds - rank 1 or rank 2 dataset

Returns:

return true if DEPEND_1 is set and its units are EnumerationUnits.

isBundle
```
public static boolean isBundle(QDataSet zds)
```
return true if the dataset is a bundle. It is rank 2 or rank 1, and has the last dimension a bundle dimension.

Parameters:

zds - the dataset

Returns:

true if the dataset is a bundle.

See Also:

Schemes

ensureMonotonic
```
public static QDataSet ensureMonotonic(QDataSet ds)
```
possibly sort the data where the DEPEND_0 tags are monotonically increasing. If the data is already monotonic, then nothing is done to the data.

Parameters:

ds - the dataset

Returns:

the dataset, sorted if necessary.

See Also:

DataSetUtil.isMonotonic(org.das2.qds.QDataSet)

ensureMonotonicAndIncreasingWithFill
```
public static QDataSet ensureMonotonicAndIncreasingWithFill(QDataSet ds)
```
Return data where the DEPEND_0 tags are monotonically increasing and non repeating. Instead of sorting the data, simply replace repeat timetags with a fill record. Note, this does not modify the original dataset (besides the timetags), but instead adds a WEIGHTS plane.

Parameters:

ds - the dataset

Returns:

the dataset, sorted if necessary. TODO: It's surprising that monotonic doesn't imply non-repeating, and this really needs to be revisited. TODO: conside the impact of not modifying the timetags, which greatly increases memory needs.

See Also:

DataSetUtil.isMonotonicAndIncreasingQuick(org.das2.qds.QDataSet)

link
```
public static QDataSet link(QDataSet x,
                            QDataSet y)
```
link is the fundamental operator where we declare that one dataset is dependent on another. For example link(x,y) creates a new dataset where y is the dependent variable of the independent variable x. link is like the plot command, but doesn't plot. For example
```
plot(X,Y) shows a plot of Y(X),
link(X,Y) returns the dataset Y(X).
```
Parameters:

x - rank 1 dataset

y - rank 1 or rank 2 bundle dataset

Returns:

rank 1 dataset with DEPEND_0 set to x.

link
```
public static QDataSet link(QDataSet x,
                            QDataSet y,
                            QDataSet z)
```
link is the fundamental operator where we declare that one dataset is dependent on another. For example link(x,y,z) creates a new dataset where z is the dependent variable of the independent variables x and y. link is like the plot command, but doesn't plot. For example
```
   plot(x,y,z) shows a plot of Z(X,Y),
   link(x,y,z) returns the dataset Z(X,Y).
```
Note if z is a rank 1 dataset, then a bundle dataset Nx3 is returned, and names are assigned to the datasets
Parameters:

x - rank 1 dataset

y - rank 1 dataset

z - rank 1 or 2 dataset.

Returns:

rank 1 or 2 dataset with DEPEND_0 and DEPEND_1 set to X and Y.

link

public static QDataSet link(QDataSet d0,
                            QDataSet d1,
                            QDataSet d2,
                            QDataSet z)

like bundle, but declare the last dataset is dependent on the first three.

Parameters:: d0 - rank 1 dataset; d1 - rank 1 dataset; d2 - rank 1 dataset; z - rank 1 or rank 3 dataset.
Returns:: rank 2 bundle when z is rank 1, or a rank 3 dataset when z is rank 3.

link

public static QDataSet link(QDataSet d0,
                            QDataSet d1,
                            QDataSet d2,
                            QDataSet d3,
                            QDataSet z)

like bundle, but declare the last dataset is dependent on the first three.

Parameters:: d0 - rank 1 dataset; d1 - rank 1 dataset; d2 - rank 1 dataset; d3 - rank 1 dataset; z - rank 1 or rank 4 dataset.
Returns:: rank 2 bundle when z is rank 1, or a rank 3 dataset when z is rank 3.

link
```
public static QDataSet link(java.lang.Object x,
                            java.lang.Object y)
```
Parameters:

x - object which can be converted to a QDataSet

y - object which can be converted to a QDataSet

Returns:

the dataset

See Also:

link(org.das2.qds.QDataSet, org.das2.qds.QDataSet), link(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

link
```
public static QDataSet link(java.lang.Object x,
                            java.lang.Object y,
                            java.lang.Object z)
```
Parameters:

x - object which can be converted to a QDataSet

y - object which can be converted to a QDataSet

z - object which can be converted to a QDataSet

Returns:

the dataset

See Also:

link(org.das2.qds.QDataSet, org.das2.qds.QDataSet), link(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

link
```
public static QDataSet link(java.lang.Object d0,
                            java.lang.Object d1,
                            java.lang.Object d2,
                            java.lang.Object z)
```
Parameters:

d0 - object which can be converted to a QDataSet

d1 - object which can be converted to a QDataSet

d2 - object which can be converted to a QDataSet

z - object which can be converted to a QDataSet

Returns:

the dataset

See Also:

link(org.das2.qds.QDataSet, org.das2.qds.QDataSet), link(org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet, org.das2.qds.QDataSet)

dependsOn
```
public static MutablePropertyDataSet dependsOn(QDataSet ds,
                                               int dim,
                                               QDataSet dep)
```
declare that the dataset is a dependent parameter of an independent parameter. This isolates the QDataSet semantics, and verifies correctness. See also link(x,y).

Parameters:

ds - the dataset

dim - dimension to declare dependence: 0,1,2.

dep - the independent dataset.

Returns:

the dataset, which may be a copy if the data was not mutable.

join
```
public static QDataSet join(QDataSet ds2)
```
Deprecated. use join(null,ds2) instead.

This one-argument join was used in a script that George had, so it must have been a function at some point.

Parameters:

ds2 - rank N dataset

Returns:

rank N+1 dataset

join
```
public static QDataSet join(QDataSet ds1,
                            QDataSet ds2)
```
Join two rank N datasets to make a rank N+1 dataset, with the first dimension having two elements. This is the anti-slice operator. If the first dataset is rank N+1 JoinDataset and the other is rank N, then the rank N dataset is added to the rank N+1 dataset. This is under-implemented right now, and can only join two rank N datasets or if the first dataset is the result of a join.

Parameters:

ds1 - rank N dataset, or null

ds2 - rank N dataset

Returns:

rank N+1 dataset

See Also:

slices(org.das2.qds.QDataSet, java.lang.Object...), concatenate(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

merge
```
public static QDataSet merge(QDataSet ds1,
                             QDataSet ds2)
```
Merge the two sorted rank N datasets, using their DEPEND_0 datasets, into one rank N dataset. If neither dataset has DEPEND_0, then this will use the datasets themselves. When ds1 occurs "before" ds2, then this is the same as concatenate. When there is a collision where two data points are coincident, use ds1[j]. This is fuzzy, based on the depend_0 cadence of ds1. When ds1 is null (or None), use ds2. Thanks to: http://stackoverflow.com/questions/5958169/how-to-merge-two-sorted-arrays-into-a-sorted-array

Parameters:

ds1 - rank N dataset, or null.

ds2 - rank N dataset

Returns:

dataset of rank N with elements interleaved.

See Also:

concatenate(org.das2.qds.QDataSet, org.das2.qds.QDataSet)

guessLabel
```
public static java.lang.String guessLabel(QDataSet ds)
```
get the label, using the NAME when LABEL is not available.

Parameters:

ds - the dataset

Returns:

the human-readable label.

guessLabel
```
public static java.lang.String guessLabel(QDataSet ds,
                                          java.lang.String deft)
```
get the label, using the NAME when LABEL is not available.

Parameters:

ds - the dataset

deft - the default label to use.

Returns:

the human-readable label.

guessName
```
public static java.lang.String guessName(QDataSet ds)
```
guess a name for the dataset, looking for NAME and then safeName(LABEL). The result will be a Java-style identifier suitable for the variable.

Parameters:

ds - the dataset

Returns:

the name or null if there is no NAME or LABEL

guessName
```
public static java.lang.String guessName(QDataSet ds,
                                         java.lang.String deft)
```
guess a name for the dataset, looking for NAME and then safeName(LABEL). The result will be a Java-style identifier suitable for the variable.

Parameters:

ds - the dataset

deft - the default name to use.

Returns:

the name, or deft if there is no NAME or LABEL.

saferName
```
public static java.lang.String saferName(java.lang.String suggest)
```
extra spaces and pipes cause problems in the Operations text field. Provide so that data sources can provide safer names, while we test safe-name requirements on a broader test set. Use of this method will allow us to see where changes are needed. TODO: where is this used?

Parameters:

suggest - a name, possibly containing pipes (|)

Returns:

suggest, but with pipe converted to underscore.

isSafeName
```
public static boolean isSafeName(java.lang.String name)
```
returns true if the name is a Java-style identifier, starting with one of a-z, A-Z, or _; followed by a-z, A-Z, 0-9, or _; and note that only ASCII characters are allowed.

Parameters:

name -

Returns:

true if the name is a safe identifier name.

safeName
```
public static java.lang.String safeName(java.lang.String suggest)
```
made a Java-style identifier from the provided string See Autoplot/src/scripts/safeName.jy which demonstrates this.

Parameters:

suggest - a name, possibly containing spaces and illegal characters

Returns:

a Java-style identifier

fillIsDifferent
```
public static boolean fillIsDifferent(QDataSet ds1,
                                      QDataSet ds2)
```
return true of the representation of fill is different in the two data sets. TODO: this does not consider WEIGHTS.

Parameters:

ds1 -

ds2 -

Returns:

true of the representation of fill is different in the two data sets.

transpose
```
public static QDataSet transpose(QDataSet ds)
```
transpose the rank 2 or rank 1 dataset. result[i,j]= ds[j,i] for each i,j; or in the case of rank 1, the DEPEND_0 (x) becomes a dependent on the data (y).

Parameters:

ds - rank 2 dataset

Returns:

rank 2 dataset

transpose

public static QDataSet transpose(java.lang.Object ds)

equivalent
```
public static boolean equivalent(QDataSet ds1,
                                 QDataSet ds2)
```
returns true iff the dataset values are equivalent. Note this may promote rank, etc. If the two datasets have enumerations, then we create datums and check .equals. This does not check TITLE, etc, just that the units and values are equal.

Parameters:

ds1 - the first dataset

ds2 - the second dataset

Returns:

true if the dataset values are equivalent.

equivalent

public static boolean equivalent(java.lang.Object ds1,
                                 java.lang.Object ds2)

dimensionCount
```
public static int dimensionCount(QDataSet dss)
```
returns the number of physical dimensions of a dataset.
- JOIN, BINS do not increase dataset dimensionality.
- DEPEND increases dimensionality by dimensionality of DEPEND ds.
- BUNDLE increases dimensionality by N, where N is the number of bundled datasets.
Note this includes implicit dimensions taken by the primary dataset:
- Z(time,freq)→3
- rand(20,20)→3
- B_gsm(20,[X,Y,Z])→4
Parameters:

dss - the dataset

Returns:

the number of dimensions occupied by the data.

dimensionCount
```
public static int dimensionCount(java.lang.Object dss)
```
returns the number of physical dimensions of the object when interpreted as a dataset.

Parameters:

dss - the object that can be coerced into a dataset.

Returns:

the number of dimensions occupied by the data.

See Also:

dataset(java.lang.Object)

fftPowerMultiThread
```
public static QDataSet fftPowerMultiThread(QDataSet ds,
                                           int len,
                                           ProgressMonitor mon)
```
Experiment with multi-threaded FFTPower function. This breaks up the task into four independent tasks that can be run in parallel.

Parameters:

ds - rank 2 dataset ds(N,M) with M>len

len - the number of elements to have in each fft.

mon - a ProgressMonitor for the process

Returns:

rank 2 FFT spectrum

buckshotInterpolate

public static QDataSet buckshotInterpolate(QDataSet xyz,
                                           QDataSet data,
                                           QDataSet xinterp,
                                           QDataSet yinterp,
                                           QDataSet zinterp)

3-D interpolation performed by tesselating the space (with 4-point tetrahedra) and doing interpolation. NOTE: this does not check units.

Parameters:: xyz - rank 2 bundle of x,y,z data.; data - rank 1 dependent data, a function of x,y,z.; xinterp - the x locations to interpolate, rank 0, 1, or 2.; yinterp - the y locations to interpolate; zinterp - the z locations to interpolate
Returns:: the interpolated data.

polyCenters
```
public static QDataSet polyCenters(QDataSet polyMesh)
```
return an array of the centers of each triangle in the triangle mesh.

Parameters:

polyMesh -

Returns:

rank 2 ds[n,2].

See Also:

Schemes#triangleMesh()

createPolyMesh
```
public static QDataSet createPolyMesh(QDataSet append,
                                      QDataSet xy)
```
create or append to a polyMesh, adding the points from rank 2 bundle xy. The polyMesh scheme will assume that point xy[0] can be connected to point xy[-1].

Parameters:

in - null or a polyMesh to append the result.

xy - the rank 2 bundle of x and y values

Returns:

a polyMesh

See Also:

createEvent(org.das2.qds.QDataSet, org.das2.datum.DatumRange, int, java.lang.String)

triangulate
```
public static QDataSet triangulate(QDataSet xx,
                                   QDataSet yy)
```
return a triangle tesselation of the space identified by rank 1 xx and yy.

Parameters:

xx - rank 1 dataset

yy - rank 1 dataset

Returns:

rank 2 ds[n,3] dataset.

buckshotInterpolate

public static QDataSet buckshotInterpolate(QDataSet xy,
                                           QDataSet data,
                                           QDataSet xinterp,
                                           QDataSet yinterp)

2-D interpolation performed by tessellating the space (with 3-point triangles) and doing interpolation. NOTE: this does not check units.

Parameters:: xy - rank 2 bundle of independent data x,y points.; data - rank 1 dependent data, a function of x,y.; xinterp - the x locations to interpolate; yinterp - the y locations to interpolate
Returns:: the interpolated data.

matrixParse
```
public static final QDataSet matrixParse(java.lang.String smat)
```
parse the string into a rank 2 matrix

Parameters:

smat - a string like '[[1,0,0],[0,1,0],[0,0,1]]'

Returns:

rank 2 matrix.

See Also:

matrixFormat(org.das2.qds.QDataSet, java.lang.String)

matrixFromEuler

public static final QDataSet matrixFromEuler(java.lang.String seq,
                                             Datum angle)

return the matrix rotating about one axis.

Parameters:: seq - the string "x", "y", or "z"; angle - the angle in degrees or radians.
Returns:

matrixMultiply
```
public static final QDataSet matrixMultiply(QDataSet m,
                                            QDataSet v)
```
matrix multiply the components of vector v by matrix m. Argument v can also be a rank 2 series of vectors (vv[n,3]), and argument m can be an array of matrices (mm[n,3,3]). Note that to multiply a vector and a matrix (instead of matrix and a vector), use matrixMultiply( transpose(m), v ).

Parameters:

m - matrix or array of matrices

v - vector or array of vectors

Returns:

vectors in the same form as b

See Also:

bundle for creating vectors from components., for extracting components from the result.

matrixFormat
```
public static java.lang.String matrixFormat(QDataSet mm,
                                            java.lang.String style)
```
format the matrix values, using %.3f and tabs to make it legible.

Parameters:

mm - the 3x3 matrix.

style - "code" or "newlines". None/null is newlines.

Returns:

formatted matrix

See Also:

will parse when style is "code"

gamma
```
public static final double gamma(double n)
```
return the gamma function for numbers greater than 0. This will soon work for any number where gamma has a result (Apache Math v3 is needed for this).

Parameters:

n -

Returns:

gamma
```
public static final QDataSet gamma(java.lang.Object n)
```
return the gamma function for numbers greater than 0. This will soon work for any number where gamma has a result (Apache Math v3 is needed for this).

Parameters:

n -

Returns:

Class Ops

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PI

TAU

E

Method Detail

applyUnaryOp

applyUnaryOp

applyBinaryOp

applyBinaryOp

equalProperties

add

add

add

subtract

subtract

negate

negate

magnitude

magnitude

total

total

total

total

total

reduceMax

reduceMax

reduceSum

reduceMin

reduceMin

reduceMean

reduceMean

reduceMedian

reduceBins

binData

normalize

normalize

decimate

decimate

decimate

collapse0

collapse0

collapse0R4

collapse1R4

collapse1

collapse2

collapse2R4

collapse3

collapse3R4

trim

trim

trim

trim

trim

trim

trim1

trim1

setDepend0Cadence

setDepend1Cadence

setValidRange

setNominalRange

setWarnRange

sqrt

sqrt

sqrt

butterworth

butterworth

cubicRoot

cubicRoot

abs

abs

abs

abs

pow

pow

pow