Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
Java library for reading and writing FITS files. FITS, the Flexible Image Transport System, is the format commonly used in the archiving and transport of astronomical data.
/*
* #%L
* nom.tam FITS library
* %%
* Copyright (C) 1996 - 2024 nom-tam-fits
* %%
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* 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 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.
* #L%
*/
package nom.tam.util.array;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
/**
* @deprecated (for internal use) use {@link MultiArrayCopier} instead. Make copies of
* multi-dimensional arrays.
*
* @param The generic type of array from which we want to copy elements
* @param The generic type of array to which we want to copy elements.
*/
@Deprecated
@SuppressFBWarnings(value = "SING_SINGLETON_HAS_NONPRIVATE_CONSTRUCTOR", justification = "warning persists despite private constructor")
public class MultiArrayCopyFactory {
private MultiArrayCopyFactory() {
}
private static final class ByteToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(byte[] src, int srcPos, char[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static final class ByteToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(byte[] src, int srcPos, double[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class ByteToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(byte[] src, int srcPos, float[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class ByteToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(byte[] src, int srcPos, int[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class ByteToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(byte[] src, int srcPos, long[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class ByteToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(byte[] src, int srcPos, short[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class CharToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(char[] src, int srcPos, byte[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static final class CharToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(char[] src, int srcPos, double[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class CharToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(char[] src, int srcPos, float[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class CharToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(char[] src, int srcPos, int[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class CharToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(char[] src, int srcPos, long[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class CharToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(char[] src, int srcPos, short[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) src[index + srcPos];
}
}
}
private static final class DoubleToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(double[] src, int srcPos, byte[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) Math.round(src[index + srcPos]);
}
}
}
private static final class DoubleToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(double[] src, int srcPos, char[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) Math.round(src[index + srcPos]);
}
}
}
private static final class DoubleToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(double[] src, int srcPos, float[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (float) src[index + srcPos];
}
}
}
private static final class DoubleToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(double[] src, int srcPos, int[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (int) Math.round(src[index + srcPos]);
}
}
}
private static final class DoubleToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(double[] src, int srcPos, long[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = Math.round(src[index + srcPos]);
}
}
}
private static final class DoubleToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(double[] src, int srcPos, short[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) Math.round(src[index + srcPos]);
}
}
}
private static final class FloatToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(float[] src, int srcPos, byte[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) Math.round(src[index + srcPos]);
}
}
}
private static final class FloatToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(float[] src, int srcPos, char[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) Math.round(src[index + srcPos]);
}
}
}
private static final class FloatToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(float[] src, int srcPos, double[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class FloatToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(float[] src, int srcPos, int[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = Math.round(src[index + srcPos]);
}
}
}
private static final class FloatToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(float[] src, int srcPos, long[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = Math.round(src[index + srcPos]);
}
}
}
private static final class FloatToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(float[] src, int srcPos, short[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) Math.round(src[index + srcPos]);
}
}
}
private static final class Generic extends MultiArrayCopyFactory {
@Override
public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
System.arraycopy(srcO, srcPos, destO, destPos, length);
}
}
private static final class IntToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(int[] src, int srcPos, byte[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static final class IntToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(int[] src, int srcPos, char[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static final class IntToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(int[] src, int srcPos, double[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class IntToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(int[] src, int srcPos, float[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class IntToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(int[] src, int srcPos, long[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class IntToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(int[] src, int srcPos, short[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) src[index + srcPos];
}
}
}
private static final class LongToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(long[] src, int srcPos, byte[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static final class LongToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(long[] src, int srcPos, char[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static final class LongToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(long[] src, int srcPos, double[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class LongToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(long[] src, int srcPos, float[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class LongToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(long[] src, int srcPos, int[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (int) src[index + srcPos];
}
}
}
private static final class LongToShort extends MultiArrayCopyFactory {
@Override
public void arraycopy(long[] src, int srcPos, short[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (short) src[index + srcPos];
}
}
}
private static final class ShortToByte extends MultiArrayCopyFactory {
@Override
public void arraycopy(short[] src, int srcPos, byte[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (byte) src[index + srcPos];
}
}
}
private static final class ShortToChar extends MultiArrayCopyFactory {
@Override
public void arraycopy(short[] src, int srcPos, char[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = (char) src[index + srcPos];
}
}
}
private static final class ShortToDouble extends MultiArrayCopyFactory {
@Override
public void arraycopy(short[] src, int srcPos, double[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class ShortToFloat extends MultiArrayCopyFactory {
@Override
public void arraycopy(short[] src, int srcPos, float[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class ShortToInt extends MultiArrayCopyFactory {
@Override
public void arraycopy(short[] src, int srcPos, int[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final class ShortToLong extends MultiArrayCopyFactory {
@Override
public void arraycopy(short[] src, int srcPos, long[] dest, int destPos, int length) {
for (int index = 0; index < length; index++) {
dest[index + destPos] = src[index + srcPos];
}
}
}
private static final Map, Map, MultiArrayCopyFactory>> FACTORIES;
private static final MultiArrayCopyFactory GENERIC = new Generic();
static {
Map, Map, MultiArrayCopyFactory>> factories = new HashMap<>();
Map, MultiArrayCopyFactory> byteMap = new HashMap<>();
byteMap.put(byte.class, new MultiArrayCopyFactory<>());
byteMap.put(char.class, new ByteToChar());
byteMap.put(short.class, new ByteToShort());
byteMap.put(int.class, new ByteToInt());
byteMap.put(long.class, new ByteToLong());
byteMap.put(float.class, new ByteToFloat());
byteMap.put(double.class, new ByteToDouble());
factories.put(byte.class, Collections.unmodifiableMap(byteMap));
Map, MultiArrayCopyFactory> charMap = new HashMap<>();
charMap.put(byte.class, new CharToByte());
charMap.put(char.class, new MultiArrayCopyFactory<>());
charMap.put(short.class, new CharToShort());
charMap.put(int.class, new CharToInt());
charMap.put(long.class, new CharToLong());
charMap.put(float.class, new CharToFloat());
charMap.put(double.class, new CharToDouble());
factories.put(char.class, Collections.unmodifiableMap(charMap));
Map, MultiArrayCopyFactory> shortMap = new HashMap<>();
shortMap.put(byte.class, new ShortToByte());
shortMap.put(char.class, new ShortToChar());
shortMap.put(short.class, new MultiArrayCopyFactory<>());
shortMap.put(int.class, new ShortToInt());
shortMap.put(long.class, new ShortToLong());
shortMap.put(float.class, new ShortToFloat());
shortMap.put(double.class, new ShortToDouble());
factories.put(short.class, Collections.unmodifiableMap(shortMap));
Map, MultiArrayCopyFactory> intMap = new HashMap<>();
intMap.put(byte.class, new IntToByte());
intMap.put(char.class, new IntToChar());
intMap.put(short.class, new IntToShort());
intMap.put(int.class, new MultiArrayCopyFactory<>());
intMap.put(long.class, new IntToLong());
intMap.put(float.class, new IntToFloat());
intMap.put(double.class, new IntToDouble());
factories.put(int.class, Collections.unmodifiableMap(intMap));
Map, MultiArrayCopyFactory> longMap = new HashMap<>();
longMap.put(byte.class, new LongToByte());
longMap.put(char.class, new LongToChar());
longMap.put(short.class, new LongToShort());
longMap.put(int.class, new LongToInt());
longMap.put(long.class, new MultiArrayCopyFactory<>());
longMap.put(float.class, new LongToFloat());
longMap.put(double.class, new LongToDouble());
factories.put(long.class, Collections.unmodifiableMap(longMap));
Map, MultiArrayCopyFactory> floatMap = new HashMap<>();
floatMap.put(byte.class, new FloatToByte());
floatMap.put(char.class, new FloatToChar());
floatMap.put(short.class, new FloatToShort());
floatMap.put(int.class, new FloatToInt());
floatMap.put(long.class, new FloatToLong());
floatMap.put(float.class, new MultiArrayCopyFactory<>());
floatMap.put(double.class, new FloatToDouble());
factories.put(float.class, Collections.unmodifiableMap(floatMap));
Map, MultiArrayCopyFactory> doubleMap = new HashMap<>();
doubleMap.put(byte.class, new DoubleToByte());
doubleMap.put(char.class, new DoubleToChar());
doubleMap.put(short.class, new DoubleToShort());
doubleMap.put(int.class, new DoubleToInt());
doubleMap.put(long.class, new DoubleToLong());
doubleMap.put(float.class, new DoubleToFloat());
doubleMap.put(double.class, new MultiArrayCopyFactory<>());
factories.put(double.class, Collections.unmodifiableMap(doubleMap));
FACTORIES = Collections.unmodifiableMap(factories);
}
/**
* @deprecated for internal use only. This ought to be private.
*
* @param primitiveType the primitive class of the elements in the source array
* @param primitiveType2 the primitive class of the elements in the destination array
*
* @return A suitable copier instance.
*/
public static synchronized MultiArrayCopyFactory select(Class primitiveType, Class primitiveType2) {
Map, MultiArrayCopyFactory> from = MultiArrayCopyFactory.FACTORIES.get(primitiveType);
if (from != null) {
MultiArrayCopyFactory to = from.get(primitiveType2);
if (to != null) {
return to;
}
}
return MultiArrayCopyFactory.GENERIC;
}
/**
* See {@link System#arraycopy(Object, int, Object, int, int)}.
*
* @param src the source array
* @param srcPos starting position in the source array
* @param dest the destination array
* @param destPos starting position in the destonation array
* @param length the number of elements to copy
*/
public void arraycopy(Source src, int srcPos, Destination dest, int destPos, int length) {
System.arraycopy(src, srcPos, dest, destPos, length);
}
}
