|
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(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.ByteArray interface.AbstractByteArray.AbstractByteArray(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.CharArray interface.AbstractCharArray.AbstractCharArray(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(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.FloatArray interface.AbstractFloatArray.AbstractFloatArray(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(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.IterativeArrayProcessor interface.LongArray interface.AbstractLongArray.AbstractLongArray(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(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.RankMorphology interface to minimize
the effort required to implement this interface.ShortArray interface.AbstractShortArray.AbstractShortArray(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.UniformGridPattern interface to minimize
the effort required to implement this interface.UpdatableBitArray interface.AbstractUpdatableBitArray.AbstractUpdatableBitArray(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableByteArray interface.AbstractUpdatableByteArray.AbstractUpdatableByteArray(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableCharArray interface.AbstractUpdatableCharArray.AbstractUpdatableCharArray(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableDoubleArray interface.AbstractUpdatableDoubleArray.AbstractUpdatableDoubleArray(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableFloatArray interface.AbstractUpdatableFloatArray.AbstractUpdatableFloatArray(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableIntArray interface.AbstractUpdatableIntArray.AbstractUpdatableIntArray(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableLongArray interface.AbstractUpdatableLongArray.AbstractUpdatableLongArray(long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableObjectArray interface.AbstractUpdatableObjectArray.AbstractUpdatableObjectArray(Class, long, long, boolean, Array...),
where both initialCapacity and initialLength arguments are equal to
initialCapacityAndLength.UpdatableShortArray interface.AbstractUpdatableShortArray.AbstractUpdatableShortArray(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).coord(i)+increment.coord(i)+increment.current pixel is a node,
returns indexes of all its neighbours, which are the starting pixels of branches, incident with this node.SkeletonScanner.adjacentBranches() method, which stores the results
in the passed Java array instead of creating new Java array.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 equal or similar "quality",
i.e. with the same or almost same summary number of points in all Minkowski decompositions
of all returned patterns.data file models, that were used
in any instances of this class (as constructor agruments) since the application start.SkeletonPixelClassifier abstract class,
minimizing the effort required to implement its abstract methods.ApertureFilterOperator.apertureDim()[coordIndex].ApertureFilterOperator
in n-dimensional Euclidean space.ApertureFilterOperator.apertureFrom()[coordIndex].n-dimensional matrices and returning a group of resulting matrices,
where the value of every element of every resulting matrix depends only on
the elements of the source matrices in some aperture "around" the same position.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(truncateOverflows, f, result.type(), 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, x1, x2, x3, x4).applyFunc(context, truncateOverflows, f, result, several(PArray.class, x1, x2, x3, x4)).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 or WeakReference.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, if 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).asConvolution(src.type(PArray.class), src, pattern).asCoordFuncMatrix(true, f, requiredType, dim).Matrices.asFuncMatrix(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.updatableClone(Arrays.SMM).updatableClone(Arrays.SMM).updatableClone(Arrays.SMM).updatableClone(Arrays.SMM).updatableClone(Arrays.SMM).updatableClone(Arrays.SMM).updatableClone(Arrays.SMM).updatableClone(Arrays.SMM).updatableClone(Arrays.SMM).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(true, f, requiredType, x).get(x[0].getDouble(k), x[1].getDouble(k), ...),
i.e. the result of the passed function for arguments, equal to the corresponding elements #k
in all passed arrays.asFuncMatrix(f, requiredType, several(PArray.class, x)).asFuncMatrix(truncateOverflows, f, requiredType, several(PArray.class, x)).asFuncMatrix(f, requiredType, several(PArray.class, x1, x2)).asFuncMatrix(truncateOverflows, f, requiredType, several(PArray.class, x1, x2)).asFuncMatrix(f, requiredType, several(PArray.class, x1, x2, x3)).asFuncMatrix(truncateOverflows, f, requiredType, several(PArray.class, x1, x2, x3)).asFuncMatrix(f, requiredType, several(PArray.class, x1, x2, x3, x4)).asFuncMatrix(truncateOverflows, f, requiredType, several(PArray.class, x1, x2, x3, x4)).asFuncMatrix(true, f, requiredType, x).Arrays.asFuncArray(boolean, Func, Class, PArray...) method
for AlgART matrices.asFunctionOfPercentilePair(src,m1,m2,pattern,processingFunc), where
constantPercentileMatrix(src,percentileIndex1)constantPercentileMatrix(src,percentileIndex2)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, boolean).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, boolean).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, boolean).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, boolean).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, boolean).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, boolean).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, boolean).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, boolean).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, boolean).asIndexFuncArray(true, f, requiredType, length).Arrays.asFuncArray(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).AbstractRankMorphology.asFunctionOfSum(Matrix, Pattern, Func) method, as described in
comments to this method in RankMorphology interface.asMeanBetweenPercentiles(src,m1,m2,pattern,filler), where
constantPercentileMatrix(src,fromPercentileIndex)constantPercentileMatrix(src,toPercentileIndex)straight-and-diagonal connectivity kind).asPercentile(src,m,pattern),
where constantPercentileMatrix(src,percentileIndex)SkeletonScanner.pixelClassifier().asPixelTypes(SkeletonScanner.skeleton(), attachmentInformation),
but probably works faster.asProcessed(requiredType, src, Matrices.several(PArray.class), pattern).asProcessed(requiredType, src, Matrices.several(PArray.class, additionalMatrix), pattern).asProcessed(requiredType, src, Matrices.several(PArray.class, additionalMatrix1, additionalMatrix2), pattern).asProcessed(requiredType, src, Matrices.several(PArray.class, additionalMatrix1, additionalMatrix2, additionalMatrix3), pattern).Matrices.asResized(Matrices.ResizingMethod, Matrix, long...) method,
allowing to precisely specify a custom scaling value along every coordinate.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.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(true, f, requiredType, x).Arrays.asFuncArray(boolean, Func, Class, PArray...) method
allowing to create updatable view of the source array.asUpdatableFuncMatrix(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 occurred while
calling Boolean.getBoolean.Arrays.SystemSettings.MAX_AVAILABLE_PROCESSORS constant.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).Morphology interface.RankMorphology interface with an instantiation method
of some complete implementation.thinning skeletons.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.copy(ArrayContext, UpdatableArray, Array, int, boolean)
method in "non-strict" mode in a case of resizing whole matrix, created by
Matrices.asResized(Matrices.ResizingMethod, Matrix, long...) method.Arrays.ParallelExecutor.processSubArr(long, int, int) method.Boundary2DSimpleMeasurer 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.goTo(long, long, net.algart.matrices.scanning.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.ExternalProcessor.close() and ExternalProcessor.finalize() methods.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.StreamingApertureProcessor.process(Matrix, Matrix, List, Pattern) method and throws the corresponding exception
if it is not so.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.checkInterruption() or
does nothing if context==null.SkeletonScanner.context().checkInterruption()
or does nothing if SkeletonScanner.context()==null.ArrayContext.checkInterruption()updateProgress(new ArrayContext.Event(elementType, readyCount, length))UnsafeSegment2D).BitArray.class, CharArray.class,
ByteArray.class, ShortArray.class,
IntArray.class, LongArray.class,
FloatArray.class, DoubleArray.class,
ObjectArray.class,
UpdatableBitArray.class, UpdatableCharArray.class,
UpdatableByteArray.class, UpdatableShortArray.class,
UpdatableIntArray.class, UpdatableLongArray.class,
UpdatableFloatArray.class, UpdatableDoubleArray.class,
UpdatableObjectArray.class,
suitable for storing the specified element type.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.ExternalProcessor.getInstance(ArrayContext, String, String)
method with the same tempDirectory argument, and which were not successfully deleted yet.cleanup(ExternalProcessor.getDefaultTempDirectory()).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).matrix, corresponding to this object,
and also clears all objects in the passed second matrix with same sizes, which are connected with at least
one unit (1) element of the first matrix.byte order.data offset.version
of the serialization format.ExternalProcessor.cancelRemovingWorkDirectory() call),
and sets the state of this instance to "closed".DataBuffer.count(), if DataBuffer.count()<=Integer.MAX_VALUE,
or throws DataBufferIndexOverflowException 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.ConnectedObjectScanner.ElementVisitor interface.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.AbstractArrayProcessorWithContextSwitching.context() == null ? null :
AbstractArrayProcessorWithContextSwitching.context().part(fromPart, toPart))constant continuation mode,
or throws throws NonConstantMatrixContinuationModeException,
if it is not a constant continuation mode.Convolution object to another instance of that interface,
which uses some non-trivial form of continuation outside the source matrix.Morphology object to another instance of that interface,
which uses some non-trivial form of continuation outside the source matrix.RankMorphology object to another instance of that interface,
which uses some non-trivial form of continuation outside the source matrix.streaming aperture procesor
to another instance of that class, which uses some non-trivial form of continuation outside the source matrix.Boundary2DScanner.AbstractConvolution.asConvolution(Class, Matrix, WeightedPattern)
method and copies it into a newly created matrix via
Matrices.copy(ArrayContext, Matrix, Matrix) method.AbstractPattern.coordRange(int) method
for all coordinate indexes from 0 to AbstractPattern.dimCount()-1.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.AbstractPattern.coordRange(int) method
for all coordinate indexes from 0 to AbstractPattern.dimCount()-1.Point.coord(coordIndex))
among all points of this pattern.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.ConnectedObjectScanner.MaskElementCounter.counter() method.ConnectedObjectScanner.MaskElementCounter.counter field.Arrays.SystemSettings.cpuCountProperty() method.Arrays.SystemSettings.cpuCountProperty() method, if it is a positive number,
or the result of Arrays.SystemSettings.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 the result of Arrays.SystemSettings.availableProcessors() method.AbstractDataFileModel.createTemporaryFile(boolean)
protected method and returns a result of getDataFile(pathToTemporaryFile, ByteOrder.nativeOrder()).DataFile
object corresponding to it.positioned yet).AlgART arrays,
about some current folder (usually a disk directory).underlying array of the currently
scanned matrix.SkeletonScanner.currentCoordinates(), designed for indexing
elements of the built-in AlgART array of the skeleton matrix.SummingHistogram.nextSharing().SummingHistogram.currentIntegral()
- thisInstance.SummingHistogram.currentIntegral(), but probably works little faster.Histogram.currentIValue().current value v, rounded to an integer number.currentIValue()current coordinates.SummingHistogram.nextSharing().SummingHistogram.currentPreciseIntegral()
- thisInstance.SummingHistogram.currentPreciseIntegral(), but probably works little faster.currentIValue()ArrayContext.numberOfThreads() parallel threads.ArrayContext.customData() method in the result returns
the value, specified in the argument customData.RankMorphology
interface.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, before all calculations,
replaces the passed coordinates with the positive remainders
from division of them by the corresponding matrix dimensions.data buffers.DataBuffer methods from(),
to() and cnt(), if the values, they should be returned
by these methods, are greater than Integer.MAX_VALUE.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.DependenceApertureBuilder.getAperture(int, Pattern[], boolean[]) method: 2 elements.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.defaultLazyWriting()).DefaultDataFileModel(null, 0, lazyWriting).DefaultDataFileModel(tempPath, 0, DefaultDataFileModel.defaultLazyWriting()).DefaultDataFileModel(tempPath, 0, lazyWriting).directBuffer flag, used when this this class
is instantiated by a constructor without directBuffer argument.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.Matrix.tile() method to create a tiled matrix.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: if subtractionMode argument
is not Morphology.SubtractionMode.NONE,
returns the difference between the dilation and the src matrix,
according the specified mode.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().MatrixInfo.dimCount().AbstractPattern.dimCount field.SkeletonPixelClassifier.dimCount() method.SkeletonScanner.skeleton().dimCount().dim(0).dim(1).dim(2).Pattern implementations to indicate that
they are direct point-set patterns, i.e. are internally represented as actual sets of points
like Set<Point>.Pattern implementations to indicate that
they are simultaneously DirectPointSetPattern and UniformGridPattern.transform(context,samples,false)transformMatrix(context,matrixRe,matrixIm,false)unmap(false) method
and returns true,
or performs some reduced form of unmapping (or even does nothing) and returns false.Boundary2DScanner.Step.pixelCenterDX(), Boundary2DScanner.Step.pixelCenterDY()).DividingFunc.getInstance(double) method.InterruptableAction.run() method and returns its result.Arrays.ParallelExecutor.process().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.erosions of the matrix by some small pattern.Morphology.erosion(Matrix, Pattern) method: if subtractionMode argument
is not Morphology.SubtractionMode.NONE,
returns the difference between the erosion and the src matrix,
according the specified mode.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.Histogram.exclude(int) method for all passed values.min(),value) <= x
<= Math.max(this.max(),value)min(),value) <= x
<= StrictMath.max(this.max(),value)subMatrix(from, to, continuationMode),
where min(k)dim(k)+aperture.max(k)width(k)ExternalProcessor.execute(ProcessBuilder) method,
if the called external process is finished with non-zero OS exit code.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)).ExternalProcessor.close() method.Arrays.ParallelExecutor.process() method.current pixel is a
node or isolated pixel,
checks whether we have a skeleton branch, originating at this node and going towards its neighbour
with the index neighbourIndex, and, if so, moves the current position to this neighbour and
returns true, if not, does nothing and returns false.current pixel is
some branch pixel,
moves the current position to a neighbour along this skeleton branch and returns true.SkeletonScanner.firstStepFromBranch(boolean onlyToUnvisited) moves
when called with the same onlyToUnvisited argument.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)flushResources(context, false).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.freeResources(context, false).constructor.freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, 0, length()), forcePhysicalWriting).subArray(fromIndex, toIndex).freeResources(context, forcePhysicalWriting)freeResources(context, false).Matrix.array().freeResources(context).Matrix.array().freeResources(null).Array.freeResources(context) /
Matrix.freeResources(context) methods for them.Matrix.freeResources(null) for the matrix,
contained in this frame.DataBuffer.fromIndex(), if DataBuffer.fromIndex()<=Integer.MAX_VALUE,
or throws DataBufferIndexOverflowException in other case.Func interface
allowing assigning values to the function result, that leads to
corresponding correction of arguments.memoryModel.newMatrix(UpdatablePArray.class,src)functionOfPercentilePair(dest,src,percentileIndexes1,percentileIndexes2,pattern,processingFunc)functionOfPercentilePair(src,m1,m2,pattern,processingFunc), where
constantPercentileMatrix(src,percentileIndex1)constantPercentileMatrix(src,percentileIndex2)functionOfPercentilePair(dest,src,m1,m2,pattern,processingFunc), where
constantPercentileMatrix(src,percentileIndex1)constantPercentileMatrix(src,percentileIndex2)RankMorphology.functionOfPercentilePair(Matrix, Matrix, Matrix, Pattern, Func) method,
but the result matrix will be placed in the dest argument.RankMorphology.functionOfPercentilePair(Matrix, double, double, Pattern, Func) method,
but the result matrix will be placed in the dest argument.memoryModel.newMatrix(UpdatablePArray.class,src)functionOfSum(dest,src,pattern,processingFunc)RankMorphology.functionOfSum(Matrix, Pattern, Func) method,
but the result matrix will be placed in the dest argument.BitArray)
to operation over any primitive type (an algorithm processing PArray).GeneralizedBitProcessing class works: see comments to that class.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(x[0],x[1],x[2],x[3]),
if x.length>=4,
returns get(x[0],x[1],x[2]), if x.length==3,
and throws IndexOutOfBoundsException, if x.length<3.get(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}).getAperture(dimCount, new Pattern[]{pattern},
new boolean[]{inverted}, DependenceApertureBuilder.DEFAULT_ADDITIONAL_SPACE).getAperture(dimCount, new Pattern[]{pattern1, pattern2},
new boolean[]{inverted1, inverted2}, DependenceApertureBuilder.DEFAULT_ADDITIONAL_SPACE).getAperture(dimCount, patterns, inverted, DependenceApertureBuilder.DEFAULT_ADDITIONAL_SPACE).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.Arrays.SystemSettings.getBooleanProperty(String, boolean), which tests
the environment variable instead of the system property.BufferMemoryModel.getByteBuffer(Array) call,
corresponding to the first element of the passed AlgART array.convex hyperpolyhedron,
which is an intersection of m ExternalProcessor.JRE_PATH_PROPERTY_NAME system property or in ExternalProcessor.JRE_PATH_ENV_NAME environment variable,
or the home directory of the currently executed JVM if there is no such property / environment variable.ExternalProcessor.getCustomJREHome() method, allowing to specify some
"name" of JRE, which is added as a suffix to the name of the corresponding system property or
environment variable.ExternalProcessor.JVM_OPTIONS_PROPERTY_NAME system property
or in ExternalProcessor.JVM_OPTIONS_ENV_NAME environment variable, or null
if there is no such property / environment variable.ExternalProcessor.getCustomJVMOptions() method, allowing to specify some
"name" of JRE, which is added as a suffix to the name of the corresponding system property or
environment variable.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).ExternalProcessor.setErrorStream(java.io.OutputStream) method
and used by execute method
for duplication of the error stream of an external program.getPropertyOrEnv(propertyKey,envVarName)), if such file or directory really exists,
throws FileNotFoundException, if it does not exist, or returns
defaultPath if it is not specified.getExistingPathFromPropertyOrEnv(propertyKey,envVarName,null) and
throws FileNotFoundException in a case of null result.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 not a functional array,
calculated on the base of indexes.getInstance(context, ExternalProcessor.getDefaultTempDirectory(), "").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).comments to this class.min(),
range.max(),
in, out.StreamingApertureProcessor object
and the specified continuation mode.Convolution object
and the specified continuation mode.Derivator object
and the specified continuation mode.Convolution object
and the specified processing tiler.getInstance(context, Arrays.SystemSettings.maxTempJavaMemory()).Morphology object
and the specified continuation mode.RankMorphology object
and the specified continuation mode.IterativeOpening.result() method.Morphology object
and the specified processing tiler.RankMorphology object
and the specified processing tiler.Arrays.SystemSettings.getIntProperty(String, int), which reads the number from
the environment variable instead of the system property.is an interpolation view of some AlgART matrix,
returns the interpolation algorithm, used while creating this function.OctupleThinningSkeleton2D algorithm.Quadruple3x5ThinningSkeleton2D algorithm.StrongQuadruple3x5ThinningSkeleton2D algorithm.Arrays.SystemSettings.getLongProperty(String, long), which reads the number from
the environment variable instead of the system property.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.memory model that should be used
for creating any instances of AlgART arrays with some additional settings
(recommendations).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.DefaultContext.getMemoryModel() and returns its result.OctupleThinningSkeleton2D algorithm.ExternalProcessor.setOutputStream(java.io.OutputStream) method
and used by execute method
for duplication of the output stream of an external program.is a continued interpolation
view of an AlgART matrix, return the value used outside the matrix.2-dimensional polygon with the specified coordinates of vertices.Quadruple3x5ThinningSkeleton2D algorithm.OctupleThinningSkeleton2D algorithm.Quadruple3x5ThinningSkeleton2D algorithm.StrongQuadruple3x5ThinningSkeleton2D algorithm.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).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.StrongQuadruple3x5ThinningSkeleton2D algorithm.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().getThreadPoolFactory()
if context!=null
or DefaultThreadPoolFactory.getDefaultThreadPoolFactory()
if context==null.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(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.scanning.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.scanning.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.scanning.ConnectivityType) method, returning the instance, which works correctly
only if all matrix elements with zero and maximal coordinates are zero.isNew() values,
for all underlying arrays of the passed one.is an interpolation view of an AlgART matrix,
returns the reference to this matrix.