All Downloads are FREE. Search and download functionalities are using the official Maven repository.

it.unimi.dsi.fastutil.doubles.DoubleBigArrayBigList Maven / Gradle / Ivy

The newest version!
/*
	* Copyright (C) 2002-2017 Sebastiano Vigna
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	*     http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
package it.unimi.dsi.fastutil.doubles;
import java.util.Collection;
import java.util.Iterator;
import java.util.RandomAccess;
import java.util.NoSuchElementException;
import it.unimi.dsi.fastutil.BigArrays;
/** A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
	*
	* 

This class implements a lightweight, fast, open, optimized, * reuse-oriented version of big-array-based big lists. Instances of this class * represent a big list with a big array that is enlarged as needed when new entries * are created (by doubling the current length), but is * never made smaller (even on a {@link #clear()}). A family of * {@linkplain #trim() trimming methods} lets you control the size of the * backing big array; this is particularly useful if you reuse instances of this class. * Range checks are equivalent to those of {@link java.util}'s classes, but * they are delayed as much as possible. The backing big array is exposed by the * {@link #elements()} method. * *

This class implements the bulk methods removeElements(), * addElements() and getElements() using * high-performance system calls (e.g., {@link * System#arraycopy(Object,int,Object,int,int) System.arraycopy()} instead of * expensive loops. * * @see java.util.ArrayList */ public class DoubleBigArrayBigList extends AbstractDoubleBigList implements RandomAccess, Cloneable, java.io.Serializable { private static final long serialVersionUID = -7046029254386353130L; /** The initial default capacity of a big-array big list. */ public final static int DEFAULT_INITIAL_CAPACITY = 16; /** The backing big array. */ protected transient double a[][]; /** The current actual size of the big list (never greater than the backing-array length). */ protected long size; private static final boolean ASSERTS = false; /** Creates a new big-array big list using a given array. * *

This constructor is only meant to be used by the wrapping methods. * * @param a the big array that will be used to back this big-array big list. */ protected DoubleBigArrayBigList(final double a[][], boolean dummy) { this.a = a; } /** Creates a new big-array big list with given capacity. * * @param capacity the initial capacity of the array list (may be 0). */ public DoubleBigArrayBigList(final long capacity) { if (capacity < 0) throw new IllegalArgumentException("Initial capacity (" + capacity + ") is negative"); a = DoubleBigArrays.newBigArray(capacity); } /** Creates a new big-array big list with {@link #DEFAULT_INITIAL_CAPACITY} capacity. */ public DoubleBigArrayBigList() { this(DEFAULT_INITIAL_CAPACITY); } /** Creates a new big-array big list and fills it with a given type-specific collection. * * @param c a type-specific collection that will be used to fill the array list. */ public DoubleBigArrayBigList(final DoubleCollection c) { this(c.size()); for(DoubleIterator i = c.iterator(); i.hasNext();) add(i.nextDouble()); } /** Creates a new big-array big list and fills it with a given type-specific list. * * @param l a type-specific list that will be used to fill the array list. */ public DoubleBigArrayBigList(final DoubleBigList l) { this(l.size64()); l.getElements(0, a, 0, size = l.size64()); } /** Creates a new big-array big list and fills it with the elements of a given big array. * *

Note that this constructor makes it easy to build big lists from literal arrays * declared as type[][] {{ init_values }}. * The only constraint is that the number of initialisation values is * below {@link it.unimi.dsi.fastutil.BigArrays#SEGMENT_SIZE}. * * @param a a big array whose elements will be used to fill the array list. */ public DoubleBigArrayBigList(final double a[][]) { this(a, 0, DoubleBigArrays.length(a)); } /** Creates a new big-array big list and fills it with the elements of a given big array. * *

Note that this constructor makes it easy to build big lists from literal arrays * declared as type[][] {{ init_values }}. * The only constraint is that the number of initialisation values is * below {@link it.unimi.dsi.fastutil.BigArrays#SEGMENT_SIZE}. * * @param a a big array whose elements will be used to fill the array list. * @param offset the first element to use. * @param length the number of elements to use. */ public DoubleBigArrayBigList(final double a[][], final long offset, final long length) { this(length); DoubleBigArrays.copy(a, offset, this.a, 0, length); size = length; } /** Creates a new big-array big list and fills it with the elements returned by an iterator.. * * @param i an iterator whose returned elements will fill the array list. */ public DoubleBigArrayBigList(final Iterator i) { this(); while(i.hasNext()) this.add(((i.next()).doubleValue())); } /** Creates a new big-array big list and fills it with the elements returned by a type-specific iterator.. * * @param i a type-specific iterator whose returned elements will fill the array list. */ public DoubleBigArrayBigList(final DoubleIterator i) { this(); while(i.hasNext()) this.add(i.nextDouble()); } /** Returns the backing big array of this big list. * * @return the backing big array. */ public double[][] elements() { return a; } /** Wraps a given big array into a big-array list of given size. * * @param a a big array to wrap. * @param length the length of the resulting big-array list. * @return a new big-array list of the given size, wrapping the given big array. */ public static DoubleBigArrayBigList wrap(final double a[][], final long length) { if (length > DoubleBigArrays.length(a)) throw new IllegalArgumentException("The specified length (" + length + ") is greater than the array size (" + DoubleBigArrays.length(a) + ")"); final DoubleBigArrayBigList l = new DoubleBigArrayBigList (a, false); l.size = length; return l; } /** Wraps a given big array into a big-array big list. * * @param a a big array to wrap. * @return a new big-array big list wrapping the given array. */ public static DoubleBigArrayBigList wrap(final double a[][]) { return wrap(a, DoubleBigArrays.length(a)); } /** Ensures that this big-array big list can contain the given number of entries without resizing. * * @param capacity the new minimum capacity for this big-array big list. */ public void ensureCapacity(final long capacity) { a = DoubleBigArrays.ensureCapacity(a, capacity, size); if (ASSERTS) assert size <= DoubleBigArrays.length(a); } /** Grows this big-array big list, ensuring that it can contain the given number of entries without resizing, * and in case enlarging it at least by a factor of two. * * @param capacity the new minimum capacity for this big-array big list. */ private void grow(final long capacity) { a = DoubleBigArrays.grow(a, capacity, size); if (ASSERTS) assert size <= DoubleBigArrays.length(a); } @Override public void add(final long index, final double k) { ensureIndex(index); grow(size + 1); if (index != size) DoubleBigArrays.copy(a, index, a, index + 1, size - index); DoubleBigArrays.set(a, index, k); size++; if (ASSERTS) assert size <= DoubleBigArrays.length(a); } @Override public boolean add(final double k) { grow(size + 1); DoubleBigArrays.set(a, size++, k); if (ASSERTS) assert size <= DoubleBigArrays.length(a); return true; } @Override public double getDouble(final long index) { if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than or equal to list size (" + size + ")"); return DoubleBigArrays.get(a, index); } @Override public long indexOf(final double k) { for(long i = 0; i < size; i++) if (( Double.doubleToLongBits(k) == Double.doubleToLongBits(DoubleBigArrays.get(a, i)) )) return i; return -1; } @Override public long lastIndexOf(final double k) { for(long i = size; i-- != 0;) if (( Double.doubleToLongBits(k) == Double.doubleToLongBits(DoubleBigArrays.get(a, i)) )) return i; return -1; } @Override public double removeDouble(final long index) { if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than or equal to list size (" + size + ")"); final double old = DoubleBigArrays.get(a, index); size--; if (index != size) DoubleBigArrays.copy(a, index + 1, a, index, size - index); if (ASSERTS) assert size <= DoubleBigArrays.length(a); return old; } @Override public boolean rem(final double k) { final long index = indexOf(k); if (index == -1) return false; removeDouble(index); if (ASSERTS) assert size <= DoubleBigArrays.length(a); return true; } @Override public double set(final long index, final double k) { if (index >= size) throw new IndexOutOfBoundsException("Index (" + index + ") is greater than or equal to list size (" + size + ")"); double old = DoubleBigArrays.get(a, index); DoubleBigArrays.set(a, index, k); return old; } @Override public boolean removeAll(final DoubleCollection c) { double[] s = null, d = null; int ss = -1, sd = BigArrays.SEGMENT_SIZE, ds = -1, dd = BigArrays.SEGMENT_SIZE; for (long i = 0; i < size; i++) { if (sd == BigArrays.SEGMENT_SIZE) { sd = 0; s = a[++ss]; } if (!c.contains(s[sd])) { if (dd == BigArrays.SEGMENT_SIZE) { d = a[++ds]; dd = 0; } d[dd++] = s[sd]; } sd++; } final long j = BigArrays.index(ds, dd); final boolean modified = size != j; size = j; return modified; } @Override public boolean removeAll(final Collection c) { double[] s = null, d = null; int ss = -1, sd = BigArrays.SEGMENT_SIZE, ds = -1, dd = BigArrays.SEGMENT_SIZE; for (long i = 0; i < size; i++) { if (sd == BigArrays.SEGMENT_SIZE) { sd = 0; s = a[++ss]; } if (!c.contains((Double.valueOf(s[sd])))) { if (dd == BigArrays.SEGMENT_SIZE) { d = a[++ds]; dd = 0; } d[dd++] = s[sd]; } sd++; } final long j = BigArrays.index(ds, dd); final boolean modified = size != j; size = j; return modified; } @Override public void clear() { size = 0; if (ASSERTS) assert size <= DoubleBigArrays.length(a); } @Override public long size64() { return size; } @Override public void size(final long size) { if (size > DoubleBigArrays.length(a)) ensureCapacity(size); if (size > this.size) DoubleBigArrays.fill(a, this.size, size, (0)); this.size = size; } @Override public boolean isEmpty() { return size == 0; } /** Trims this big-array big list so that the capacity is equal to the size. * * @see java.util.ArrayList#trimToSize() */ public void trim() { trim(0); } /** Trims the backing big array if it is too large. * * If the current big array length is smaller than or equal to * n, this method does nothing. Otherwise, it trims the * big-array length to the maximum between n and {@link #size64()}. * *

This method is useful when reusing big lists. {@linkplain #clear() Clearing a * big list} leaves the big-array length untouched. If you are reusing a big list * many times, you can call this method with a typical * size to avoid keeping around a very large big array just * because of a few large transient big lists. * * @param n the threshold for the trimming. */ public void trim(final long n) { final long arrayLength = DoubleBigArrays.length(a); if (n >= arrayLength || size == arrayLength) return; a = DoubleBigArrays.trim(a, Math.max(n, size)); if (ASSERTS) assert size <= DoubleBigArrays.length(a); } /** Copies element of this type-specific list into the given big array using optimized system calls. * * @param from the start index (inclusive). * @param a the destination big array. * @param offset the offset into the destination array where to store the first element copied. * @param length the number of elements to be copied. */ @Override public void getElements(final long from, final double[][] a, final long offset, final long length) { DoubleBigArrays.copy(this.a, from, a, offset, length); } /** Removes elements of this type-specific list using optimized system calls. * * @param from the start index (inclusive). * @param to the end index (exclusive). */ @Override public void removeElements(final long from, final long to) { BigArrays.ensureFromTo(size, from, to); DoubleBigArrays.copy(a, to, a, from, size - to); size -= (to - from); } /** Adds elements to this type-specific list using optimized system calls. * * @param index the index at which to add elements. * @param a the big array containing the elements. * @param offset the offset of the first element to add. * @param length the number of elements to add. */ @Override public void addElements(final long index, final double a[][], final long offset, final long length) { ensureIndex(index); DoubleBigArrays.ensureOffsetLength(a, offset, length); grow(size + length); DoubleBigArrays.copy(this.a, index, this.a, index + length, size - index); DoubleBigArrays.copy(a, offset, this.a, index, length); size += length; } @Override public DoubleBigListIterator listIterator(final long index) { ensureIndex(index); return new AbstractDoubleBigListIterator () { long pos = index, last = -1; public boolean hasNext() { return pos < size; } public boolean hasPrevious() { return pos > 0; } public double nextDouble() { if (! hasNext()) throw new NoSuchElementException(); return DoubleBigArrays.get(a, last = pos++); } public double previousDouble() { if (! hasPrevious()) throw new NoSuchElementException(); return DoubleBigArrays.get(a, last = --pos); } public long nextIndex() { return pos; } public long previousIndex() { return pos - 1; } public void add(double k) { DoubleBigArrayBigList.this.add(pos++, k); last = -1; } public void set(double k) { if (last == -1) throw new IllegalStateException(); DoubleBigArrayBigList.this.set(last, k); } public void remove() { if (last == -1) throw new IllegalStateException(); DoubleBigArrayBigList.this.removeDouble(last); /* If the last operation was a next(), we are removing an element *before* us, and we must decrease pos correspondingly. */ if (last < pos) pos--; last = -1; } }; } @Override public DoubleBigArrayBigList clone() { DoubleBigArrayBigList c = new DoubleBigArrayBigList (size); DoubleBigArrays.copy(a, 0, c.a, 0, size); c.size = size; return c; } /** Compares this type-specific big-array list to another one. * *

This method exists only for sake of efficiency. The implementation * inherited from the abstract implementation would already work. * * @param l a type-specific big-array list. * @return true if the argument contains the same elements of this type-specific big-array list. */ public boolean equals(final DoubleBigArrayBigList l) { if (l == this) return true; long s = size64(); if (s != l.size64()) return false; final double[][] a1 = a; final double[][] a2 = l.a; while(s-- != 0) if (DoubleBigArrays.get(a1, s) != DoubleBigArrays.get(a2, s)) return false; return true; } /** Compares this big list to another big list. * *

This method exists only for sake of efficiency. The implementation * inherited from the abstract implementation would already work. * * @param l a big list. * @return a negative integer, * zero, or a positive integer as this big list is lexicographically less than, equal * to, or greater than the argument. */ public int compareTo(final DoubleBigArrayBigList l) { final long s1 = size64(), s2 = l.size64(); final double a1[][] = a, a2[][] = l.a; double e1, e2; int r, i; for(i = 0; i < s1 && i < s2; i++) { e1 = DoubleBigArrays.get(a1, i); e2 = DoubleBigArrays.get(a2, i); if ((r = ( Double.compare((e1),(e2)) )) != 0) return r; } return i < s2 ? -1 : (i < s1 ? 1 : 0); } private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { s.defaultWriteObject(); for(int i = 0; i < size; i++) s.writeDouble(DoubleBigArrays.get(a, i)); } private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); a = DoubleBigArrays.newBigArray(size); for(int i = 0; i < size; i++) DoubleBigArrays.set(a, i, s.readDouble()); } }





© 2015 - 2025 Weber Informatics LLC | Privacy Policy