calc,
funcs,
@@ -53,7 +53,7 @@
xsdvalidate.
Object[] to an array of
+- * Comparable[]. Anything which is not comparable is
+- * replaced by null.
+- *
+- * @param objs objects
+- * @return comparable array with the same contents as objs
+- */
+- private Comparable[] toComparables( Object[] objs ) {
+- Comparable[] comps = new Comparable[ objs.length ];
+- for ( int i = 0; i < comps.length; i++ ) {
+- comps[ i ] = objs[ i ] instanceof Comparable
+- ? (Comparable) objs[ i ]
+- : null;
+- }
+- return comps;
+- }
+-
+ /**
+ * Creates a new ValueWrapper instance suitable for adapting values
+ * described by a given ValueInfo object.
diff -Nru starjava-ttools-3.4.5/debian/patches/Use-a-local-copy-of-the-XSLT-stylesheets-instead-of-xdoc.patch starjava-ttools-3.4.6/debian/patches/Use-a-local-copy-of-the-XSLT-stylesheets-instead-of-xdoc.patch
--- starjava-ttools-3.4.5/debian/patches/Use-a-local-copy-of-the-XSLT-stylesheets-instead-of-xdoc.patch 2022-06-13 14:59:22.000000000 +0000
+++ starjava-ttools-3.4.6/debian/patches/Use-a-local-copy-of-the-XSLT-stylesheets-instead-of-xdoc.patch 2022-07-14 17:35:39.000000000 +0000
@@ -10,7 +10,7 @@
2 files changed, 17 insertions(+), 55 deletions(-)
diff --git a/build.xml b/build.xml
-index 6b8717d..944be7e 100644
+index 0fbd545..153dbae 100644
--- a/build.xml
+++ b/build.xml
@@ -114,7 +114,7 @@
diff -Nru starjava-ttools-3.4.5/debian/patches/Use-android-json.patch starjava-ttools-3.4.6/debian/patches/Use-android-json.patch
--- starjava-ttools-3.4.5/debian/patches/Use-android-json.patch 2022-06-13 14:59:22.000000000 +0000
+++ starjava-ttools-3.4.6/debian/patches/Use-android-json.patch 2022-07-14 17:35:39.000000000 +0000
@@ -59,7 +59,7 @@
json.put( "nbformat", 4 );
json.put( "nbformat_minor", 2 );
diff --git a/src/main/uk/ac/starlink/ttools/build/Plot2Example.java b/src/main/uk/ac/starlink/ttools/build/Plot2Example.java
-index 0978e7d..82de46f 100644
+index 9695c7c..06fb14c 100644
--- a/src/main/uk/ac/starlink/ttools/build/Plot2Example.java
+++ b/src/main/uk/ac/starlink/ttools/build/Plot2Example.java
@@ -31,6 +31,7 @@ import javax.swing.JComponent;
diff -Nru starjava-ttools-3.4.5/debian/patches/Use-starlink-ttools.jar-as-main-jar-for-STILTS-and-add-to.patch starjava-ttools-3.4.6/debian/patches/Use-starlink-ttools.jar-as-main-jar-for-STILTS-and-add-to.patch
--- starjava-ttools-3.4.5/debian/patches/Use-starlink-ttools.jar-as-main-jar-for-STILTS-and-add-to.patch 2022-06-13 14:59:22.000000000 +0000
+++ starjava-ttools-3.4.6/debian/patches/Use-starlink-ttools.jar-as-main-jar-for-STILTS-and-add-to.patch 2022-07-16 08:40:35.000000000 +0000
@@ -14,7 +14,7 @@
1 file changed, 2 insertions(+)
diff --git a/build.xml b/build.xml
-index ff636b8..6b8717d 100644
+index 64deb83..0fbd545 100644
--- a/build.xml
+++ b/build.xml
@@ -246,6 +246,7 @@
diff -Nru starjava-ttools-3.4.5/.properties starjava-ttools-3.4.6/.properties
--- starjava-ttools-3.4.5/.properties 2022-06-10 13:14:05.000000000 +0000
+++ starjava-ttools-3.4.6/.properties 2022-07-08 09:59:19.000000000 +0000
@@ -6,8 +6,6 @@
Moc.jar \
skyview-geom.jar \
jlatexmath.jar \
- ucidy-1.2-beta.jar \
- unity-1.1pre.jar \
jide-oss.jar \
../util/util.jar \
../table/table.jar \
@@ -25,6 +23,8 @@
../vo/vo.jar \
../pal/pal.jar \
../dpac/dpac.jar \
+ ../vo/ucidy-1.2-beta.jar \
+ ../vo/unity-1.1pre.jar \
../plastic/plastic.jar \
../connect/connect.jar \
../astrogrid/astrogrid.jar \
diff -Nru starjava-ttools-3.4.5/src/docs/sun256.xml starjava-ttools-3.4.6/src/docs/sun256.xml
--- starjava-ttools-3.4.5/src/docs/sun256.xml 2022-06-10 13:14:05.000000000 +0000
+++ starjava-ttools-3.4.6/src/docs/sun256.xml 2022-07-08 09:59:19.000000000 +0000
@@ -76,6 +76,7 @@
+
@@ -176,7 +177,7 @@
tcatn,
tloop,
tjoin,
+ arrayjoin,
tgridmap, and
tcube
(see ).
@@ -536,6 +538,7 @@
name of one of the tasks listed in - currently
the available tasks are:
arrayjoincalccdsskymatchconeYou can use the special functions
+ valueDouble, valueInt, valueLong,
+ valueString and valueObject
+ to obtain the typed value of a column with a given name.
+ The argument of the function is a string giving the exact
+ (case-sensitive) column name, for instance
+ valueDouble("b_E(BP-RP)")
+ will yield the value of the column named "b_E(BP-RP)"
+ as a double-precision floating point value.
+ These functions are not the generally recommended way
+ to get column values,
+ since they are slower and provide less type-checking than
+ the other options listed above,
+ and can occasionally lead to some other esoteric problems.
+ However, if you need to refer by name to strangely-named columns
+ they are sometimes a convenient option.
+
If a column is referenced with the prefix "Object$"
before its identifier
@@ -5411,6 +5433,9 @@
tjoin:
&tjoin-purpose;
arrayjoin:
+ &arrayjoin-purpose;
+ tgridmap:
&tgridmap-purpose;
arrayjoin takes an input table and for each row
+adds the contents of a separate "array" table.
+The columns added are the columns from the array table,
+and the value of each cell is the value of the whole column from
+the array table represented as an array.
+The assumption is that all the array tables have the same form
+(the same columns, though not necessarily the same row counts).
+
This can be useful for constructing a single table +with array-valued columns containing data that is made +available in multiple external files, for instance +via the DataLink protocol; +this is illustrated in the Examples subsection below. +Note however that this command does not understand DataLink directly, +and cannot itself determine the location of the external array tables; +an expression giving their per-row location (filname or URL) +must be supplied. +
+ +&arrayjoin-summary; + +Here are some examples of using arrayjoin:
+
This command uses the Gaia DR3 DataLink service + to attach sampled XP spectrum data to an input table containing + other information about Gaia DR3 sources. +
+The input file dr3-sources.vot must contain the column
+ source_id giving the Gaia DR3 source ID
+ corresponding to that row.
+ The atable expression is a URL built using that
+ source_id column and a base URL that can be obtained
+ by examining the DR3 catalogue
+
The output file sources-with-xp.fits
+ is a FITS table with the same content as the input
+ but with three added array-valued columns,
+ wavelength, flux and flux_error
+ as supplied by tables downloaded from the URL in the atable
+ parameter.
+ For each row of the output table, the lengths of those three arrays
+ will be the same, namely the row count of the table that supplied them.
+ These matched arrays can be manipulated within STILTS,
+ for instance using the
+ Arrays functions
+ or to produce plots using the
+ lines or
+ arrayquantile plot layer types.
+
The icmd=progress filter is a useful convenience to see
+ how the command is progressing,
+ since the operation requires multiple downloads and so may be
+ time-consuming.
+
Similar to the previous example, but this time acquiring
+ EPOCH_PHOTOMETRY rather than XP_SAMPLED data,
+ and performing some additional
+ processing of the main and array input tables.
+ Only those input rows are used for which the boolean
+ has_epoch_photometry column is True;
+ for the linked array tables the rows are limited to those with
+ the BAND column having the value "G";
+ and only the array columns
+ time, mag and flux
+ are retained for inclusion into the output.
+
Takes an ivoa.ObsCore-like table and adds array-valued
+ columns giving the content of spectrum files linked from
+ the access_url field.
+ For rows in the input table whose dataproduct_type
+ field does not have the value "spectrum" a blank location
+ is substituted insteead of the access_url.
+ That has the effect of ensuring that no attempt is made
+ to add array values for non-spectrum rows of the input table,
+ while retaining those rows in the output.
+ Note all the access_urls in the selected rows must point to
+ spectrum files of a of a similar form,
+ otherwise the command will fail.
+
+
+
arrayjoin
+ added.add, subtract,
+ multiply, divide in class
+ Arrays;
+ these now all take either two array arguments or an array
+ and a scalar in either order.dotProduct in class
+ Arrays.value* functions for
+ column references
+ to strangely-named columns.taplint EPN stage
+ update; now corresponds to PR-EPNTAP-20220705.+
null is returned.
- * The types of the arrays do not need to be the same,
- * so for example it is permitted to add an integer array
- * to a floating point array.
- *
- * @example add(array(1,2,3), array(0.1,0.2,0.3))
- * = [1.1, 2.2, 3.3]
- *
- * @param array1 first array of numeric values
- * @param array2 second array of numeric values
- * @return element-by-element sum of
- * array1 and array2,
- * the same length as the input arrays
- */
- public static double[] add( Object array1, Object array2 ) {
- int n = getNumericArrayLength( array1 );
- if ( n >= 0 && getNumericArrayLength( array2 ) == n ) {
- double[] out = new double[ n ];
- for ( int i = 0; i < n; i++ ) {
- out[ i ] = Array.getDouble( array1, i )
- + Array.getDouble( array2, i );
+ * Returns the dot (scalar) product of two numeric arrays.
+ * If either argument is not an array, or if the arrays are not of
+ * the same length, a blank value is returned.
+ *
+ * @example dotProduct(array(3,4,5), array(1,2,3)) = 26
+ *
+ * @param array1 first array
+ * @param array2 second array
+ * @return sum of element-wise products of input arrays
+ */
+ public static double dotProduct( Object array1, Object array2 ) {
+ int n1 = getNumericArrayLength( array1 );
+ int n2 = getNumericArrayLength( array2 );
+ if ( n1 >= 0 && n1 == n2 ) {
+ double d = 0;
+ for ( int i = 0; i < n1; i++ ) {
+ d += Array.getDouble( array1, i )
+ * Array.getDouble( array2, i );
}
- return out;
+ return d;
}
else {
- return null;
+ return Double.NaN;
}
}
/**
- * Returns the result of adding a constant value to every element of
- * a numeric array.
- * If the supplied array argument is not a numeric array,
- * null is returned.
+ * Returns the element-by-element result of adding
+ * either two numeric arrays of the same length,
+ * or an array and a scalar considered as if an array of the right length.
+ *
+ * If the arguments are not as expected
+ * (e.g. arrays of different lengths, both scalars, not numeric)
+ * then null is returned.
*
+ * @example add(array(1,2,3), array(0.1,0.2,0.3))
+ * = [1.1, 2.2, 3.3]
* @example add(array(1,2,3), 10) = [11,12,13]
*
- * @param array array input
- * @param constant value to add to each array element
- * @return array output,
- * the same length as the array parameter
+ * @param arrayOrScalar1 first numeric array/scalar
+ * @param arrayOrScalar2 second numeric array/scalar
+ * @return element-by-element result of
+ * arrayOrScalar1 + arrayOrScalar2,
+ * the same length as the input array(s)
*/
- public static double[] add( Object array, double constant ) {
- int n = getNumericArrayLength( array );
- if ( n >= 0 ) {
- double[] out = new double[ n ];
- for ( int i = 0; i < n; i++ ) {
- out[ i ] = Array.getDouble( array, i ) + constant;
- }
- return out;
- }
- else {
- return null;
- }
+ public static double[] add( Object arrayOrScalar1, Object arrayOrScalar2 ) {
+ return arrayOp( arrayOrScalar1, arrayOrScalar2, ADD );
}
/**
- * Returns the result of subtracting one numeric array from the other
- * element by element.
- * Both arrays must be numeric, and the arrays must have the same length.
- * If either of those conditions is not true, null is returned.
- * The types of the arrays do not need to be the same,
- * so for example it is permitted to subtract an integer array
- * from a floating point array.
+ * Returns the element-by-element result of subtracting
+ * either two numeric arrays of the same length,
+ * or an array and a scalar considered as if an array of the right length.
+ *
+ *
If the arguments are not as expected
+ * (e.g. arrays of different lengths, both scalars, not numeric)
+ * then null is returned.
*
* @example subtract(array(1,2,3), array(0.1,0.2,0.3))
* = [0.9, 1.8, 2.7]
+ * @example subtract(array(1,2,3), 1.0)
+ * = [0, 1, 2]
*
- * @param array1 first array of numeric values
- * @param array2 second array of numeric values
- * @return element-by-element difference of
- * array1 and array2,
- * the same length as the input arrays
- */
- public static double[] subtract( Object array1, Object array2 ) {
- int n = getNumericArrayLength( array1 );
- if ( n >= 0 && getNumericArrayLength( array2 ) == n ) {
- double[] out = new double[ n ];
- for ( int i = 0; i < n; i++ ) {
- out[ i ] = Array.getDouble( array1, i )
- - Array.getDouble( array2, i );
- }
- return out;
- }
- else {
- return null;
- }
+ * @param arrayOrScalar1 first numeric array/scalar
+ * @param arrayOrScalar2 second numeric array/scalar
+ * @return element-by-element result of
+ * arrayOrScalar1 - arrayOrScalar2,
+ * the same length as the input array(s)
+ */
+ public static double[] subtract( Object arrayOrScalar1,
+ Object arrayOrScalar2 ) {
+ return arrayOp( arrayOrScalar1, arrayOrScalar2, SUBTRACT );
}
/**
- * Returns the result of multiplying two numeric arrays element by element.
- * Both arrays must be numeric, and the arrays must have the same length.
- * If either of those conditions is not true, null is returned.
- * The types of the arrays do not need to be the same,
- * so for example it is permitted to multiply an integer array
- * by a floating point array.
+ * Returns the element-by-element result of multiplying
+ * either two numeric arrays of the same length,
+ * or an array and a scalar considered as if an array of the right length.
*
- * @example multiply(array(1,2,3), array(2,4,6)) = [2, 8, 18]
- *
- * @param array1 first array of numeric values
- * @param array2 second array of numeric values
- * @return element-by-element product of
- * array1 and array2,
- * the same length as the input arrays
- */
- public static double[] multiply( Object array1, Object array2 ) {
- int n = getNumericArrayLength( array1 );
- if ( n >= 0 && getNumericArrayLength( array2 ) == n ) {
- double[] out = new double[ n ];
- for ( int i = 0; i < n; i++ ) {
- out[ i ] = Array.getDouble( array1, i )
- * Array.getDouble( array2, i );
- }
- return out;
- }
- else {
- return null;
- }
- }
-
- /**
- * Returns the result of multiplying every element of a numeric array
- * by a constant value.
- * If the supplied array argument is not a numeric array,
- * null is returned.
+ *
If the arguments are not as expected
+ * (e.g. arrays of different lengths, both scalars, not numeric)
+ * then null is returned.
*
- * @example multiply(array(1,2,3), 2) = [2, 4, 6]
+ * @example multiply(array(1,2,3), array(2,4,6)) = [2, 8, 18]
+ * @example multiply(2, array(1,2,3)) = [2, 4, 6]
*
- * @param array array input
- * @param constant value by which to multiply each array element
- * @return array output,
- * the same length as the array parameter
+ * @param arrayOrScalar1 first numeric array/scalar
+ * @param arrayOrScalar2 second numeric array/scalar
+ * @return element-by-element result of
+ * arrayOrScalar1 * arrayOrScalar2,
+ * the same length as the input array(s)
*/
- public static double[] multiply( Object array, double constant ) {
- int n = getNumericArrayLength( array );
- if ( n >= 0 ) {
- double[] out = new double[ n ];
- for ( int i = 0; i < n; i++ ) {
- out[ i ] = Array.getDouble( array, i ) * constant;
- }
- return out;
- }
- else {
- return null;
- }
+ public static double[] multiply( Object arrayOrScalar1,
+ Object arrayOrScalar2 ) {
+ return arrayOp( arrayOrScalar1, arrayOrScalar2, MULTIPLY );
}
/**
- * Returns the result of dividing two numeric arrays element by element.
- * Both arrays must be numeric, and the arrays must have the same length.
- * If either of those conditions is not true, null is returned.
- * The types of the arrays do not need to be the same,
- * so for example it is permitted to divide an integer array
- * by a floating point array.
+ * Returns the element-by-element result of dividing
+ * either two numeric arrays of the same length,
+ * or an array and a scalar considered as if an array of the right length.
+ *
+ *
If the arguments are not as expected
+ * (e.g. arrays of different lengths, both scalars, not numeric)
+ * then null is returned.
*
* @example divide(array(0,9,4), array(1,3,8)) = [0, 3, 0.5]
+ * @example divide(array(50,60,70), 10) = [5, 6, 7]
*
- * @param array1 array of numerator values (numeric)
- * @param array2 array of denominator values (numeric)
- * @return element-by-element result of array1[i]/array2[i]
- * the same length as the input arrays
- */
- public static double[] divide( Object array1, Object array2 ) {
- int n = getNumericArrayLength( array1 );
- if ( n >= 0 && getNumericArrayLength( array2 ) == n ) {
- double[] out = new double[ n ];
- for ( int i = 0; i < n; i++ ) {
- out[ i ] = Array.getDouble( array1, i )
- / Array.getDouble( array2, i );
- }
- return out;
- }
- else {
- return null;
- }
+ * @param arrayOrScalar1 first numeric array/scalar
+ * @param arrayOrScalar2 second numeric array/scalar
+ * @return element-by-element result of
+ * arrayOrScalar1 / arrayOrScalar2,
+ * the same length as the input array(s)
+ */
+ public static double[] divide( Object arrayOrScalar1,
+ Object arrayOrScalar2 ) {
+ return arrayOp( arrayOrScalar1, arrayOrScalar2, DIVIDE );
}
/**
@@ -1319,6 +1267,129 @@
}
/**
+ * Performs an operation on two input numeric arrays returning one
+ * numeric array of the same length.
+ * One or other, but not both, of the input array values may in fact
+ * be a scalar which is treated as an array of the appropriate length.
+ *
+ * @param aos1 first array or scalar
+ * @param aos2 second array or scalar
+ * @param operator element-wise operation
+ * @return array result of applying operator to each pair of elements,
+ * or null if input operands are not suitable
+ */
+ private static double[] arrayOp( Object aos1, Object aos2,
+ DoubleBinaryOperator operator ) {
+ ElementHandler eh1 = createElementHandler( aos1 );
+ if ( eh1 == null ) {
+ return null;
+ }
+ ElementHandler eh2 = createElementHandler( aos2 );
+ if ( eh2 == null ) {
+ return null;
+ }
+ int leng1 = eh1.length_;
+ int leng2 = eh2.length_;
+ final int leng;
+ if ( leng1 == leng2 ) {
+ leng = leng1;
+ }
+ else if ( leng1 < 0 ) {
+ leng = leng2;
+ }
+ else if ( leng2 < 0 ) {
+ leng = leng1;
+ }
+ else {
+ leng = -1;
+ }
+ if ( leng >= 0 ) {
+ double[] result = new double[ leng ];
+ for ( int i = 0; i < leng; i++ ) {
+ result[ i ] = operator.applyAsDouble( eh1.getElement( i ),
+ eh2.getElement( i ) );
+ }
+ return result;
+ }
+ else {
+ return null;
+ }
+ }
+
+ /**
+ * Constructs an ElementHandler from an argument that may be either
+ * a numeric (wrapper) scalar or a numeric (primitive) array.
+ * In case of a scalar, the length is reported as -1.
+ *
+ * @param aos array or scalar
+ * @return element handler, or null if input is not suitable
+ */
+ private static ElementHandler createElementHandler( Object aos ) {
+ if ( aos instanceof Number ) {
+ final double scalar = ((Number) aos).doubleValue();
+ return new ElementHandler( i -> scalar, -1 );
+ }
+ else if ( aos instanceof double[] ) {
+ final double[] array = (double[]) aos;
+ return new ElementHandler( i -> array[ i ], array.length );
+ }
+ else if ( aos instanceof float[] ) {
+ final float[] array = (float[]) aos;
+ return new ElementHandler( i -> array[ i ], array.length );
+ }
+ else if ( aos instanceof int[] ) {
+ final int[] array = (int[]) aos;
+ return new ElementHandler( i -> array[ i ], array.length );
+ }
+ else if ( aos instanceof short[] ) {
+ final short[] array = (short[]) aos;
+ return new ElementHandler( i -> array[ i ], array.length );
+ }
+ else if ( aos instanceof long[] ) {
+ final long[] array = (long[]) aos;
+ return new ElementHandler( i -> array[ i ], array.length );
+ }
+ else if ( aos instanceof byte[] ) {
+ final byte[] array = (byte[]) aos;
+ return new ElementHandler( i -> array[ i ], array.length );
+ }
+ else {
+ return null;
+ }
+ }
+
+ /**
+ * Provides indexed double values.
+ * This serves as a generalised representation of a double array.
+ */
+ private static class ElementHandler {
+ final int length_;
+ final IntToDoubleFunction accessor_;
+
+ /**
+ * Constructs an ElementHandler with a given finite length.
+ *
+ * @param accessor provides value access
+ * @param length number of elements available;
+ * if negative any input index is acceptable
+ */
+ ElementHandler( IntToDoubleFunction accessor, int length ) {
+ accessor_ = accessor;
+ length_ = length;
+ }
+
+ /**
+ * Returns the value at a given index.
+ *
+ * @param i index
+ * @return value at index
+ */
+ double getElement( int i ) {
+ return accessor_.applyAsDouble( i );
+ }
+ }
+
+ /**
* Class to cache compiled array functions.
*/
private static class ArrayFuncMap {
diff -Nru starjava-ttools-3.4.5/src/main/uk/ac/starlink/ttools/func/VO.java starjava-ttools-3.4.6/src/main/uk/ac/starlink/ttools/func/VO.java
--- starjava-ttools-3.4.5/src/main/uk/ac/starlink/ttools/func/VO.java 2022-06-10 13:14:05.000000000 +0000
+++ starjava-ttools-3.4.6/src/main/uk/ac/starlink/ttools/func/VO.java 2022-07-08 09:59:19.000000000 +0000
@@ -5,8 +5,8 @@
package uk.ac.starlink.ttools.func;
-import uk.ac.starlink.ttools.votlint.UcdStatus;
-import uk.ac.starlink.ttools.votlint.UnitStatus;
+import uk.ac.starlink.vo.UcdStatus;
+import uk.ac.starlink.vo.UnitStatus;
/**
* Virtual Observatory-specific functions.
diff -Nru starjava-ttools-3.4.5/src/main/uk/ac/starlink/ttools/jel/StarTableJELRowReader.java starjava-ttools-3.4.6/src/main/uk/ac/starlink/ttools/jel/StarTableJELRowReader.java
--- starjava-ttools-3.4.5/src/main/uk/ac/starlink/ttools/jel/StarTableJELRowReader.java 2022-06-10 13:14:05.000000000 +0000
+++ starjava-ttools-3.4.6/src/main/uk/ac/starlink/ttools/jel/StarTableJELRowReader.java 2022-07-08 09:59:19.000000000 +0000
@@ -1,7 +1,9 @@
package uk.ac.starlink.ttools.jel;
import java.io.IOException;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;
@@ -57,6 +59,21 @@
* within this reader. The quality of the random numbers may not
* be particularly good.
*
+ *
Gives the location of the table whose rows will be turned into", + "an array-valued column.", + "This will generally be an expression", + "giving a URL or filename that is different", + "for each row of the input table.", + "If table loading fails for the given location,", + "for instance becase the file is not found or an HTTP 404", + "response is received,", + "the array cells in the corresponding row will be blank.", + "
", + "The first non-blank table loaded defines the array columns",
+ "to be added.",
+ "If subsequent tables have a different structure",
+ "(do not contain similar columns in a similar sequence)",
+ "an error may result.",
+ "If the external array tables are not all homogenous in this way,",
+ "the " + acmdParam_.getName() + " parameter",
+ "can be used to filter them so that they are.",
+ "
Determines whether the array data will be cached", + "the first time an array table is read (true)", + "or re-read from the array table every time", + "the row is accessed (false).", + "Since the row construction may be an expensive step,", + "especially if the tables are downloaded,", + "it usually makes sense to set this true (the default).", + "When true it also enables the metadata to be adjusted", + "to report constant array length where applicable,", + "which cannot be done before all the rows have been scanned,", + "and which may enable more efficient file output.", + "However, if you want to stream the data you can set it false.", + "
", + } ); + + fixcolsParam_ = new JoinFixActionParameter( "fixcols" ); + asuffixParam_ = + fixcolsParam_ + .createSuffixParameter( "suffixarray", "the array tables", "_a" ); + } + + @Override + public Parameter[] getParameters() { + ListGregory Mantelet's Ucidy library is used for UCD1+ parsing.
- *
- * @author Mark Taylor
- * @since 9 Jul 2021
- */
-public class UcdStatus {
-
- private final Code code_;
- private final String message_;
-
- private static final Map Norman Gray's Unity library is used for VOUnits parsing.
- *
- * @author Mark Taylor
- * @since 9 Jul 2021
- * @see VOUnits
- */
-public class UnitStatus {
-
- private final Code code_;
- private final String message_;
- private static final Map