org.apache.mahout.math.set.AbstractDoubleSet Maven / Gradle / Ivy
Show all versions of mahout-collections Show documentation
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.mahout.math.set;
import org.apache.mahout.math.function.DoubleProcedure;
import org.apache.mahout.math.list.DoubleArrayList;
public abstract class AbstractDoubleSet extends AbstractSet {
/**
* Returns true if the receiver contains the specified key.
*
* @return true if the receiver contains the specified key.
*/
public boolean contains(final double key) {
return !forEachKey(
new DoubleProcedure() {
@Override
public boolean apply(double iterKey) {
return (key != iterKey);
}
}
);
}
/**
* Returns a deep copy of the receiver; uses clone() and casts the result.
*
* @return a deep copy of the receiver.
*/
public AbstractDoubleSet copy() {
return (AbstractDoubleSet) clone();
}
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof AbstractDoubleSet)) {
return false;
}
final AbstractDoubleSet other = (AbstractDoubleSet) obj;
if (other.size() != size()) {
return false;
}
return
forEachKey(
new DoubleProcedure() {
@Override
public boolean apply(double key) {
return other.contains(key);
}
}
);
}
/**
* Applies a procedure to each key of the receiver, if any. Note: Iterates over the keys in no particular order.
* Subclasses can define a particular order, for example, "sorted by key". All methods which can be expressed
* in terms of this method (most methods can) must guarantee to use the same order defined by this
* method, even if it is no particular order. This is necessary so that, for example, methods keys and
* values will yield association pairs, not two uncorrelated lists.
*
* @param procedure the procedure to be applied. Stops iteration if the procedure returns false, otherwise
* continues.
* @return false if the procedure stopped before all keys where iterated over, true otherwise.
*/
public abstract boolean forEachKey(DoubleProcedure procedure);
/**
* Returns a list filled with all keys contained in the receiver. The returned list has a size that equals
* this.size(). Iteration order is guaranteed to be identical to the order used by method {@link
* #forEachKey(DoubleProcedure)}. This method can be used to iterate over the keys of the receiver.
*
* @return the keys.
*/
public DoubleArrayList keys() {
DoubleArrayList list = new DoubleArrayList(size());
keys(list);
return list;
}
/**
* Fills all keys contained in the receiver into the specified list. Fills the list, starting at index 0. After this
* call returns the specified list has a new size that equals this.size(). Iteration order is guaranteed to
* be identical to the order used by method {@link #forEachKey(DoubleProcedure)}.
*
This method can be used to
* iterate over the keys of the receiver.
*
* @param list the list to be filled, can have any size.
*/
public void keys(final DoubleArrayList list) {
list.clear();
forEachKey(
new DoubleProcedure() {
@Override
public boolean apply(double key) {
list.add(key);
return true;
}
}
);
}
/**
* Associates the given key with the given value. Replaces any old (key,someOtherValue) association, if
* existing.
*
* @param key the key the value shall be associated with.
* @return true if the receiver did not already contain such a key; false if the receiver did
* already contain such a key - the new value has now replaced the formerly associated value.
*/
public abstract boolean add(double key);
/**
* Removes the given key with its associated element from the receiver, if present.
*
* @param key the key to be removed from the receiver.
* @return true if the receiver contained the specified key, false otherwise.
*/
public abstract boolean remove(double key);
/**
* Returns a string representation of the receiver, containing the String representation of each key-value pair,
* sorted ascending by key.
*/
public String toString() {
DoubleArrayList theKeys = keys();
//theKeys.sort();
StringBuilder buf = new StringBuilder();
buf.append('[');
int maxIndex = theKeys.size() - 1;
for (int i = 0; i <= maxIndex; i++) {
double key = theKeys.get(i);
buf.append(String.valueOf(key));
if (i < maxIndex) {
buf.append(", ");
}
}
buf.append(']');
return buf.toString();
}
}