net.algart.arrays.AbstractDoubleArray Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of algart Show documentation
Show all versions of algart Show documentation
Open-source Java libraries, supporting generalized smart arrays and matrices with elements
of any types, including a wide set of 2D-, 3D- and multidimensional image processing
and other algorithms, working with arrays and matrices.
/*
* The MIT License (MIT)
*
* Copyright (c) 2007-2024 Daniel Alievsky, AlgART Laboratory (http://algart.net)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package net.algart.arrays;
/*Repeat(INCLUDE_FROM_FILE, AbstractFloatArray.java, all)
public(\s+\w+)+\s+(g|s)etDouble(.*?)\n\s*}\s* ==> ;;
\/\*\*\s*(?:\*\s*)?\
* This implementation returns
* value==(double)value ? {@link #indexOf(long, long, double)
* indexOf}(lowIndex, highIndex, (double)value) : -1.
*
* @param lowIndex the low index in the array for search (inclusive).
* @param highIndex the high index in the array for search (exclusive).
* @param value the value to be found.
* @return the index of the first occurrence of this value in this array
* in range lowIndex<=index<highIndex,
* or -1 if this value does not occur in this range.
*/
private long indexOf(long lowIndex, long highIndex, long value) {
return value == (double) value ? indexOf(lowIndex, highIndex, (double) value) : -1;
}
/**
*
* This implementation returns
* value==(double)value ? {@link #lastIndexOf(long, long, double)
* lastIndexOf}(lowIndex, highIndex, (double)value) : -1.
*
* @param lowIndex the low index in the array for search (inclusive).
* @param highIndex the high index in the array for search (exclusive).
* @param value the value to be found.
* @return the index of the last occurrence of this value in this array
* in range lowIndex<=index<highIndex,
* or -1 if this value does not occur in this range.
*/
private long lastIndexOf(long lowIndex, long highIndex, long value) {
return value == (double) value ? lastIndexOf(lowIndex, highIndex, (double) value) : -1;
}
public abstract double getDouble(long index);
/**
* This implementation is based on a loop of calls of {@link #getDouble(long)} method
* from index max(lowIndex,0) until index min({@link #length()},highIndex)-1.
* Please override this method if it's possible to perform the same task more efficiently
* than such a loop.
*
* @param lowIndex the low index in the array for search (inclusive).
* @param highIndex the high index in the array for search (exclusive).
* @param value the value to be found.
* @return the index of the first occurrence of this value in this array
* in range lowIndex<=index<highIndex,
* or -1 if this value does not occur in this range.
*/
public long indexOf(long lowIndex, long highIndex, double value) {
for (long k = Math.max(lowIndex, 0), n = Math.min(length(), highIndex); k < n; k++) {
if (getDouble(k) == value) {
return k;
}
}
return -1;
}
/**
* This implementation is based on a loop of calls of {@link #getDouble(long)} method
* from index min({@link #length()},highIndex)-1 back until index max(lowIndex,0).
* Please override this method if it's possible to perform the same task more efficiently
* than such a loop.
*
* @param lowIndex the low index in the array for search (inclusive).
* @param highIndex the high index in the array for search (exclusive).
* @param value the value to be found.
* @return the index of the last occurrence of this value in this array
* in range lowIndex<=index<highIndex,
* or -1 if this value does not occur in this range.
*/
public long lastIndexOf(long lowIndex, long highIndex, double value) {
for (long k = Math.min(length(), highIndex), low = Math.max(lowIndex, 0); k > low; ) {
// warning: highIndex-1 can be invalid value Long.MAX_VALUE
if (getDouble(--k) == value) {
return k;
}
}
return -1;
}
/**
* This implementation returns true.
* Should be overridden if the inheritor is mutable.
*
* @return true if this instance is immutable.
*/
@Override
public boolean isImmutable() {
return true;
}
/**
* This implementation returns true.
* Should be overridden if the inheritor is resizable
*
* @return true if this instance is unresizable.
*/
@Override
public boolean isUnresizable() {
return true;
}
/**
* This implementation does nothing.
*
* @throws UnallowedMutationError never in this implementation.
*/
@Override
public void checkUnallowedMutation() throws UnallowedMutationError {
}
/**
* This implementation calls {@link #asImmutable()} and returns its result.
*
* @return a trusted immutable view of this array (or a reference to this array if it is already
* trusted immutable).
*/
@Override
public DoubleArray asTrustedImmutable() {
return asImmutable();
}
/**
* This implementation returns this object.
* Should be overridden if the inheritor is mutable.
*
* @return a copy-on-next-write view of this array (or a reference to this array if it is
* immutable or already copy-on-next-write).
*/
@Override
public Array asCopyOnNextWrite() {
return this;
}
/**
* This implementation returns false.
* Should be overridden if the inheritor is mutable.
*
* @return true if this array is in copy-on-next-write mode
*/
@Override
public boolean isCopyOnNextWrite() {
return false;
}
/**
* This implementation returns this object.
* Should be overridden if the inheritor is mutable.
*
* @return an immutable view of this array (or a reference to this array if it is immutable).
*/
@Override
public DoubleArray asImmutable() {
return this;
}
@Override
public MutableDoubleArray mutableClone(MemoryModel memoryModel) {
return (MutableDoubleArray) super.mutableClone(memoryModel);
}
@Override
public UpdatableDoubleArray updatableClone(MemoryModel memoryModel) {
return (UpdatableDoubleArray) super.updatableClone(memoryModel);
}
public double[] ja() {
return (double[]) super.ja();
}
/**
* This implementation calls
* {@link #loadResources(ArrayContext, long, long) loadResources(context, 0, length())}.
*
* @param context the context of execution; can be {@code null}, then it will be ignored.
*/
@Override
public void loadResources(ArrayContext context) {
loadResources(context, 0, length());
}
/**
* This implementation calls
* {@link #flushResources(ArrayContext, long, long, boolean)
* flushResources(context, 0, length(), forcePhysicalWriting)}.
*
* @param context the context of execution; can be {@code null}, then it will be ignored.
* @param forcePhysicalWriting is it necessary to try forcing physical writing all associated resources
* to the external device.
*/
@Override
public void flushResources(ArrayContext context, boolean forcePhysicalWriting) {
flushResources(context, 0, length(), forcePhysicalWriting);
}
/**
* This implementation calls
* {@link #freeResources(ArrayContext, long, long, boolean)
* freeResources(context, 0, length()), forcePhysicalWriting)}.
*
* @param context the context of execution; can be {@code null}, then it will be ignored.
* @param forcePhysicalWriting is it necessary to try forcing physical writing all associated resources
* to the external device.
*/
@Override
public void freeResources(ArrayContext context, boolean forcePhysicalWriting) {
freeResources(context, 0, length(), forcePhysicalWriting);
}
/**
* This method implements all actions that should be performed by
* {@link #subArray subArray}(fromIndex, toIndex).{@link #loadResources(ArrayContext)
* loadResources}(context) call.
* This default implementation calls {@link #loadResources(ArrayContext) loadResources(c)}
* (where c is a necessary {@link ArrayContext#part(long, long, long) part} of the passed context)
* for the corresponding subarray
* of all underlying arrays, passed via the last argument of the constructor,
* if the underlyingArraysAreParallel constructor argument was true,
* or does nothing in other case.
*
* @param context the context of execution; can be {@code null}, then it will be ignored.
* @param fromIndex low endpoint (inclusive) of the subarray that should be loaded.
* @param toIndex high endpoint (exclusive) of the subarray that should be loaded.
* @throws IndexOutOfBoundsException for illegal fromIndex and toIndex
* (fromIndex < 0 || toIndex > length() || fromIndex > toIndex).
*/
protected void loadResources(ArrayContext context, long fromIndex, long toIndex) {
checkSubArrayArguments(fromIndex, toIndex);
if (underlyingArraysAreParallel) {
for (int k = 0; k < underlyingArrays.length; k++) {
underlyingArrays[k].subArray(fromIndex, toIndex).loadResources(
context == null ? null : context.part(k, k + 1, underlyingArrays.length));
}
}
}
/**
* This method implements all actions that should be performed by
* {@link #subArray subArray}(fromIndex, toIndex).{@link #flushResources(ArrayContext, boolean)
* flushResources(context, forcePhysicalWriting)} call.
* This default implementation calls {@link #flushResources(ArrayContext, boolean)
* flushResources(c, forcePhysicalWriting)}
* (where c is a necessary {@link ArrayContext#part(long, long, long) part} of the passed context)
* for the corresponding subarray of all underlying arrays, passed via the last argument of the constructor,
* if the underlyingArraysAreParallel constructor argument was true,
* or for original underlying arrays in other case
* (alike {@link AbstractArray#flushResources(ArrayContext, boolean)}).
*
* @param context the context of execution; can be {@code null}, then it will be ignored.
* @param fromIndex low endpoint (inclusive) of the subarray that should be flushed.
* @param toIndex high endpoint (exclusive) of the subarray that should be flushed.
* @param forcePhysicalWriting is it necessary to try forcing physical writing all associated resources
* to the external device.
* @throws IndexOutOfBoundsException for illegal fromIndex and toIndex
* (fromIndex < 0 || toIndex > length() || fromIndex > toIndex).
*/
protected void flushResources(ArrayContext context, long fromIndex, long toIndex, boolean forcePhysicalWriting) {
checkSubArrayArguments(fromIndex, toIndex);
if (underlyingArraysAreParallel) {
for (int k = 0; k < underlyingArrays.length; k++) {
underlyingArrays[k].subArray(fromIndex, toIndex).flushResources(
context == null ? null : context.part(k, k + 1, underlyingArrays.length),
forcePhysicalWriting);
}
} else {
super.flushResources(context, forcePhysicalWriting);
}
}
/**
* This method implements all actions that should be performed by
* {@link #subArray subArray}(fromIndex, toIndex).{@link #freeResources(ArrayContext, boolean)
* freeResources(context, forcePhysicalWriting)} call.
* This default implementation calls {@link #freeResources(ArrayContext, boolean)
* freeResources(c, forcePhysicalWriting)}
* (where c is a necessary {@link ArrayContext#part(long, long, long) part} of the passed context)
* for the corresponding subarray of all underlying arrays, passed via the last argument of the constructor,
* if the underlyingArraysAreParallel constructor argument was true,
* or for original underlying arrays in other case
* (alike {@link AbstractArray#freeResources(ArrayContext, boolean)}).
*
* @param context the context of execution; can be {@code null}, then it will be ignored.
* @param fromIndex low endpoint (inclusive) of the subarray that should be freed.
* @param toIndex high endpoint (exclusive) of the subarray that should be freed.
* @param forcePhysicalWriting is it necessary to try forcing physical writing all associated resources
* to the external device.
* @throws IndexOutOfBoundsException for illegal fromIndex and toIndex
* (fromIndex < 0 || toIndex > length() || fromIndex > toIndex).
*/
protected void freeResources(ArrayContext context, long fromIndex, long toIndex, boolean forcePhysicalWriting) {
checkSubArrayArguments(fromIndex, toIndex);
if (underlyingArraysAreParallel) {
for (int k = 0; k < underlyingArrays.length; k++) {
underlyingArrays[k].subArray(fromIndex, toIndex).freeResources(
context == null ? null : context.part(k, k + 1, underlyingArrays.length),
forcePhysicalWriting);
}
} else {
super.freeResources(context, forcePhysicalWriting);
}
}
@Override
public String toString() {
return "immutable AlgART array double[" + length + "]" + (underlyingArrays.length == 0 ? "" :
" based on " + underlyingArrays.length + " underlying array" + (underlyingArrays.length > 1 ? "s" : ""));
}
Object javaArrayInternal() {
return null;
}
int javaArrayOffsetInternal() {
return 0;
}
/*Repeat.IncludeEnd*/
public double minPossibleValue(double valueForFloatingPoint) {
return valueForFloatingPoint;
}
public double maxPossibleValue(double valueForFloatingPoint) {
return valueForFloatingPoint;
}
}