| Overview | Package | Class | Tree | Deprecated | Index | Help |
|
AlgART Home | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
comments to this class).MutableArray interface.AbstractArray(initialCapacity, initialLength, new Array[0]).AbstractArray(initialCapacityAndLength, initialCapacityAndLength, new Array[0]).ArrayContext interface to minimize
the effort required to implement this interface.ArrayProcessorWithContextSwitching interface.BitArray interface.AbstractBitArray.AbstractBitArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.ByteArray interface.AbstractByteArray.AbstractByteArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.CharArray interface.AbstractCharArray.AbstractCharArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.Context interface to minimize
the effort required to implement this interface.CoordinateTransformationOperator interface to minimize
the effort required to implement this interface.DataFileModel interface to minimize
the effort required to implement this interface for processing usual disk files.AbstractDataFileModel(null, 0).DoubleArray interface.AbstractDoubleArray.AbstractDoubleArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.FloatArray interface.AbstractFloatArray.AbstractFloatArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.Func interface to minimize
the effort required to implement this interface.IntArray interface.AbstractIntArray.AbstractIntArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.IterativeArrayProcessor interface.LongArray interface.AbstractLongArray.AbstractLongArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.Matrix interface to minimize
the effort required to implement this interface.MemoryModel interface to minimize
the effort required to implement this interface.Morphology interface to minimize
the effort required to implement this interface.ObjectArray interface.AbstractObjectArray.AbstractObjectArray(MemoryModel, Class, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.Pattern interface to minimize
the effort required to implement this interface.ShortArray interface.AbstractShortArray.AbstractShortArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.SpectralTransform interface to minimize
the effort required to implement this interface.ThreadPoolFactory interface.UpdatableBitArray interface.AbstractUpdatableBitArray.AbstractUpdatableBitArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableByteArray interface.AbstractUpdatableByteArray.AbstractUpdatableByteArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableCharArray interface.AbstractUpdatableCharArray.AbstractUpdatableCharArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableDoubleArray interface.AbstractUpdatableDoubleArray.AbstractUpdatableDoubleArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableFloatArray interface.AbstractUpdatableFloatArray.AbstractUpdatableFloatArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableIntArray interface.AbstractUpdatableIntArray.AbstractUpdatableIntArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableLongArray interface.AbstractUpdatableLongArray.AbstractUpdatableLongArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableObjectArray interface.AbstractUpdatableObjectArray.AbstractUpdatableObjectArray(MemoryModel, Class, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableShortArray interface.AbstractUpdatableShortArray.AbstractUpdatableShortArray(MemoryModel, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.WeightedPattern interface to minimize
the effort required to implement this interface.mapped blocks
that were created by not finalized yet by this model.invokeOnDeallocation method,
but not fully performed yet.coord(i)+point.coord(i).coord(i)+point.coord(i).asArray
and asUpdatableArray
methods, that means the region from the specified position to the file end.ObjectArray.elementType() class in some state.AbstractDataFileModel.allTemporaryFiles() method returns its clone.union decompositions
with the equal or similar quality.data file models, that were used
in any instances of this class (as constructor agruments) since the application start.ApertureFilterOperator.apertureDim()[coordIndex].ApertureFilterOperator
in n-dimensional Euclidean space.ApertureFilterOperator.apertureFrom()[coordIndex].ApertureFilterOperator.apertureSteps()[coordIndex].ApertureFilterOperator.apertureFrom()[coordIndex] + (ApertureFilterOperator.apertureDim()[coordIndex] - 1)
* ApertureFilterOperator.apertureSteps()[coordIndex].CoordinateTransformedFunc.getInstance(f, this).applyFunc(context, f, true, result, x).applyFunc(context, f, truncateOverflows, 0, true, result, x).asFuncArray(null, truncateOverflows, f, necessaryType, x) call
and copies it into the result argument by
copy(context, result, lazy, numberOfTasks, strictMode) call.applyFunc(context, true, f, result, x).applyFunc(context, truncateOverflows, f, result, several(PArray.class, x)).applyFunc(context, true, f, result, x1, x2).applyFunc(context, truncateOverflows, f, result, several(PArray.class, x1, x2)).applyFunc(context, true, f, result, x1, x2, x3).applyFunc(context, truncateOverflows, f, result, several(PArray.class, x1, x2, x3)).applyFunc(context, true, f, result, x).Arrays.applyFunc(context, truncateOverflows, f, result.array(), arrays),
where arrays is
{x.get(0).array(), x.get(1).array(), ...}.directTransform,
inverseTransform, directTransformMatrix,
inverseTransformMatrix) can process only complex samples,
false if the real samples are also allowed.ArrayContext.updateProgress(Event) method.ArrayContext.Event.elementType(), ArrayContext.Event.length(),
ArrayContext.Event.readyCount() for the case of 1 parallel task.ArrayContext.Event.elementType(), ArrayContext.Event.lengthPerTask()
and ArrayContext.Event.readyCountPerTask().AlgART arrays,
about the preferred memory model.unresizable AlgART arrays
(usually work buffers) with the same size and type of elements,
based on a list of SoftReference.AlgART arrays.Arrays.compareAndCopy(ArrayContext, UpdatableArray, Array) and
Matrices.compareAndCopy(ArrayContext, Matrix, Matrix) methods.Arrays.ParallelExecutor performing
simple copying of the source array.Arrays.copy(ArrayContext, UpdatableArray, Array),
Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean),
Arrays.compareAndCopy(ArrayContext, UpdatableArray, Array),
Matrices.copy(ArrayContext, Matrix, Matrix), etc.Arrays.copy(ArrayContext, UpdatableArray, Array),
Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean),
Matrices.copy(ArrayContext, Matrix, Matrix), etc.Arrays.rangeOf(PArray, MinMaxInfo) method, containing information
about the minimum and maximum in some AlgART array.uninitialized instance of this class.Array.subArray).AlgART arrays.Arrays.addShutdownTask(Runnable, TaskExecutionOrder) method.equal dimensions and, it it is true,
creates and returns Java array of built-in AlgART arrays of all passed matrices.AlgART arrays,
about the preferred thread pool factory.UnsupportedContextException if this context cannot serve this request.as(contextClass)
in other case.immutable AlgART array with specified element type,
backed by the content of a region of the data file with specified name.asArray(filePath, boolean.class, filePosition, fileAreaSize, byteOrder).asArray(filePath, byte.class, filePosition, fileAreaSize, byteOrder).asArray(filePath, char.class, filePosition, fileAreaSize, byteOrder).asImmutable(),
(storage[1].asImmutable(), ...,
(storage[storage.length-1].asImmutable(),
with the current combiner (specified while creating this memory model).asConcatenation(null, arrays).asCoordFuncMatrix(resultMemoryModel, true, f, requiredType, dim).Matrices.asFuncMatrix(MemoryModel, boolean, Func, Class, List) method,
where the passed function is applied not to the elements of some source matrices,
but to the indexes of the resulting matrix.AbstractBitArray.updatableClone() method and returns its result.AbstractByteArray.updatableClone() method and returns its result.AbstractCharArray.updatableClone() method and returns its result.AbstractDoubleArray.updatableClone() method and returns its result.AbstractFloatArray.updatableClone() method and returns its result.AbstractIntArray.updatableClone() method and returns its result.AbstractLongArray.updatableClone() method and returns its result.AbstractObjectArray.updatableClone() method and returns its result.AbstractShortArray.updatableClone() method and returns its result.AbstractMorphology.asDilation(Matrix src, Pattern pattern)
if isDilation argument is true or to
AbstractMorphology.asErosion(Matrix src, Pattern pattern)
if isDilation argument is false.asArray(filePath, double.class, filePosition, fileAreaSize, byteOrder).asArray(filePath, float.class, filePosition, fileAreaSize, byteOrder).asFuncArray(null, true, f, requiredType, x).asFuncArray(resultMemoryModel, true, f, requiredType, x).get(x[0].getDouble(k), x[1].getDouble(k), ...),
that is the result of the passed function for arguments equal to the corresponding elements #k
in all passed arrays.asFuncMatrix(resultMemoryModel, f, requiredType, several(PArray.class, x)).asFuncMatrix(resultMemoryModel, truncateOverflows, f, requiredType, several(PArray.class, x)).asFuncMatrix(resultMemoryModel, f, requiredType, several(PArray.class, x1, x2)).asFuncMatrix(resultMemoryModel, truncateOverflows, f, requiredType, several(PArray.class, x1, x2)).asFuncMatrix(resultMemoryModel, f, requiredType, several(PArray.class, x1, x2, x3)).asFuncMatrix(resultMemoryModel, truncateOverflows, f, requiredType, several(PArray.class, x1, x2, x3)).asFuncMatrix(resultMemoryModel, true, f, requiredType, x).Arrays.asFuncArray(MemoryModel, boolean, Func, Class, PArray...) method
for AlgART matrices.AbstractBitArray,
where the following method are overridden and call the same methods of this instance:
AbstractBitArray.getBit(long), AbstractBitArray.getData(long, Object, int, int),
AbstractBitArray.getData(long, Object),
AbstractBitArray.loadResources(ArrayContext, long, long),
AbstractBitArray.flushResources(ArrayContext, long, long, boolean) and
AbstractBitArray.freeResources(ArrayContext, long, long).AbstractByteArray,
where the following method are overridden and call the same methods of this instance:
AbstractByteArray.getByte(long), AbstractByteArray.getData(long, Object, int, int),
AbstractByteArray.getData(long, Object),
AbstractByteArray.loadResources(ArrayContext, long, long),
AbstractByteArray.flushResources(ArrayContext, long, long, boolean) and
AbstractByteArray.freeResources(ArrayContext, long, long).AbstractCharArray,
where the following method are overridden and call the same methods of this instance:
AbstractCharArray.getChar(long), AbstractCharArray.getData(long, Object, int, int),
AbstractCharArray.getData(long, Object),
AbstractCharArray.loadResources(ArrayContext, long, long),
AbstractCharArray.flushResources(ArrayContext, long, long, boolean) and
AbstractCharArray.freeResources(ArrayContext, long, long).AbstractDoubleArray,
where the following method are overridden and call the same methods of this instance:
AbstractDoubleArray.getDouble(long), AbstractDoubleArray.getData(long, Object, int, int),
AbstractDoubleArray.getData(long, Object),
AbstractDoubleArray.loadResources(ArrayContext, long, long),
AbstractDoubleArray.flushResources(ArrayContext, long, long, boolean) and
AbstractDoubleArray.freeResources(ArrayContext, long, long).AbstractFloatArray,
where the following method are overridden and call the same methods of this instance:
AbstractFloatArray.getFloat(long), AbstractFloatArray.getData(long, Object, int, int),
AbstractFloatArray.getData(long, Object),
AbstractFloatArray.loadResources(ArrayContext, long, long),
AbstractFloatArray.flushResources(ArrayContext, long, long, boolean) and
AbstractFloatArray.freeResources(ArrayContext, long, long).AbstractIntArray,
where the following method are overridden and call the same methods of this instance:
AbstractIntArray.getInt(long), AbstractIntArray.getData(long, Object, int, int),
AbstractIntArray.getData(long, Object),
AbstractIntArray.loadResources(ArrayContext, long, long),
AbstractIntArray.flushResources(ArrayContext, long, long, boolean) and
AbstractIntArray.freeResources(ArrayContext, long, long).AbstractLongArray,
where the following method are overridden and call the same methods of this instance:
AbstractLongArray.getLong(long), AbstractLongArray.getData(long, Object, int, int),
AbstractLongArray.getData(long, Object),
AbstractLongArray.loadResources(ArrayContext, long, long),
AbstractLongArray.flushResources(ArrayContext, long, long, boolean) and
AbstractLongArray.freeResources(ArrayContext, long, long).AbstractObjectArray,
where the following method are overridden and call the same methods of this instance:
AbstractObjectArray.get(long), AbstractObjectArray.getData(long, Object, int, int),
AbstractObjectArray.getData(long, Object),
AbstractObjectArray.loadResources(ArrayContext, long, long),
AbstractObjectArray.flushResources(ArrayContext, long, long, boolean) and
AbstractObjectArray.freeResources(ArrayContext, long, long).AbstractShortArray,
where the following method are overridden and call the same methods of this instance:
AbstractShortArray.getShort(long), AbstractShortArray.getData(long, Object, int, int),
AbstractShortArray.getData(long, Object),
AbstractShortArray.loadResources(ArrayContext, long, long),
AbstractShortArray.flushResources(ArrayContext, long, long, boolean) and
AbstractShortArray.freeResources(ArrayContext, long, long).asIndexFuncArray(null, true, f, requiredType, length).asFuncArray(resultMemoryModel, true, f, requiredType, length).Arrays.asFuncArray(MemoryModel, boolean, Func, Class, PArray...) method,
where the passed function is applied not to the elements of some source array,
but to the index of the resulting array.asArray(filePath, int.class, filePosition, fileAreaSize, byteOrder).Matrices.asInterpolationFunc(Matrix, InterpolationMethod, boolean) method,
that use constant continuation for all coordinates outside the matrix.asList(array, array.elementType()}.asArray(filePath, long.class, filePosition, fileAreaSize, byteOrder).asShifted(null, array, shift).asArray(filePath, short.class, filePosition, fileAreaSize, byteOrder).result() matrix thinned along the given direction.result() matrix thinned along the given direction.result() matrix thinned along the given direction.AbstractBitArray.asImmutable() and returns its result.AbstractByteArray.asImmutable() and returns its result.AbstractCharArray.asImmutable() and returns its result.AbstractDoubleArray.asImmutable() and returns its result.AbstractFloatArray.asImmutable() and returns its result.AbstractIntArray.asImmutable() and returns its result.AbstractLongArray.asImmutable() and returns its result.AbstractObjectArray.asImmutable() and returns its result.AbstractShortArray.asImmutable() and returns its result.unresizable AlgART array with specified element type,
backed by the content of a region of the data file with specified name.asUpdatableArray(filePath, boolean.class, filePosition, fileAreaSize, byteOrder).asUpdatableArray(byteBuffer, byte.class).asUpdatableArray(filePath, byte.class, filePosition, fileAreaSize, byteOrder).asUpdatableArray((Object)array).asUpdatableArray(byteBuffer, char.class).asUpdatableArray(filePath, char.class, filePosition, fileAreaSize, byteOrder).asUpdatableArray((Object)array).asUnresizable().shallowClone(),
(storage[1].asUnresizable().shallowClone(), ...,
(storage[storage.length-1].asUnresizable().shallowClone(),
with the current combiner (specified while creating this memory model).asUpdatableArray(byteBuffer, double.class).asUpdatableArray(filePath, double.class, filePosition, fileAreaSize, byteOrder).asUpdatableArray((Object)array).asUpdatableArray(byteBuffer, float.class).asUpdatableArray(filePath, float.class, filePosition, fileAreaSize, byteOrder).asUpdatableArray((Object)array).asUpdatableFuncArray(null, true, f, requiredType, x).Arrays.asFuncArray(MemoryModel, boolean, Func, Class, PArray...) method
allowing to create updatable view of the source array.asUpdatableFuncMatrix(resultMemoryModel, true, f, requiredType, x).Arrays.asUpdatableFuncArray
method for AlgART matrices.asUpdatableArray(byteBuffer, int.class).asUpdatableArray(filePath, int.class, filePosition, fileAreaSize, byteOrder).asUpdatableArray((Object)array).asUpdatableArray(byteBuffer, long.class).asUpdatableArray(filePath, long.class, filePosition, fileAreaSize, byteOrder).asUpdatableArray((Object)array).asUpdatableArray((Object)array)asUpdatableArray(byteBuffer, short.class).asUpdatableArray(filePath, short.class, filePosition, fileAreaSize, byteOrder).asUpdatableArray((Object)array).map(position, size) call
automatically increases the file length to position+size
if the current file length is less than this value.DefaultDataFileModel class,
or false if there is no such system property or some exception occured while
calling Boolean.getBoolean.Arrays.SystemSettings.maxTempJavaMemoryForTiling() and 80% of the amount of memory, that can be
probably allocated in Java heap without the risk of OutOfMemoryError.Matrices.ResizingMethod.Averaging class,
in particular, for Matrices.ResizingMethod.AVERAGING and Matrices.ResizingMethod.POLYLINEAR_AVERAGING cases,
false for other cases.comments to this class).dilation
and erosion of the source matrix with the same pattern.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean)
method in "non-strict" mode in a case of affine coordinate transformation.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean)
method in "non-strict" mode.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean)
method in "non-strict" mode in a case of projective coordinate transformation.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean)
method in "non-strict" mode in a case of resizing coordinate transformation.Arrays.ParallelExecutor.processSubArr(long, int, int) method.AbstractPattern.points() method.integer points A of this pattern,
that the neighbour point B,
generated by the backward or forwards shift of point A on 1 along at least one coordinate
does not belong to this pattern.Boundary2DScanner.SimpleMeasurer class.Boundary2DScanner class, that redirects all methods to some
parent scanner and, maybe, performs some additional actions.Boundary2DScanner.x(), Boundary2DScanner.y(), Boundary2DScanner.side())
is identical to the position, set by last call of Boundary2DScanner.nextBoundary() or
Boundary2DScanner.go(long, long, Boundary2DScanner.Side) method.buffer(mode, someCapacity), where mode is the argument of this method
and someCapacity is the result of defaultBufferCapacity(thisArray) method.buffer(suitableMode, capacity), where capacity is the argument of this method
and suitableMode is
this instanceof UpdatableArray ?
DataBuffer.AccessMode.READ_WRITE :
DataBuffer.AccessMode.READ.buffer(suitableMode), where suitableMode is
this instanceof UpdatableArray ?
DataBuffer.AccessMode.READ_WRITE :
DataBuffer.AccessMode.READ.data buffer allowing block access to this array
with the specified access mode and buffer capacity.buffer(mode, someCapacity), where mode is the argument of this method
and someCapacity is chosen automatically to provide good performance in typical situations.buffer(suitableMode, capacity), where capacity is the argument of this method
and suitableMode is chosen automatically.buffer(suitableMode, someCapacity), where both suitableMode and someCapacity
arguments are chosen automatically.DataFile.map(Range, boolean)
method.AbstractDataFileModel.createTemporary(boolean) method
in this class.AbstractArray.capacity & Long.MAX_VALUE.getDataFileModel().pathClass()
cannot be cast to the passed type pathClass.element type is not its subclass).Array.equals(Object) method.AbstractPattern.dimCount().UpdatableArray.copy(Array) and throws corresponding exception if no.equal dimensions and, it is not so, throws a corresponding exception.equal dimensions and, it is not so, throws a corresponding exception.Arrays.ParallelExecutor.process().as(InterruptionContext.class).checkInterruption(), where context is the argument of the construcor.InterruptionException in this case.ArrayContext.checkInterruption()updateProgress(new ArrayContext.Event(elementType, readyCount, length))UnsafeSegment2D).coordinate range.AbstractArray.subArr(long, long)
and throws corresponding exception if no.AbstractArray.subArray(long, long)
and throws corresponding exception if no.UpdatableArray.swap(UpdatableArray) and throws corresponding exception if no.trusted immutable array took place,
and throw UnallowedMutationError in this case.visit method for each element
and clears this element (UpdatableBitArray.clearBit(long)).clear(context, elementVisitor, coordinates, true).clear(context, null, coordinates, forceClearing).clear(context, null, coordinates, true).version
of the serialization format.DataBuffer.count(), if DataBuffer.count()<=Integer.MAX_VALUE,
or throws UnsupportedOperationException in other case.CombinedMemoryModel.Combiner interface.CombinedMemoryModel.AbstractByteBufferCombiner skeleton class
implementing CombinedMemoryModel.CombinerInPlace interface.CombinedMemoryModel.Combiner interface allowing
to optimize block access to the combined array.combined memory model.CombinedMemoryModel.Combiner interface allowing
to load an element without creating new Java object.Arrays.copy(ArrayContext, UpdatableArray, Array)
allowing to know, whether the destination array was really modified while copying.Arrays.compareAndCopy(context, dest.array(), src.array()),
if the passed matrices have the same dimensions,
or throws SizeMismatchException in other case.IPoint.compareTo(IPoint) method,
but with the cyclical shift of all indexes of coordinates:
the coordinate #firstCoordIndex instead of x,
#firstCoordIndex+1 instead of y, etc.Point.compareTo(Point) method,
but with the cyclical shift of all indexes of coordinates:
the coordinate #firstCoordIndex instead of x,
#firstCoordIndex+1 instead of y, etc.UpdatablePNumberArray.UpdatablePNumberArray.Convolution object to another instance of that interface,
which uses constantly continuation.IRange.min()<=value<=IRange.max().IRange.min()<=range.IRange.min()
and range.IRange.max()<=IRange.max().min(k)<=point.coord(k)<=max(k)
for all k.min(k)<=area.min(k)
and area.max(k)<=max(k)
for all k.Range.min()<=value<=Range.max()Range.min()<=range.Range.min()
and range.Range.max()<=Range.max().min(k)<=point.coord(k)<=max(k)
for all k.min(k)<=area.min(k)
and area.max(k)<=max(k)
for all k.AbstractConvolution.context() field.AbstractArrayProcessorWithContextSwitching.context() == null ? null :
AbstractArrayProcessorWithContextSwitching.context().part(fromPart, toPart))AbstractConvolution.asConvolution(Matrix, WeightedPattern) method
and copies it into newly created matrix via Matrices.copy(ArrayContext, Matrix, Matrix) method.Boundary2DScanner.next() method has changed Boundary2DScanner.x() or Boundary2DScanner.y()
coordinate.coordinate transformation operator
in n-dimensional Euclidean space.AbstractPattern.coordRange(int) method
for all coordinate indexes from 0 to AbstractPattern.dimCount()-1.IPoint.coord(coordIndex)
of all points of this pattern.AbstractPattern.coordRange(int) method
for all coordinate indexes from 0 to AbstractPattern.dimCount()-1.IPoint.coord(coordIndex)
of all points of this pattern.AbstractPattern.points() method.IPoint.coord(coordIndex)
of all points of this pattern.AbstractPattern.coordRange(int) method
for all coordinate indexes from 0 to AbstractPattern.dimCount()-1.IPoint.coord(coordIndex)
of all points of this pattern for every coordinate index.AbstractUpdatableBitArray.copy(long, long) method.defaultCopy(thisInstance, src).AbstractUpdatableByteArray.copy(long, long) method.defaultCopy(thisInstance, src).AbstractUpdatableCharArray.copy(long, long) method.defaultCopy(thisInstance, src).AbstractUpdatableDoubleArray.copy(long, long) method.defaultCopy(thisInstance, src).AbstractUpdatableFloatArray.copy(long, long) method.defaultCopy(thisInstance, src).AbstractUpdatableIntArray.copy(long, long) method.defaultCopy(thisInstance, src).AbstractUpdatableLongArray.copy(long, long) method.defaultCopy(thisInstance, src).AbstractUpdatableObjectArray.copy(long, long) method.defaultCopy(thisInstance, src).AbstractUpdatableShortArray.copy(long, long) method.defaultCopy(thisInstance, src).length(), src.length()) elements
of src array, starting from index 0, to dest array, starting from index 0.Arrays.copy(ArrayContext, UpdatableArray, Array),
allowing to specify the number of parallel tasks.Arrays.copy(ArrayContext, UpdatableArray, Array) and
Arrays.copy(ArrayContext, UpdatableArray, Array, int)
providing a special "non-strict" copying mode.Arrays.copy(context, dest.array(), src.array()),
if the passed matrices have the same dimensions,
or throws SizeMismatchException in other case.Arrays.copy(context, dest.array(), src.array(),
numberOfTasks),
if the passed matrices have the same dimensions,
or throws SizeMismatchException in other case.Arrays.copy(context, dest.array(), src.array(),
numberOfTasks, strictMode),
if the passed matrices have the same dimensions,
or throws SizeMismatchException in other case.length(), src.length()) elements of
src array, starting from index 0,
to this array, starting from index 0.copyOfRange(array, fromIndex, toIndex).copyOfRange(array, fromIndex, toIndex).copyOfRange(array, fromIndex, toIndex).copyOfRange(array, fromIndex, toIndex).copyOfRange(array, fromIndex, toIndex).copyOfRange(array, fromIndex, toIndex).copyOfRange(array, fromIndex, toIndex).copyOfRange(array, fromIndex, toIndex).Matrices.copyRegion(ArrayContext, Matrix, Matrix, Region, long...) method,
allowing to copy regions which do not lie fully inside dest and src matrices.Arrays.SystemSettings.cpuCountProperty() method.Arrays.SystemSettings.cpuCountProperty() method, if it is a positive number,
or Runtime.getRuntime().availableProcessors(), if it is zero.Arrays.SystemSettings.CPU_COUNT_PROPERTY_NAME
system property ("net.algart.arrays.CPUCount"); the result 0 means
a recommendation to use Runtime.getRuntime().availableProcessors().AbstractDataFileModel.createTemporaryFile(boolean)
protected method and returns a result of getDataFile(pathToTemporaryFile, ByteOrder.nativeOrder()).DataFile
object corresponding to it.IRange.min()?IRange.min():value>IRange.max()?IRange.max():value.Range.min()?Range.min():value>Range.max()?Range.max():value.Matrix.index(long...) method, that does not check,
whether the passed coordinates are in the required ranges,
and also replaces the resulting shift by the positive remainder
from division of it by the length of the built-in array.Boundary2DScanner.Step.dx(), Boundary2DScanner.Step.dy()).data buffers.DataFile.map(net.algart.arrays.DataFile.Range, boolean) method.DataFile.open(boolean) method.data file.data files").MatrixInfo.valueOf(Matrix, long) or MatrixInfo.valueOf(Matrix, long, String)
method or loaded from the serialized form by MatrixInfo.valueOf(byte[]) or MatrixInfo.valueOf(String) method.ArrayContext, that does almost nothing.MutableArray.append(Array),
based on MutableArray.length(long), UpdatableArray.subArr(long, long)
and UpdatableArray.copy(Array)
methods.ArrayContext interface,
based on the memory,
thread pool,
interruption and
progress contexts defined in this package.DefaultArrayContext.getThreadPoolFactory() method.AbstractArray.buffer(net.algart.arrays.DataBuffer.AccessMode, long) method.AbstractArray.buffer(net.algart.arrays.DataBuffer.AccessMode)
and AbstractArray.buffer() methods.InterruptionContext, ArrayMemoryContext, ArrayThreadPoolContext,
ProgressUpdater, StatusUpdater.DefaultContext.getMemoryModel() method.defaultCopy(thisArray, src, false).UpdatableArray.copy(Array)
based on Array.getData(long, Object) and UpdatableArray.setData(long, Object)
methods (for some temporary array).DataFileModel that creates usual Java files,
which are mapped via standard Java technique (FileChannel.map method).DefaultDataFileModel(null, 0).DefaultDataFileModel(null, 0, lazyWriting).DefaultDataFileModel(tempPath, 0).DefaultDataFileModel(tempPath, 0, lazyWriting).lazy-writing mode, used when this this class
is instantiated by a constructor without lazyWriting argument.UpdatableArray.swap(UpdatableArray)
based on Array.getData(long, Object) and UpdatableArray.setData(long, Object)
methods (for some temporary array).ThreadPoolFactory interface.Matrices.Simplex
cannot be constructed because all vertices lies on the same hyperplane.getPath(dataFile).delete()
(if java.io.File.exists() method returns true).Morphology.dilation(Matrix, Pattern) method, but the result matrix
will be placed in the dest argument.dilation(dest, src, pattern, false).dilation(src, dilationPattern) and
erosion(src, erosionPattern)
of the source matrix by the specified patterns.AbstractMorphology.dilation(Matrix dest, Matrix src, Pattern pattern, boolean disableMemoryAllocation)
if isDilation argument is true or to
AbstractMorphology.erosion(Matrix dest, Matrix src, Pattern pattern, boolean disableMemoryAllocation)
if isDilation argument is false.Matrix.dimCount().AbstractPattern.dimCount field.dim(0).dim(1).dim(2).transform(context,samples,false)transformMatrix(context,matrixRe,matrixIm,false)DataFile.BufferHolder.unmap() method and returns true,
or performs some reduced form of unmapping (or even does nothing) and returns false.InterruptableAction.run() method and returns its result.Arrays.ParallelExecutor.process().Matrix.array().elementType().Arrays.ParallelExecutor.processRange(long, long, int, long)
method at the end of each processed block.Array.equals(Object) method.coordinate transformation operator, performing the same coordinate transformation as this one.Direction2D.getAngle() is the same for both directions.Rotation2D.getRotationAngle() is the same for both rotations.UnsafeSegment2D.setEqualityPrecision(double) call (or with absolute precision if that method was never called).Frame,
containg the matrix and position, equal to the matrix and position
in this frame.FramePosition,
specifying the same position as this one.Morphology.erosion(Matrix, Pattern) method, but the result matrix
will be placed in the dest argument.erosion(dest, src, pattern, false).erosion(src, erosionPattern) and
dilation(src, dilationPattern)
of the source matrix by the specified patterns.min(),value) <= x
<= Math.max(this.max(),value)min(),value) <= x
<= StrictMath.max(this.max(),value)dilation
with the same pattern and the source matrix.comments to this class.comments to this class.comments to this class, if normalizeDirectTransform argument is
false, or to the formula 2, if this argument is true.comments to this class, if normalizeDirectTransform argument is
false, or to the formula 2, if this argument is true.fill(0, thisArray.length(), value).fill(position, count, (boolean)value).fill(0, thisArray.length(), value).fill(position, count, (boolean)value).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nBitCopies(count, value)).fill(0, thisArray.length(), value).fill(position, count, (byte)value).fill(0, thisArray.length(), value).fill(position, count, (byte)value).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nByteCopies(count, value)).fill(0, thisArray.length(), value).fill(position, count, (char)value).fill(0, thisArray.length(), value).fill(position, count, (char)value).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nCharCopies(count, value)).fill(0, thisArray.length(), value).fill(position, count, (double)value).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nDoubleCopies(count, value)).fill(0, thisArray.length(), value).fill(position, count, (float)value).fill(0, thisArray.length(), value).fill(position, count, (float)value).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nFloatCopies(count, value)).fill(0, thisArray.length(), value).fill(position, count, (int)value).fill(0, thisArray.length(), value).fill(position, count, (int)value).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nIntCopies(count, value)).fill(0, thisArray.length(), value).fill(position, count, (long)value).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nLongCopies(count, value)).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nObjectCopies(count, value)).fill(0, thisArray.length(), value).fill(position, count, (short)value).fill(0, thisArray.length(), value).fill(position, count, (short)value).fill(0, thisArray.length(), value).subArr(position, count).copy(Arrays.nShortCopies(count, value)).Arrays.ParallelExecutor.process() method.flushResources(context, false).constructor.flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)flushResources(context, 0, length(), forcePhysicalWriting).subArray(fromIndex, toIndex).flushResources(context, forcePhysicalWriting)Array.flushResources(ArrayContext), allowing to force
immediate writing data to the external storage device.Matrix.array().flushResources(context).DataBuffer.data() Java array
(from DataBuffer.fromIndex(), inclusive, to DataBuffer.toIndex(), exclusive)
back to the underlying data storage (usually AlgART array).DataBuffer.data() Java array
(from the passed fromIndex, inclusive, to the passed toIndex, exclusive)
back to the underlying data storage (usually AlgART array).AlgART matrix and its position;
in other words, an n-dimensional matrix, placed by some way in n-dimensional space.constructor.freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)freeResources(context, 0, length()).subArray(fromIndex, toIndex).freeResources(context)Matrix.array().freeResources(context).Array.freeResources(context) /
Matrix.freeResources(context) methods for them.DataBuffer.fromIndex(), if DataBuffer.fromIndex()<=Integer.MAX_VALUE,
or throws UnsupportedOperationException in other case.Func interface
allowing assigning values to the function result, that leads to
corresponding correction of arguments.BitArray)
to operation over any primitive type (an algorithm processing PArray).GeneralizedBitProcessing class.getElement(index).get(EMPTY),
where EMPTY is a constant array double[0].get(new double[] {x0}).get(new double[] {x0, x1}).get(new double[] {x0, x1, x2}).get(new double[] {x0, x1, x2, x3}).get(new double[0]).get(new double[] {x0}).get(new double[] {x0, x1}).get(new double[] {x0, x1, x2}).get(new double[] {x0, x1, x2, x3}).get(coordinates,
new double[] {v0}).get(coordinates,
new double[] {v0,v1}).get(coordinates,
new double[] {v0,v1,v2}).get(coordinates,
new double[] {v0,v1,v2,v3}).get(coordinates,
new double[] {v0,v1,v2,v3,v4}).get(coordinates,
new double[] {v0,v1,v2,v3,v4,v5}).get(coordinates,
new double[] {v0,v1,v2,v3,v4,v5,v6}).get(coordinates,
new double[] {v0,v1,v2,v3,v4,v5,v6,v7}).get(new double[] {x0}, values).get(new double[] {x0},
new double[] {v0}).get(new double[] {x0},
new double[] {v0,v1}).get(new double[] {x0},
new double[] {v0,v1,v2}).get(new double[] {x0},
new double[] {v0,v1,v2,v3}).get(new double[] {x0},
new double[] {v0,v1,v2,v3,v4}).get(new double[] {x0},
new double[] {v0,v1,v2,v3,v4,v5}).get(new double[] {x0},
new double[] {v0,v1,v2,v3,v4,v5,v6}).get(new double[] {x0},
new double[] {v0,v1,v2,v3,v4,v5,v6,v7}).get(new double[] {x0,x1}, values).get(new double[] {x0,x1},
new double[] {v0}).get(new double[] {x0,x1},
new double[] {v0,v1}).get(new double[] {x0,x1},
new double[] {v0,v1,v2}).get(new double[] {x0,x1},
new double[] {v0,v1,v2,v3}).get(new double[] {x0,x1},
new double[] {v0,v1,v2,v3,v4}).get(new double[] {x0,x1},
new double[] {v0,v1,v2,v3,v4,v5}).get(new double[] {x0,x1},
new double[] {v0,v1,v2,v3,v4,v5,v6}).get(new double[] {x0,x1},
new double[] {v0,v1,v2,v3,v4,v5,v6,v7}).get(new double[] {x0,x1,x2}, values).get(new double[] {x0,x1,x2},
new double[] {v0}).get(new double[] {x0,x1,x2},
new double[] {v0,v1}).get(new double[] {x0,x1,x2},
new double[] {v0,v1,v2}).get(new double[] {x0,x1,x2},
new double[] {v0,v1,v2,v3}).get(new double[] {x0,x1,x2},
new double[] {v0,v1,v2,v3,v4}).get(new double[] {x0,x1,x2},
new double[] {v0,v1,v2,v3,v4,v5}).get(new double[] {x0,x1,x2},
new double[] {v0,v1,v2,v3,v4,v5,v6}).get(new double[] {x0,x1,x2},
new double[] {v0,v1,v2,v3,v4,v5,v6,v7}).getInstance(averagingFunc, apertureDim, apertureFrom, apertureSteps),
where averagingFunc is the averaging linear function
LinearFunc.getAveragingInstance(m),
m = apertureDim[0]*apertureDim[1]*....getInstance(averagingFunc, apertureDim),
where averagingFunc is the averaging linear function
LinearFunc.getAveragingInstance(m),
m = apertureDim[0]*apertureDim[1]*....getNonweightedInstance(0.0, 1.0/n, n):
the average from n numbers.AbstractBitArray.getBit(long) method.BufferMemoryModel.getByteBuffer(Array) call,
corresponding to the first element of the passed AlgART array.getMorphology method.getRankMorphology method.convex hyperpolyhedron,
which is an intersection of m AbstractBitArray.getBit(long) method.AbstractBitArray.getData(long, Object, int, int)
with corresponding arguments.AbstractByteArray.getByte(long) method.AbstractByteArray.getData(long, Object, int, int)
with corresponding arguments.AbstractCharArray.getChar(long) method.AbstractCharArray.getData(long, Object, int, int)
with corresponding arguments.AbstractDoubleArray.getDouble(long) method.AbstractDoubleArray.getData(long, Object, int, int)
with corresponding arguments.AbstractFloatArray.getFloat(long) method.AbstractFloatArray.getData(long, Object, int, int)
with corresponding arguments.AbstractIntArray.getInt(long) method.AbstractIntArray.getData(long, Object, int, int)
with corresponding arguments.AbstractLongArray.getLong(long) method.AbstractLongArray.getData(long, Object, int, int)
with corresponding arguments.AbstractObjectArray.get(long) method.AbstractObjectArray.getData(long, Object, int, int)
with corresponding arguments.AbstractShortArray.getShort(long) method.AbstractShortArray.getData(long, Object, int, int)
with corresponding arguments.length() - arrayPos, destArray.length})
elements of this array, starting from arrayPos index,
into the specified Java array of corresponding type, starting from 0 index.DataFile object corresponding to the given path.DataFile.map
method based on standard Java mapping.DataFile.map
method that use usual read/write operation instead of Java mapping.model of the data file
storing all elements of the passed AlgART array.path to the data file
storing all elements of the passed AlgART array.getDiagonalInstance(diagonal, new double[diagonal.length])
(the case of zero b vector).IntegerCirclePointsGenerator.getCirclePoints(int) method, but returned points
are shifted by delta pixels from (0,0).functional array,
or throws an exception if this array is not functional.IterativeOpening.sumsOfOpenings() method.hyperparallelepiped with edges,
parallel to coordinate axes, described by the given ranges of coordinates.index-based functional array,
or throws an exception if this array is a functional array,
calculated on the base of indexes only.DefaultContext(){}" call.getInstance(apertureFunc, apertureDim, apertureFrom, apertureSteps),
where averagingFrom and apertureSteps are chosen automatically
to get an aperture 1.0x1.0x... starting from the origin of coordinates
(0<=aij<1).min(),
range.max(),
in, out.Convolution object
and the specified outside value.IterativeOpening.result() method.is an interpolation view of some AlgART matrix,
returns the interpolation algorithm, used while creating thie function.memory model that should be used
for creating any instances of AlgART arrays.memory model that should be used
for creating any instances of AlgART arrays.memory model that should be used
for creating any instances of AlgART arrays
with specified type of elements.as(ArrayMemoryContext.class).getMemoryModel() call, where context is the argument of the construcor.corresponding constructor,
or Arrays.SystemSettings.globalMemoryModel()
if the constructor without arguments was used.isElementTypeSupported(elementType) ? mm : SimpleMemoryModel.getInstance(),
where mm is the result of DefaultContext.getMemoryModel() method.getInstance(context, Arrays.SystemSettings.maxTempJavaMemory()).Morphology interface.is a continued interpolation
view of an AlgART matrix, return the value used outside the matrix.Morphologies.getConstantlyContinuedMorphology(Morphology, double) or
Morphologies.getConstantlyContinuedMorphology(RankMorphology, double) method,
or throws an exception if this object is not created by those methods.2-dimensional polygon with the specified coordinates of vertices.shited array,
or throws an exception if this array is not shifted.getDiagonalInstance(diagonal, b),
where diagonal is an array consisting of b.length unit values (1.0).Boundary2DScanner.SimpleMeasurer class,
that is based on the specified parent scanner and,
while scanning any boundary by the parent scanner,
measure the specified set of boundary parameters.simplex with the specified coordinates of vertices.Array.shallowClone()
of arrays used as internal storage,
where the elements of the combined array are stored.CombinedMemoryModel.getStorage(Array) method.CombinedMemoryModel.getStorage(Array) method.persistent thread pool,
if it exists, or creates new thread pool by the following call:
Executors.newFixedThreadPool(DefaultThreadPoolFactory.recommendedNumberOfTasks(),
threadFactory==null ? Executors.defaultThreadFactory() : threadFactory).persistent thread pool,
if it exists, or creates new thread pool by the following call:
Executors.newFixedThreadPool(recommendedNumberOfTasks(sourceArray),
threadFactory==null ? Executors.defaultThreadFactory() : threadFactory).thread pool factory that should be used for
planning parallel execution in multithread methods alike
Arrays.ParallelExecutor.process().thread pool factory that should be used
for multithreading parallel processing AlgArt arrays.as(ArrayThreadPoolContext.class).getThreadPoolFactory() call, where context is the argument of the construcor,
or threadPoolFactory constructor argument,
if this instance was created with
the corresponding variant of the constructor.DefaultThreadPoolFactory.Arrays.asFuncArray(MemoryModel, boolean, Func, Class, PArray...) method
(or one of its overloaded versions),
used for creating the passed functional array,
or throws an exception if this array is not functional.ConnectedObjectScanner.getBreadthFirstScanner(net.algart.arrays.Matrix, net.algart.matrices.bitscanning.ConnectivityType) method, returning the instance, which works correctly
only if all matrix elements with zero and maximal coordinates are zero.ConnectedObjectScanner.getDepthFirstScanner(net.algart.arrays.Matrix, net.algart.matrices.bitscanning.ConnectivityType) method, returning the instance, which works correctly
only if all matrix elements with zero and maximal coordinates are zero.ConnectedObjectScanner.getStacklessDepthFirstScanner(net.algart.arrays.Matrix, net.algart.matrices.bitscanning.ConnectivityType) method, returning the instance, which works correctly
only if all matrix elements with zero and maximal coordinates are zero.isFresh() values,
for all underlying arrays of the passed one.is an interpolation view of an AlgART matrix,
returns the reference to this matrix.disk synchronizer
that is recommended to use in the application for any disk I/O operations.memory model that is recommended to use
in the application for creating large AlgART arrays.global memory model, if it
supports the passed type
of array elements, or SimpleMemoryModel instance in other case.DefaultThreadPoolFactory.getThreadPool(Array, ThreadFactory) method
if the constructor without arguments
or the constructor with 1 argument was used.getBits(position, destArray, offset, someCount)
and (for updatable array)
setBits(position, srcArray, offset, someCount)
work essentially faster than for most of other ("slow") positions,
or 0 if there is no such offset,
in particular, if position>=length().Arrays.ParallelExecutor.granularity().SampleArray.newCompatibleSamplesArray(long) method in any case, if there is enough memory.LinearFunc class, describing the linear function
(x0 - x1)/2:
LinearFunc.getInstance(0.0, 0.5, -0.5).LinearFunc class, describing the linear function
(x0 + x1)/2:
LinearFunc.getInstance(0.0, 0.5, 0.5).LinearFunc class, describing the linear function
(x1 - x0)/2:
LinearFunc.getInstance(0.0, -0.5, 0.5).DataBuffer.count()>0.Array.hashCode() method.DirectAccessible.javaArray() method.minkowskiDecomposition(0).size()>1.minkowskiDecomposition(0) method,
consists of 2 or more patterns:
minkowskiDecomposition(0).size()>1.histogramOf(null, array, histogram, from, to).MatrixInfo is invalid.index method for the case
of 2-dimensional matrix.index method for the case
of 3-dimensional matrix.underlying array of the currently
scanned matrix.indexOf(lowIndex, highIndex, value != 0) : -1.indexOf(lowIndex, highIndex, value != 0) : -1.AbstractBitArray.getBit(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.indexOf(lowIndex, highIndex, (byte)value) : -1.indexOf(lowIndex, highIndex, (byte)value) : -1.AbstractByteArray.getByte(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.indexOf(lowIndex, highIndex, (char)value) : -1.indexOf(lowIndex, highIndex, (char)value) : -1.AbstractCharArray.getChar(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.AbstractDoubleArray.getDouble(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.indexOf(lowIndex, highIndex, (float)value) : -1.AbstractFloatArray.getFloat(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.indexOf(lowIndex, highIndex, (int)value) : -1.indexOf(lowIndex, highIndex, (int)value) : -1.AbstractIntArray.getInt(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.indexOf(lowIndex, highIndex, (long)value) : -1.AbstractLongArray.getLong(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.AbstractObjectArray.get(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.indexOf(lowIndex, highIndex, (short)value) : -1.indexOf(lowIndex, highIndex, (short)value) : -1.AbstractShortArray.getShort(long) method
from index max(lowIndex,0) until index min(AbstractArray.length(),highIndex)-1.length())
and getBit(k)==value,
or -1 if there is no such array element.length())
and getByte(k)==value,
or -1 if there is no such array element.length())
and getChar(k)==value,
or -1 if there is no such array element.length())
and getDouble(k)==value,
or -1 if there is no such array element.length())
and getFloat(k)==value,
or -1 if there is no such array element.length())
and getInt(k)==value,
or -1 if there is no such array element.length())
and getLong(k)==value,
or -1 if there is no such array element.length())
and value!=null?value.equals(thisArray.get(k)):thisArray.get(k)==null,
or -1 if there is no such array element.length())
and getDouble(k)==value,
or -1 if there is no such array element.length())
and getLong(k)==value,
or -1 if there is no such array element.length())
and getShort(k)==value,
or -1 if there is no such array element.index method for the case
of 2-dimensional matrix.index method for the case
of 3-dimensional matrix.erosion with the same pattern.Matrices.ResizingMethod.POLYLINEAR_INTERPOLATION and Matrices.ResizingMethod.POLYLINEAR_AVERAGING cases,
and for inheritors of Matrices.ResizingMethod.Averaging class created with
Matrices.InterpolationMethod.POLYLINEAR_FUNCTION constructor argument,
false for other cases.Matrices.InterpolationMethod.POLYLINEAR_FUNCTION for
Matrices.ResizingMethod.POLYLINEAR_INTERPOLATION and Matrices.ResizingMethod.POLYLINEAR_AVERAGING cases,
Matrices.InterpolationMethod.STEP_FUNCTION for
Matrices.ResizingMethod.SIMPLE and Matrices.ResizingMethod.AVERAGING cases,
and the argument of the constructor for inheritors of Matrices.ResizingMethod.Averaging class.InterruptionContext.InterruptionContext.Listener.interruptionRequested(InterruptionContext.Event) method.added and
removed by
the interruption context.IRange.min()<=range.IRange.max()
and range.IRange.min()<=IRange.max().min(k)<=area.max(k)
and area.min(k)<=max(k)
for all k.Range.min()<=range.Range.max()
and range.Range.min()<=Range.max().min(k)<=area.max(k)
and area.min(k)<=max(k)
for all k.Updatable extension of the inverse function.transform(context,samples,true)transformMatrix(context,matrixRe,matrixIm,true)min()<=x<=max().AbstractContext.as(Class) method.Context.as(Class) method.DataFileModel.allTemporaryFiles() method), is necessary for this file model.aperture function is a linear function,
where the b coefficient is zero and all ai coefficients
are equal to 1/m, m=apertureDim[0]*apertureDim[1]*....BitArray.class,
UpdatableBitArray.class or MutableBitArray.class
(but not some of their subinterfaces or subclasses).ByteArray.class,
UpdatableByteArray.class or MutableByteArray.class
(but not some of their subinterfaces or subclasses).CharArray.class,
UpdatableCharArray.class or MutableCharArray.class
(but not some of their subinterfaces or subclasses).Matrices.asInterpolationFunc(Matrix, InterpolationMethod, boolean) method with true
last argument.Arrays.asConcatenation(Array...),
Arrays.asConcatenation(MemoryModel, Array...).AbstractWeightedPattern.weightRange().size()==0.0.Morphologies.getConstantlyContinuedMorphology(Morphology, double) or
Morphologies.getConstantlyContinuedMorphology(RankMorphology, double) method.Matrices.Region.contains(long...) in this class works correctly.Matrices.asInterpolationFunc(Matrix, InterpolationMethod, double) method.Matrix.array().isCopyOnNextWrite().MatrixInfo.cloneWithOtherAdditionalProperties(Map) method.LargeMemoryModel.asArray(Object, Class, long, long, ByteOrder) method
or one of its versions for concrete element types
(LargeMemoryModel.asBitArray(Object, long, long, ByteOrder),
LargeMemoryModel.asCharArray(Object, long, long, ByteOrder), etc.),
or if the passed argument is a view of such an array.DirectAccessible
interface and ((DirectAccessible)Matrix.array()).hasJavaArray() method returns true.DoubleArray.class,
UpdatableDoubleArray.class or MutableDoubleArray.class
(but not some of their subinterfaces or subclasses).FloatArray.class,
UpdatableFloatArray.class or MutableFloatArray.class
(but not some of their subinterfaces or subclasses).AbstractArray.setFresh(boolean) method.MemoryModel methods creating an array or a matrix (newXxx
or valueOf, or by fully equivalent methods as Array.updatableClone(),
Array.newCompatibleArray(long), etc.MemoryModel.newMatrix(Class, Class, long...) method or by one of methods
MemoryModel.newBitMatrix(long...),
MemoryModel.newByteMatrix(long...), ..., and if the built-in AlgART array
is also fresh.Matrix.array().isImmutable().Arrays.rangeOf(PArray, MinMaxInfo) method at least once
and this method was successfully finished.side() == Side.X_PLUSIntArray.class,
UpdatableIntArray.class or MutableIntArray.class
(but not some of their subinterfaces or subclasses).AbstractArray.underlyingArrays.length > 0.the constructor while creating this instance.directTransform, inverseTransform,
directTransformMatrix or inverseTransformMatrix
method.DataFile.map(Range, boolean) method, but was quickly loaded from some cache.LongArray.class,
UpdatableLongArray.class or MutableLongArray.class
(but not some of their subinterfaces or subclasses).Patterns.newMinkowskiSum(Pattern[])
or equivalent method from this package.n()<=1 or
if all ai coefficients are equal.ObjectArray.class,
UpdatableObjectArray.class or MutableObjectArray.class
(but not some of their subinterfaces or subclasses).Matrices.asInterpolationFunc(Matrix, InterpolationMethod, boolean) method.AbstractPattern.pointCount(), and if it's 1, checks whether the only element
of AbstractPattern.points() set is the origin.DataFile.open(boolean) method.hyperparallelepiped.AbstractPattern.pointCount()=r0r1...<Long.MAX_VALUE,
where ri=#coordRange(i).Patterns.newRectangularPattern(IRange[]) or equivalent method from this package.Boundary2DScanner.Step.dx()==0 && Boundary2DScanner.Step.dy()==0.Arrays.asShifted(Array, long),
Arrays.asShifted(MemoryModel, Array, long).ShortArray.class,
UpdatableShortArray.class or MutableShortArray.class
(but not some of their subinterfaces or subclasses).Patterns.newPattern(Set)
or equivalent method from this package.Matrix.structureLike(Matrix) method.submatrix of
some parent matrix, created by one of calls parent.subMatrix(...)
or parent.subMatr(...).data file storing all its elements will be automatically deleted
when this AlgART array and all other arrays, sharing the same data (as subarrays), will become unreachable and will be finalized.Patterns.newUnion(Pattern[])
or equivalent method from this package.PArray interface is fully implemented in this class.DirectAccessible.javaArray() call,
corresponding to all elements of this object.DirectAccessible.javaArray() call,
corresponding to the first element of this object.JArrays and java.util.Arrays classes.AbstractPattern.pointCount().Pattern.pointCount() if this value
is not greater than Long.MAX_VALUE;
in other case, returns the number of points in this pattern as double value.lastIndexOf(lowIndex, highIndex, value != 0) : -1.lastIndexOf(lowIndex, highIndex, value != 0) : -1.AbstractBitArray.getBit(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).lastIndexOf(lowIndex, highIndex, (byte)value) : -1.lastIndexOf(lowIndex, highIndex, (byte)value) : -1.AbstractByteArray.getByte(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).lastIndexOf(lowIndex, highIndex, (char)value) : -1.lastIndexOf(lowIndex, highIndex, (char)value) : -1.AbstractCharArray.getChar(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).AbstractDoubleArray.getDouble(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).lastIndexOf(lowIndex, highIndex, (float)value) : -1.AbstractFloatArray.getFloat(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).lastIndexOf(lowIndex, highIndex, (int)value) : -1.lastIndexOf(lowIndex, highIndex, (int)value) : -1.AbstractIntArray.getInt(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).lastIndexOf(lowIndex, highIndex, (long)value) : -1.AbstractLongArray.getLong(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).AbstractObjectArray.get(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).lastIndexOf(lowIndex, highIndex, (short)value) : -1.lastIndexOf(lowIndex, highIndex, (short)value) : -1.AbstractShortArray.getShort(long) method
from index min(AbstractArray.length(),highIndex)-1 back until index max(lowIndex,0).getBit(k)==value,
or -1 if there is no such array element.getByte(k)==value,
or -1 if there is no such array element.getChar(k)==value,
or -1 if there is no such array element.getDouble(k)==value,
or -1 if there is no such array element.getFloat(k)==value,
or -1 if there is no such array element.getInt(k)==value,
or -1 if there is no such array element.getLong(k)==value,
or -1 if there is no such array element.get(k)):thisArray.get(k)==null,
or -1 if there is no such array element.getDouble(k)==value,
or -1 if there is no such array element.getLong(k)==value,
or -1 if there is no such array element.getShort(k)==value,
or -1 if there is no such array element.Boundary2DScanner.next() method.AbstractPattern.points() method.integer points A of this pattern,
that the neighbour point B,
generated by the backwards shift of point A on 1 along the coordinate #coordIndex,
does not belong to this pattern.AbstractArray.length & Long.MAX_VALUE.MutableArray.length(long) method
with the only exception that newUnsignedLength is considered as unsigned long value.Updatable extension of the linear function
with one argument.CombinedMemoryModel.AbstractByteBufferCombiner.workStorage.CombinedMemoryModel.AbstractByteBufferCombiner.workStorage.loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)loadResources(context, 0, length()).subArray(fromIndex, toIndex).loadResources(context)DataBuffer.capacity() elements starting from this position.DataBuffer.capacity()) elements starting from this position.dilationErosion(src, dilationPattern, erosionPattern) call.erosionDilation(src, erosionPattern, dilationPattern) call.AlgART matrices.hyperparallelepiped.function.Matrices.asResized method.matrix (multi-dimensional array)
backed by the specified AlgART array with the given dimensions.AlgART matrix, consisting of elements
of some primitive types, in a form convenient for serialization.coord(i),point.coord(i)).IRectangularArea.max().coord(coordIndex).coord(i),point.coord(i)).RectangularArea.max().coord(coordIndex).Arrays.SystemSettings.CPU_COUNT_PROPERTY_NAME system property
and returned by Arrays.SystemSettings.cpuCountProperty() method.additional properties, that can be stored in this object:
10000.MatrixInfo.toBytes() / MatrixInfo.toChars() methods: 65536.ArrayContext.checkInterruption() and ArrayContext.updateProgress
methods by Arrays.ParallelExecutor class.apertureTo(k)-apertureFrom(k)
for all k=0,1,...,n()-1BitArray, CharArray, ByteArray, ShortArray,
IntArray, LongArray or an inheritor / implementing class of some of these interfaces,
this method is equivalent to
(double)maxPossibleIntegerValue(arrayType);
if arrayType is FloatArray, DoubleArray, ObjectArray
or an inheritor / implementing class of some of these interfaces,
returns valueForFloatingPoint.BitArray,
0xFF for ByteArray,
0xFFFF for CharArray and ShortArray,
Integer.MAX_VALUE for IntArray,
Long.MAX_VALUE for LongArray,
valueForFloatingPoint for FloatArray and DoubleArray.BitArray,
0xFF for ByteArray,
0xFFFF for CharArray and ShortArray,
Integer.MAX_VALUE for IntArray,
Long.MAX_VALUE for LongArray.Arrays.SystemSettings.maxTempJavaMemory() value for a special case: conversion AlgART matrices
into the tiled form and inversely from the tiled form, i.e. for
copying a usual matrix to the matrix created by the Matrix.tile(long...) method and, inversely,
for copying a result of Matrix.tile(long...) method into a usual matrix.ConnectedObjectScanner.resetUsedMemory() method.x coordinate since the last Boundary2DScanner.SimpleMeasurer.reset() call.x−y
since the last Boundary2DScanner.SimpleMeasurer.reset() call.x+y since the last Boundary2DScanner.SimpleMeasurer.reset() call.y coordinate since the last Boundary2DScanner.SimpleMeasurer.reset() call.coord(i),point.coord(i)).IRectangularArea.min().coord(coordIndex).coord(i),point.coord(i)).RectangularArea.min().coord(coordIndex).Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean) method in "non-strict" mode,
the case of resizing coordinate transformation:
layer optimization is used only if the resulting matrix depends on the specified part of every layer.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean) method in "non-strict" mode,
the case of affine coordinate transformation:
tile optimization is not used in a case of a common affine transformation without averaging,
if it is a compression, stronger than this value.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean) method in "non-strict" mode:
layer optimization is not used in a case of simple compressing resizing without averaging,
if total compression is stronger than this value.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean) method in "non-strict" mode:
this optimization uses a buffer in RAM (SimpleMemoryModel's array), the size of which in bytes
is the maximum from this value and Arrays.SystemSettings.maxTempJavaMemory().Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean) method in "non-strict" mode,
the case of projective coordinate transformation:
recursive splitting algorithm does not try to split a tile, if
the total number of its elements is less than this value.AbstractSpectralTransform.maxTempJavaMemory() method of this class: 4194304L bytes (4 MB).Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean) method in "non-strict" mode:
this optimization tries to preload whole original matrix in RAM (if it is little enough)
only if the resulting matrix depends on the specified part of the original one.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean) method in "strict" mode:
this optimization tries to preload whole original matrix in RAM (if it is little enough)
only if the resulting matrix depends on the specified part of the original one.AbstractPattern.points() method in both patterns
and always returns the simple pattern consisting of sums of all point pairs.AbstractPattern.isRectangular() method
returns true.AbstractPattern.points() method in both patterns
and always returns the simple pattern consisting of sums of all point pairs.BitArray, CharArray, ByteArray, ShortArray,
IntArray, LongArray or an inheritor / implementing class of some of these interfaces,
this method is equivalent to
(double)minPossibleIntegerValue(arrayType);
if arrayType is FloatArray, DoubleArray, ObjectArray
or an inheritor / implementing class of some of these interfaces,
returns valueForFloatingPoint.BitArray, ByteArray, CharArray and ShortArray,
Integer.MIN_VALUE for IntArray,
Long.MIN_VALUE for LongArray,
valueForFloatingPoint for FloatArray and DoubleArray.BitArray, ByteArray, CharArray and ShortArray,
Integer.MIN_VALUE for IntArray,
Long.MIN_VALUE for LongArray.x coordinate since the last Boundary2DScanner.SimpleMeasurer.reset() call.x−y
since the last Boundary2DScanner.SimpleMeasurer.reset() call.x+y since the last Boundary2DScanner.SimpleMeasurer.reset() call.y coordinate since the last Boundary2DScanner.SimpleMeasurer.reset() call.n-dimensional matrices.coord(i)*mult).IPoint.multiply(double) method.IPoint.multiply(double) method.coord(i)*mult.AbstractArray.newCompatibleArray(long)
and fills it from this array by UpdatableArray.copy(Array).MutableObjectArray allowing
to load an element without creating new Java object.nBitCopies(null, n, element).nByteCopies(null, n, element).nCharCopies(null, n, element).nDoubleCopies(null, n, element).Boundary2DScanner.x(), Boundary2DScanner.y(), Boundary2DScanner.side()
— is located.AlgART matrices.AlgART matrices.AlgART matrices.AlgART matrices.AlgART matrices.AlgART matrices.AlgART matrices.newArray(array.elementType(), array.length()).newArray(boolean.class, initialLength).newMatrix(UpdatableBitArray.class, boolean.class, dim).newArray(byte.class, initialLength).newMatrix(UpdatableByteArray.class, byte.class, dim).newArray(char.class, initialLength).newMatrix(UpdatableCharArray.class, char.class, dim).newBitArray(initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newByteArray(initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newCharArray(initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newDoubleArray(initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newFloatArray(initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newIntArray(initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newLongArray(initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newObjectArray(AbstractObjectArray.elementType(), initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newShortArray(initialLength)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(elementType, initialLength),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyBitArray(),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyByteArray(),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyCharArray(),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyDoubleArray(),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyFloatArray(),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyIntArray(),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyLongArray(),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyObjectArray(AbstractObjectArray.elementType()),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyShortArray(),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newEmptyArray(elementType),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.memory model if the samples are stored in AlgART arrays).newUnresizableBitArray(length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableByteArray(length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableCharArray(length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableDoubleArray(length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableFloatArray(length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableIntArray(length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableLongArray(length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableObjectArray(AbstractObjectArray.elementType(), length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableShortArray(length)},
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newUnresizableArray(elementType, length),
where mm is the memory model specified by the constructor argument
or SimpleMemoryModel if this argument was null.newArray(double.class, initialLength).newMatrix(UpdatableDoubleArray.class, double.class, dim).newArray(elementType, 10).newEmptyArray(boolean.class).newEmptyArray(boolean.class, initialCapacity).newEmptyArray(byte.class).newEmptyArray(byte.class, initialCapacity).newEmptyArray(char.class).newEmptyArray(char.class, initialCapacity).newEmptyArray(double.class).newEmptyArray(double.class, initialCapacity).newEmptyArray(float.class).newEmptyArray(float.class, initialCapacity).newEmptyArray(int.class).newEmptyArray(int.class, initialCapacity).newEmptyArray(long.class).newEmptyArray(long.class, initialCapacity).newEmptyArray(elementType).newEmptyArray(elementType, initialCapacity).newEmptyArray(short.class).newEmptyArray(short.class, initialCapacity).newArray(float.class, initialLength).newMatrix(UpdatableFloatArray.class, float.class, dim).newArray(int.class, initialLength).newMatrix(UpdatableIntArray.class, int.class, dim).Array.elementType() method.asCopyOnNextWrite(),
if the array is resizable and created by this memory model,
or usual actual copy of the array in other case.MemoryModel.newLazyCopy(Array) method.matrix(newUnresizableLazyCopy(matrix.array())).cast(arraySupertype).newArray(long.class, initialLength).newMatrix(UpdatableLongArray.class, long.class, dim).matrix with the specified element type and dimensions.newMatrix(arraySupertype, matrix.elementType(), matrix.dimensions()).newMinkowskiSum(patterns), where pattern
is the array with the length n containing n copies of the passed pattern.newArray(elementType, initialLength).newPattern(new HashSetrectangular pattern
(n-dimensional rectangular parallelepiped), consisting of all such points
(x0,x1,...,xn-1) that
ranges[i].min()<=xi<=ranges[i].max(), i=0,1,...,n-1, n=ranges.length.newRectangularPattern(ranges),
where ranges[k] is IRange.valueOf(min.coord(k), max.coord(k)).newArray(short.class, initialLength).newMatrix(UpdatableShortArray.class, short.class, dim).Patterns.newPattern(Set) method returning
the pattern consisting of all such points inside n-dimensional sphere
with the given radius r and center.newMatrix(arraySupertype, matrix).structureLike(matrix).newUnresizableArray(array.elementType(), array.length()).newUnresizableArray(boolean.class, initialLength).newUnresizableArray(byte.class, initialLength).newUnresizableArray(char.class, initialLength).newUnresizableArray(double.class, initialLength).newUnresizableArray(float.class, initialLength).newUnresizableArray(int.class, initialLength).asCopyOnNextWrite(),
if the array is updatable and created by this memory model,
or usual actual copy of the array in other case.MemoryModel.newUnresizableLazyCopy(Array) method.MemoryModel.newLazyCopy(Array) method with the only difference, that the returned array
is unresizable.newUnresizableArray(long.class, initialLength).newUnresizableArray(elementType, initialLength).newUnresizableArray(short.class, initialLength).getBits(pos, destArray, 0, someCount)
and (for updatable array)
setBits(pos, srcArray, 0, someCount)
work essentially faster than for most of other ("slow") positions,
or -1 if there is no such position,
in particular, if position>=length().nFloatCopies(null, n, element).nIntCopies(null, n, element).nLongCopies(null, n, element).nObjectCopies(n, element) method
with element=null that allows to specify the element type
of the returned array.nObjectCopies(mm, n, element) method
with element=null that allows to specify the element type
of the returned array.DirectAccessible.javaArray() method
if the object cannot be viewed as a Java array.nObjectCopies(null, n, element).ArrayContext.updateProgress(Event) method does nothing.sort method.nPCopies(null, n, elementType, element).nPFixedCopies(null, n, elementType, element).nShortCopies(null, n, element).straight connectivity,
3dimCount-1 for straight-and-diagonal connectivity.Arrays.ParallelExecutor.process() method.Arrays.ParallelExecutor.numberOfRanges field.Arrays.ParallelExecutor.process() method.Arrays.ParallelExecutor.numberOfTasks field.ObjectArray allowing
to load an element without creating new Java object.getInstance method.getInstance method.mathematical function to another.min(k)<area.max(k)
and area.min(k)<max(k)
for all k.packBitsGreater(null, bits, array, threshold).getDouble(k) >= thresholdpackBitsGreaterOrEqual(null, bits, array, threshold).getDouble(k) >= thresholdpackBitsLess(null, bits, array, threshold).getDouble(k) <= thresholdpackBitsLessOrEqual(null, bits, array, threshold).getDouble(k) <= thresholdparallelDistance(IPoint.valueOf(coordinates)), but works faster because does not require to create an instance
of IPoint class.parallelDistance(IPoint.valueOf(x, y)), but works faster because does not require to allocate any objects.parallelDistance(IPoint.valueOf(x, y, z)), but works faster because does not require to allocate any objects.parallelDistance(Point.valueOf(coordinates)), but works faster because does not require to create an instance
of Point class.parallelDistance(Point.valueOf(x, y)), but works faster because does not require to allocate any objects.parallelDistance(Point.valueOf(x, y, z)), but works faster because does not require to allocate any objects.getInstance method.getInstance method.Boundary2DScanner.Wrapper.parent scanner.Convolution object, passed to ConstantlyContinuedConvolution.getInstance(Convolution, double) method.part(fromPart, toPart))integer points
(points in multidimensional space with integer coordinates).patterns.preciseValue(histogram,percentileLevel*(sumOfColumns-1)),
if sumOfColumns>0.preciseValue(histogram,percentileLevel*(sumOfColumns-1)),
if sumOfColumns>0.getThreadPool(threadFactory) method
in the begin of execution.ThreadPoolFactory.performTasks(java.util.concurrent.ThreadFactory, Runnable[]) method
with the only difference, that the thread pool is got via
getThreadPool(sourceArray, threadFactory) method.DefaultThreadPoolFactory.getThreadPool(Array, ThreadFactory) method,
if it exists,
or null in other case.integer points in this pattern.integer points of this pattern.Stack.popElement().matrix is placed.Updatable extension of the power function
with one argument.preciseSumOf(null, array, checkOverflow).getLong(k) for all k==0,1,...,array.length()-1.preciseSumOf(null, array, false).preciseSumOf(context, array, false).Histogram.value(long[], long).Histogram.preciseValue(long[], double) for a case
of int[] type of the histogram.AbstractDataFileModel.recommendedPrefixSize() method.GeneralizedBitProcessing.sliceOperation()).performIteration method, while
IterativeArrayProcessor.done() method returns false.subArr(position,count)
to dest.subArr(position,count)
via UpdatableArray.copy(Array) method.ProductFunc.getInstance(double) method.pushElement(value).IRange.valueOf(min(coordIndex), max(coordIndex)).min()<=x<=max().Range.valueOf(min(coordIndex), max(coordIndex)).rangeOf(null, array, minMaxInfo).Range.valueOf(min, max),
where min is equal to the minimal array element
and min is equal to the maximal array element.rangeOf(null, array, null).rangeOf(context, array, null).UpdatablePNumberArray.UpdatablePNumberArray.Arrays.SystemSettings.profilingMode() returns true).ArrayContext.checkInterruption() and ArrayContext.updateProgress
methods by Arrays.ParallelExecutor and AbstractIterativeArrayProcessor classes.StandardIODataFileModel class,
or default value 65536 if some exception occured while calling Integer.getInteger.DefaultDataFileModel class,
or default value 3 * Runtime.getRuntime().availableProcessors(),
if some exception occured while calling Integer.getInteger.StandardIODataFileModel class,
or default value 32 if some exception occured while calling Integer.getInteger.constructor without arguments (a usual case), this implementation returns
the result of Arrays.SystemSettings.cpuCount() method.DefaultThreadPoolFactory.recommendedNumberOfTasks(), excepting that
when the passed array is very little, this method may return less value (usually 1).AbstractDataFileModel.prefixSize — the long value passed
to the constructor, or 0 if the constructor without long argument was used.DataFileModel.createTemporary(boolean) method.unresizable and it's size, in bytes,
is less than or equal to the result of this method, then all data file is mapped by a single large bank.ArrayPool.requestArray() call,
and adds it to the internal cache of arrays.JArrayPool.requestArray() call,
and adds it to the internal cache of arrays.DefaultThreadPoolFactory.persistentThreadPool() returns null), or does nothing in other case.ThreadPoolFactory.getThreadPool(Array, ThreadFactory) method.InterruptionContext.addInterruptionListener(Listener) method.Boundary2DScanner.Wrapper.nextBoundary() and
Boundary2DScanner.Wrapper.go(long, long, Boundary2DScanner.Side) methods
after calling the same methods of the parent scanner.ConnectedObjectScanner.maxUsedMemory() method.LinearFunc class, describing the linear function
1.0 - x0:
LinearFunc.getInstance(1.0, -1.0).sort method.Direction2D.revive().AbstractPattern.points() method.integer points A of this pattern,
that the neighbour point B,
generated by the forwards shift of point A on 1 along the coordinate #coordIndex,
does not belong to this pattern.coord(i)*mult).n−1=sectionCoordinateValue,
and returns this intersection as an array of comments to this class.comments to this class.comments to this class, if normalizeDirectTransform argument
is false, or to the formula 2, if this argument is true.comments to this class, if normalizeDirectTransform argument
is false, or to the formula 2, if this argument is true.setElement(index, value).get(x) will be, as possible, equal to newResult.AbstractUpdatableBitArray.setBit(long, boolean) method.AbstractUpdatableBitArray.setBit(long, boolean) method.AbstractUpdatableBitArray.setData(long, Object, int, int)
with corresponding arguments.AbstractUpdatableByteArray.setByte(long, byte) method.AbstractUpdatableByteArray.setData(long, Object, int, int)
with corresponding arguments.AbstractUpdatableCharArray.setChar(long, char) method.AbstractUpdatableCharArray.setData(long, Object, int, int)
with corresponding arguments.AbstractUpdatableDoubleArray.setDouble(long, double) method.AbstractUpdatableDoubleArray.setData(long, Object, int, int)
with corresponding arguments.AbstractUpdatableFloatArray.setFloat(long, float) method.AbstractUpdatableFloatArray.setData(long, Object, int, int)
with corresponding arguments.AbstractUpdatableIntArray.setInt(long, int) method.AbstractUpdatableIntArray.setData(long, Object, int, int)
with corresponding arguments.AbstractUpdatableLongArray.setLong(long, long) method.AbstractUpdatableLongArray.setData(long, Object, int, int)
with corresponding arguments.AbstractUpdatableObjectArray.set(long, Object) method.AbstractUpdatableObjectArray.setData(long, Object, int, int)
with corresponding arguments.AbstractUpdatableShortArray.setShort(long, short) method.AbstractUpdatableShortArray.setData(long, Object, int, int)
with corresponding arguments.length() - arrayPos, srcArray.length})
elements from the specified Java array of corresponding type,
starting from 0 index,
into this array, starting from arrayPos index.AbstractArray.isFresh() method.setLong(index, (long)value),
but may work little faster.setFresh(false).setFresh(false).setFresh(false).setFresh(false).setFresh(false).setFresh(false).setFresh(false).setFresh(false).setFresh(false).fresh status" for this array instance.DataFileModel.allTemporaryFiles() method;
if value is false, removes it from that collection.LargeMemoryModel.isTemporary(Array) method.array() are instances of the required arrayClass,
or throws an exception in other case.AbstractArray.standardObjectClone().AbstractBitArray.updatableClone() method and returns its result.AbstractByteArray.updatableClone() method and returns its result.AbstractCharArray.updatableClone() method and returns its result.AbstractDoubleArray.updatableClone() method and returns its result.AbstractFloatArray.updatableClone() method and returns its result.AbstractIntArray.updatableClone() method and returns its result.AbstractLongArray.updatableClone() method and returns its result.AbstractObjectArray.updatableClone() method and returns its result.AbstractShortArray.updatableClone() method and returns its result.IPoint.add(IPoint) method.weights,
generated from points of this instance by adding the argument via IPoint.add(IPoint) method.positioned yet).erosions of the matrix by some small pattern.ArrayContext.getThreadPoolFactory() method, returns
thisInstance.getThreadPoolFactory().singleThreadVersion().Matrix.array().length().IRange.max()-IRange.min()+1.IPoint.max(coordIndex) - min(coordIndex) + 1.Range.max()-Range.min().Point.max(coordIndex) - min(coordIndex).DataFileModel that creates usual Java files,
but emulates mapping via standard read/write operations
(StandardIODataFileModel.readAllBuffer(FileChannel, long, ByteBuffer) and
StandardIODataFileModel.writeAllBuffer(FileChannel, long, ByteBuffer) methods).StandardIODataFileModel(null, 0).StandardIODataFileModel(null, 0, cacheReading).StandardIODataFileModel(tempPath, 0).StandardIODataFileModel(tempPath, 0, cacheReading)."fresh" flag.Arrays.ParallelExecutor.processRange(long, long, int, long)
method at the begin of each processed block.CombinedMemoryModel.AbstractByteBufferCombiner.workStorage.Arrays.copy(ArrayContext, UpdatableArray, Array, int, boolean) or
Matrices.copy(ArrayContext, Matrix, Matrix, int, boolean) method with
the argument strictMode=true or by any other method of copying arrays.subArray(position, position + count).subArray(position, position + count).AbstractBitArray with the same memory model,
underlying arrays and underlyingArraysAreParallel flag, that were passed
to the constructor of this instance,
and with overridden methods AbstractBitArray.getBit(long) and
AbstractBitArray.getData(long, Object, int, int),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractByteArray with the same memory model,
underlying arrays and underlyingArraysAreParallel flag, that were passed
to the constructor of this instance,
and with overridden methods AbstractByteArray.getByte(long) and
AbstractByteArray.getData(long, Object, int, int),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractCharArray with the same memory model,
underlying arrays and underlyingArraysAreParallel flag, that were passed
to the constructor of this instance,
and with overridden methods AbstractCharArray.getChar(long) and
AbstractCharArray.getData(long, Object, int, int),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractDoubleArray with the same memory model,
underlying arrays and underlyingArraysAreParallel flag, that were passed
to the constructor of this instance,
and with overridden methods AbstractDoubleArray.getDouble(long) and
AbstractDoubleArray.getData(long, Object, int, int),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractFloatArray with the same memory model,
underlying arrays and underlyingArraysAreParallel flag, that were passed
to the constructor of this instance,
and with overridden methods AbstractFloatArray.getFloat(long) and
AbstractFloatArray.getData(long, Object, int, int),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractIntArray with the same memory model,
underlying arrays and underlyingArraysAreParallel flag, that were passed
to the constructor of this instance,
and with overridden methods AbstractIntArray.getInt(long) and
AbstractIntArray.getData(long, Object, int, int),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractLongArray with the same memory model,
underlying arrays and underlyingArraysAreParallel flag, that were passed
to the constructor of this instance,
and with overridden methods AbstractLongArray.getLong(long) and
AbstractLongArray.getData(long, Object, int, int),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractObjectArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractObjectArray.get(long) and
AbstractObjectArray.getData(long arrayPos, Object destArray, int destArrayOffset, int count),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractShortArray with the same memory model,
underlying arrays and underlyingArraysAreParallel flag, that were passed
to the constructor of this instance,
and with overridden methods AbstractShortArray.getShort(long) and
AbstractShortArray.getData(long, Object, int, int),
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableBitArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractBitArray.getBit(long), AbstractUpdatableBitArray.setBit(long, boolean),
AbstractBitArray.getData(long, Object, int, int) and
AbstractUpdatableBitArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableByteArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractByteArray.getByte(long), AbstractUpdatableByteArray.setByte(long, byte),
AbstractByteArray.getData(long, Object, int, int) and
AbstractUpdatableByteArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableCharArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractCharArray.getChar(long), AbstractUpdatableCharArray.setChar(long, char),
AbstractCharArray.getData(long, Object, int, int) and
AbstractUpdatableCharArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableDoubleArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractDoubleArray.getDouble(long), AbstractUpdatableDoubleArray.setDouble(long, double),
AbstractDoubleArray.getData(long, Object, int, int) and
AbstractUpdatableDoubleArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableFloatArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractFloatArray.getFloat(long), AbstractUpdatableFloatArray.setFloat(long, float),
AbstractFloatArray.getData(long, Object, int, int) and
AbstractUpdatableFloatArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableIntArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractIntArray.getInt(long), AbstractUpdatableIntArray.setInt(long, int),
AbstractIntArray.getData(long, Object, int, int) and
AbstractUpdatableIntArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableLongArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractLongArray.getLong(long), AbstractUpdatableLongArray.setLong(long, long),
AbstractLongArray.getData(long, Object, int, int) and
AbstractUpdatableLongArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableObjectArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractObjectArray.get(long), AbstractUpdatableObjectArray.set(long, Object),
AbstractObjectArray.getData(long, Object, int, int) and
AbstractUpdatableObjectArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.AbstractUpdatableShortArray with the same memory model
and underlying arrays, that were passed to the constructor of this instance,
and with overridden methods AbstractShortArray.getShort(long), AbstractUpdatableShortArray.setShort(long, short),
AbstractShortArray.getData(long, Object, int, int) and
AbstractUpdatableShortArray.setData(long, Object, int, int)
calling the same methods of this instance with corresponding corrections of the arguments.base constructor
with the only difference that as(ArrayMemoryContext.class)
method will return a ArrayMemoryContext describing the passed memory model.Matrix.subMatrix(long[] from, long[] to) method, where
from[k]=position[k] and to[k]=position[k]+dimensions[k] for all k.Matrix.subMatr(long[] position, long[] dimensions) method, where
position is the first half of positionAndDimensions array and
dimensions is it's second half.Matrix.subMatrix(long[] from, long[] to, Object outsideValue) method, where
from[k]=position[k] and to[k]=position[k]+dimensions[k] for all k.subMatr(new long[]{x,y}, new long[]{dimX,dimY}, outsideValue)subMatr(new long[]{x,y,z}, new long[]{dimX,dimY,dimZ}, outsideValue)Matrix.subMatrix(long[] from, long[] to) method, where
from.length=to.length=area.coordCount(),
from[k]=area.min(k)},
to[k]=area.max(k)}+1.Matrix.subMatrix(long[] from, long[] to) method, where
from is the first half of fromAndTo array and
to is it's second half.Matrix.subMatrix(long[], long[]) method, allowing to get a rectangular fragment
which is not fully inside this matrix.Matrix.subMatrix(long[] from, long[] to, Object outsideValue) method, where
from.length=to.length=area.coordCount(),
from[k]=area.min(k)},
to[k]=area.max(k)}+1.subMatrix(new long[]{fromX,fromY}, new long[]{toX,toY}, outsideValue)subMatrix(new long[]{fromX,fromY,fromZ}, new long[]{toX,toY,toZ}, outsideValue)submatrix of some parent matrix,
created by one of calls parent.subMatrix(...) or parent.subMatr(...),
creates and returns a new Java array containing the starting position of this submatrix
in the parent one.submatrix of some parent matrix,
created by one of calls parent.subMatrix(...) or parent.subMatr(...),
returns a reference to the parent matrix instance.submatrix of some parent matrix,
created by one of calls parent.subMatrix(...) or parent.subMatr(...),
creates and returns a new Java array containing the ending position (exlusive) of this submatrix
in the parent one.coord(i)-point.coord(i).coord(i)-point.coord(i).sumOf(null, array).getDouble(k) for all k==0,1,...,array.length()-1.immutable view of internal AlgART array, where the sums
of all elements of the source matrix and every its openings are stored.AbstractBitArray.getBit(long)
and AbstractUpdatableBitArray.setBit(long, boolean) methods.AbstractUpdatableBitArray.swap(long, long) method.defaultSwap(thisInstance, another).AbstractByteArray.getByte(long)
and AbstractUpdatableByteArray.setByte(long, byte) methods.AbstractUpdatableByteArray.swap(long, long) method.defaultSwap(thisInstance, another).AbstractCharArray.getChar(long)
and AbstractUpdatableCharArray.setChar(long, char) methods.AbstractUpdatableCharArray.swap(long, long) method.defaultSwap(thisInstance, another).AbstractDoubleArray.getDouble(long)
and AbstractUpdatableDoubleArray.setDouble(long, double) methods.AbstractUpdatableDoubleArray.swap(long, long) method.defaultSwap(thisInstance, another).AbstractFloatArray.getFloat(long)
and AbstractUpdatableFloatArray.setFloat(long, float) methods.AbstractUpdatableFloatArray.swap(long, long) method.defaultSwap(thisInstance, another).AbstractIntArray.getInt(long)
and AbstractUpdatableIntArray.setInt(long, int) methods.AbstractUpdatableIntArray.swap(long, long) method.defaultSwap(thisInstance, another).AbstractLongArray.getLong(long)
and AbstractUpdatableLongArray.setLong(long, long) methods.AbstractUpdatableLongArray.swap(long, long) method.defaultSwap(thisInstance, another).AbstractObjectArray.get(long)
and AbstractUpdatableObjectArray.set(long, Object) methods.AbstractUpdatableObjectArray.swap(long, long) method.defaultSwap(thisInstance, another).AbstractShortArray.getShort(long)
and AbstractUpdatableShortArray.setShort(long, short) methods.AbstractUpdatableShortArray.swap(long, long) method.defaultSwap(thisInstance, another).length(), src.length()) elements of
another array, starting from index 0,
and the same number of elements of this array, starting from index 0.multiply(-1.0).multiply(-1.0).multiply(-1.0).multiply(-1.0).AbstractDataFileModel.createTemporaryFile(boolean) method
or null if the default temporary-file directory is to be used.AbstractDataFileModel.tempPath protected field,
in other words, the first argument of AbstractDataFileModel.AbstractDataFileModel(File, long) constructor.DataBuffer.toIndex(), if DataBuffer.toIndex()<=Integer.MAX_VALUE,
or throws UnsupportedOperationException in other case.IPoint.valueOf(thisInstance).IRectangularArea.valueOf(thisInstance).toJavaArray((Array)array).toJavaArray((Array)array).toJavaArray((Array)array).toJavaArray((Array)array).toJavaArray((Array)array).toJavaArray((Array)array).toJavaArray((Array)array).toJavaArray((Array)array).toJavaArray((Array)array).pattern is extremely large to be correctly processed.Point.valueOf(thisInstance).RectangularArea.valueOf(thisInstance).IPoint.roundOf(thisInstance).IRectangularArea.roundOf(thisInstance).AbstractSpectralTransform.transform(ArrayContext, SampleArray, boolean) method, to multidimensional case,
as described in comments to this class.Matrix.array().type().Matrix.array().type(),
if it is subtype of (or same type as) the passed arraySupertype,
or throws ClassCastException in other case.AbstractSpectralTransform.isLengthAllowed(long) method.trusted immutable
AlgART arrays have been changed.Matrix.index(long...) method, that does not check,
whether the passed coordinates are in the required ranges.allUnionDecompositions(minimalPointCount).get(0).unpackBits(null, array, bits, filler0, filler1).unpackUnitBits(null, array, bits, filler1).unpackZeroBits(null, array, bits, filler0).Context.as(Class) method
when it cannot serve the request.MemoryModel.newEmptyArray(Class)), if the specified element type
is not supported by the memory model.Func.IDENTITY function.AbstractArray.newCompatibleUnresizableArray(long)
and fills it from this array by UpdatableArray.copy(Array).UpdatableObjectArray allowing
to load an element without creating new Java object.Matrix.array().updatableType().Matrix.array().updatableType(),
if it is subtype of (or same type as) the passed arraySupertype,
or throws ClassCastException in other case.Arrays.ParallelExecutor.process().ArrayContext.updateProgress method
with the context, passed to the constructor,
and correctly filled ArrayContext.Event instance.as(ProgressUpdater.class).updateProgress(part, part==1.0), where context is the argument of the construcor
and part=event.readyPart().DefaultContext.updateStatus(String, boolean)
with the first argument alike Math.round(readyPart*100)+"%"
and the second argument force.indexInArray(), matrix().size())matrix().size(), matrix().index(coordinates))updateStatus(message, true).updateStatus(message, true).constructor.Histogram.value(long[], long) for a case
of int[] type of the histogram.Histogram.value(long[], long), rounded to the "best" integer result.Histogram.value(long[], double) for a case
of int[] type of the histogram.version of serialization format.valueOf((Object)array, offset, count).valueOf((Object)array).valueOf((Object)array, offset, count).valueOf((Object)array).valueOf((Object)array, offset, count).valueOf((Object)array).valueOf((Object)array, offset, count).valueOf((Object)array).valueOf((Object)array, offset, count).valueOf((Object)array).valueOf((Object)array, offset, count).valueOf((Object)array).valueOf((Object)array, offset, count).valueOf((Object)array).valueOf((Object)array, offset, count).valueOf((Object)array).valueOf((Object)array, offset, count).valueOf((Object)array).ConnectedObjectScanner.clear(ArrayContext, net.algart.matrices.bitscanning.ConnectedObjectScanner.ElementVisitor, long...)
for every visited unit element of the matrix.OctupleThinningSkeleton2D skeletonization.WeightedMeanFunc.getInstance(double) method.weighted patterns.positioned yet).LinearFunc class, describing the linear function
x0 - x1:
LinearFunc.getInstance(0.0, 1.0, -1.0).LinearFunc class, describing the linear function
x0 + x1:
LinearFunc.getInstance(0.0, 1.0, 1.0).positioned yet).LinearFunc class, describing the linear function
x1 - x0:
LinearFunc.getInstance(0.0, -1.0, 1.0).
|
|
||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||