SignalCollection

java.lang.Object
- agi.foundation.communications.SignalCollection

All Implemented Interfaces:

Iterable<Signal>, Collection<Signal>
```
public class SignalCollection
extends Object
implements Collection<Signal>
```
An immutable collection of constituent signals, which represents a composite signal.

Constructor Summary

Constructors
Constructor and Description
`SignalCollection()` Create a new empty instance.
`SignalCollection(Collection<Signal> signals)` Create a new instance which consists of a set of signals.
`SignalCollection(Iterable<? extends SignalCollection> signalCollections)` Create a new instance based on combining an existing set of signal collections.
`SignalCollection(Signal... signals)` Create a new instance which consists of the provided signals.
`SignalCollection(Signal signal)` Create a new instance which consists of a single signal.
`SignalCollection(SignalCollection... signals)` Create a new instance based on combining an existing set of signal collections.
`SignalCollection(SignalCollection existingInstance)` Initializes a new instance as a copy of an existing instance.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`__remove(Signal item)`
`boolean`	`add(Signal item)` Ensures that this collection contains the specified element (optional operation).
`boolean`	`addAll(Collection<? extends Signal> c)` Adds all of the elements in the specified collection to this collection (optional operation).
`SignalCollection`	`addNoiseTemperature(double noiseTemperature)` Creates a new collection of signals by increasing the noise temperature for each signal.
`SignalCollection`	`addSignals(Iterable<? extends Signal> signals)` Creates a new `SignalCollection` by adding signals.
`SignalCollection`	`addSignals(Signal... signals)` Creates a new `SignalCollection` by adding signals.
`SignalCollection`	`applyFrequencyShift(double frequencyShiftFactor)` Create a new composite signal by shifting the frequency of the constituents of this signal.
`SignalCollection`	`applyGain(double gain)` Create a new composite signal by applying a gain to this composite signal.
`void`	`clear()` Removes all of the elements from this collection (optional operation).
`double`	`computeTotalPower()` Computes the total sum of the power of the individual signals.
`boolean`	`contains(Object item)` Search to determine whether the given signal is an element of the composite signal.
`boolean`	`containsAll(Collection<?> c)` Returns `true` if this collection contains all of the elements in the specified collection.
`void`	`copyTo(Signal[] array, int arrayIndex)` Copy the constituent signals to the given array, starting at the given index.
`boolean`	`equals(Object obj)` Indicates whether another object is exactly equal to this instance.
`boolean`	`equals(SignalCollection other)` Indicates whether this collection of signals is equivalent to another collection of signals.
`Signal`	`find(Predicate<Signal> match)` Searches for a signal that matches the conditions defined by the specified predicate, and returns the first occurrence within the collection.
`Signal`	`get(int index)` Gets the constituent signal at the given index.
`int`	`hashCode()` Returns a hash code for this instance, which is suitable for use in hashing algorithms and data structures like a hash table.
`int`	`indexOf(Signal signal)` Searches for the specified signal and returns the zero-based index of the first occurrence within the collection.
`boolean`	`isEmpty()` Returns `true` if this collection contains no elements.
`Iterator<Signal>`	`iterator()` Get an enumerator for the signals in the collections.
`SignalCollection`	`modifySignals(double gain, double frequencyShiftFactor)` Create a new composite signal by uniformly modifying the power and frequency of the existing constituent signals.
`SignalCollection`	`modifySignals(SignalModificationMethod changeSignal)` Create a new composite signal by modifying the existing constituent signals and removing any which are null.
`SignalCollection`	`modifySignalsWithoutRemoval(SignalModificationMethod changeSignal)` Create a new composite signal by modifying the existing constituent signals.
`boolean`	`remove(Object item)` Removes a single instance of the specified element from this collection, if it is present (optional operation).
`boolean`	`removeAll(Collection<?> c)` Removes all of this collection's elements that are also contained in the specified collection (optional operation).
`SignalCollection`	`removeSignals(Predicate<Signal> match)` Creates a new `SignalCollection` by removing signals based on a predicate.
`boolean`	`retainAll(Collection<?> c)` Retains only the elements in this collection that are contained in the specified collection (optional operation).
`SignalCollection`	`selectSignals(Predicate<Signal> match)` Creates a new `SignalCollection` by selecting signals based on a predicate.
`int`	`size()` Gets the number of constituent signals in the composite signal.
`Object[]`	`toArray()` Returns an array containing all of the elements in this collection.
`<T> T[]`	`toArray(T[] a)` Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.
`boolean`	`trueForAll(Predicate<Signal> match)` Determines whether every signal in the collection matches the conditions defined by the specified predicate.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Collection
parallelStream, removeIf, spliterator, stream

Methods inherited from interface java.lang.Iterable
forEach

- Constructor Detail
  - SignalCollection
```
public SignalCollection()
```
    Create a new empty instance.
  - SignalCollection
```
public SignalCollection(@Nonnull
                        SignalCollection existingInstance)
```
    Initializes a new instance as a copy of an existing instance.
    
    Parameters:
    
    existingInstance - The existing instance to copy.
    
    Throws:
    
    ArgumentNullException - Thrown when existingInstance is null.
  - SignalCollection
```
public SignalCollection(@Nonnull
                        Signal signal)
```
    Create a new instance which consists of a single signal.
    
    Parameters:
    
    signal - The single signal.
    
    Throws:
    
    ArgumentNullException - Thrown when signal is null.
  - SignalCollection
```
public SignalCollection(@Nonnull
                        Collection<Signal> signals)
```
    Create a new instance which consists of a set of signals.
    
    Parameters:
    
    signals - The set of signals contained in this composite.
    
    Throws:
    
    ArgumentNullException - Thrown when signals is null, or when any of the contained signals is null.
  - SignalCollection
```
public SignalCollection(@Nonnull
                        Signal... signals)
```
    Create a new instance which consists of the provided signals.
    
    Parameters:
    
    signals - The parameterized array of signals contained in this composite.
  - SignalCollection
```
public SignalCollection(@Nonnull
                        SignalCollection... signals)
```
    Create a new instance based on combining an existing set of signal collections.
    
    Parameters:
    
    signals - The set of signals contained in this composite.
  - SignalCollection
```
public SignalCollection(@Nonnull
                        Iterable<? extends SignalCollection> signalCollections)
```
    Create a new instance based on combining an existing set of signal collections.
    
    Parameters:
    
    signalCollections - The existing signal collections to combine.
    
    Throws:
    
    ArgumentNullException - Thrown when signalCollections is null, or when any item in signalCollections is null.
- Method Detail
  - addSignals
```
@Nonnull
public final SignalCollection addSignals(@Nonnull
                                                   Signal... signals)
```
    Creates a new SignalCollection by adding signals.
    
    Parameters:
    
    signals - A set of signals to add.
    
    Returns:
    
    The new collection of signals.
    
    Throws:
    
    ArgumentNullException - Thrown when signals is null, or when any of the contained signals is null.
  - addSignals
```
@Nonnull
public final SignalCollection addSignals(@Nonnull
                                                   Iterable<? extends Signal> signals)
```
    Creates a new SignalCollection by adding signals.
    
    Parameters:
    
    signals - A set of signals to add.
    
    Returns:
    
    The new collection of signals.
    
    Throws:
    
    ArgumentNullException - Thrown when signals is null, or when any of the contained signals is null.
  - removeSignals
```
@Nonnull
public final SignalCollection removeSignals(@Nonnull
                                                      Predicate<Signal> match)
```
    Creates a new SignalCollection by removing signals based on a predicate.
    
    Parameters:
    
    match - A delegate defining the conditions on a Signal which will remove it from the new collection.
    
    Returns:
    
    The new collection of signals.
    
    Throws:
    
    ArgumentNullException - Thrown when match is null.
  - selectSignals
```
@Nonnull
public final SignalCollection selectSignals(@Nonnull
                                                      Predicate<Signal> match)
```
    Creates a new SignalCollection by selecting signals based on a predicate.
    
    Parameters:
    
    match - A delegate defining the conditions on a Signal which will add it to the new collection.
    
    Returns:
    
    The new collection of signals.
    
    Throws:
    
    ArgumentNullException - Thrown when match is null.
  - applyGain
```
@Nonnull
public final SignalCollection applyGain(double gain)
```
    Create a new composite signal by applying a gain to this composite signal.
    
    Parameters:
    
    gain - The gain to apply to all constituent signals in this composite signal.
    
    Returns:
    
    The new composite signal after applying the gain.
  - applyFrequencyShift
```
@Nonnull
public final SignalCollection applyFrequencyShift(double frequencyShiftFactor)
```
    Create a new composite signal by shifting the frequency of the constituents of this signal.
    The new frequency is the old frequency multiplied by the shift factor.
    
    Parameters:
    
    frequencyShiftFactor - The multiplicative frequency shift to apply to all constituent signals in this signal.
    
    Returns:
    
    The new composite signal after shifting the frequency.
  - modifySignals
```
@Nonnull
public final SignalCollection modifySignals(double gain,
                                                      double frequencyShiftFactor)
```
    Create a new composite signal by uniformly modifying the power and frequency of the existing constituent signals.
    
    Parameters:
    
    gain - The gain to apply to the power of each signal.
    
    frequencyShiftFactor - The multiplicative frequency shift to apply to each signal.
    
    Returns:
    
    The new composite signal after applying the modifications.
  - modifySignals
```
@Nonnull
public final SignalCollection modifySignals(@Nonnull
                                                      SignalModificationMethod changeSignal)
```
    Create a new composite signal by modifying the existing constituent signals and removing any which are null.
    
    Parameters:
    
    changeSignal - A user-defined method to modify each of the constituent signals. If the modification method returns null for a given signal, that signal will be removed.
    
    Returns:
    
    The new composite signal after applying the modifications.
  - modifySignalsWithoutRemoval
```
@Nonnull
public final SignalCollection modifySignalsWithoutRemoval(@Nonnull
                                                                    SignalModificationMethod changeSignal)
```
    Create a new composite signal by modifying the existing constituent signals.
    This method is slightly faster than SignalCollection.modifySignals(SignalModificationMethod) since this does not have to check for null.
    
    Parameters:
    
    changeSignal - A user-defined method to modify each of the constituent signals.
    
    Returns:
    
    The new composite signal after applying the modifications.
  - addNoiseTemperature
```
@Nonnull
public final SignalCollection addNoiseTemperature(double noiseTemperature)
```
    Creates a new collection of signals by increasing the noise temperature for each signal.
    
    Parameters:
    
    noiseTemperature - The noise temperature to add, in kelvin.
    
    Returns:
    
    The new collection of signals.
  - computeTotalPower
```
public final double computeTotalPower()
```
    Computes the total sum of the power of the individual signals.
    
    Returns:
    
    The sum of the power of each signal in this collection.
  - iterator
```
public final Iterator<Signal> iterator()
```
    Get an enumerator for the signals in the collections.
    
    Specified by:
    
    iterator in interface Iterable<Signal>
    
    Specified by:
    
    iterator in interface Collection<Signal>
    
    Returns:
    
    The enumerator.
  - contains
```
public final boolean contains(Object item)
```
    Search to determine whether the given signal is an element of the composite signal.
    
    Specified by:
    
    contains in interface Collection<Signal>
    
    Parameters:
    
    item - The signal for which to search.
    
    Returns:
    
    true if the signal is part of the composite; otherwise false.
  - copyTo
```
public final void copyTo(Signal[] array,
                         int arrayIndex)
```
    Copy the constituent signals to the given array, starting at the given index.
    
    Parameters:
    
    array - The one-dimensional, zero-indexed array which is the destination of the copy.
    
    arrayIndex - The zero-indexed index at which to start the copy.
    
    Throws:
    
    ArgumentNullException - array is null.
    
    ArgumentOutOfRangeException - arrayIndex is less than zero.
    
    ArgumentException - array is multidimensional.-or-arrayIndex is equal to or greater than the length of array.-or-The number of elements in the source Collection is greater than the available space from arrayIndex to the end of the destination array.-or-Type T cannot be cast automatically to the type of the destination array.
  - size
```
public final int size()
```
    Gets the number of constituent signals in the composite signal.
    
    Specified by:
    
    size in interface Collection<Signal>
    
    Returns:
    
    the number of elements in this collection
  - get
```
@Nonnull
public final Signal get(int index)
```
    Gets the constituent signal at the given index.
    
    Parameters:
    
    index - The index of the signal to retrieve.
    
    Returns:
    
    The requested signal.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when the index is less than zero or not less than Count (get).
  - indexOf
```
public final int indexOf(Signal signal)
```
    Searches for the specified signal and returns the zero-based index of the first occurrence within the collection.
    
    Parameters:
    
    signal - The signal to locate in the collection.
    
    Returns:
    
    The zero-based index of the first occurrence of the given signal within the collection, if found; otherwise -1.
  - find
```
@Nonnull
public final Signal find(@Nonnull
                                   Predicate<Signal> match)
```
    Searches for a signal that matches the conditions defined by the specified predicate, and returns the first occurrence within the collection.
    
    Parameters:
    
    match - The delegate that defines the conditions of the signal to search for.
    
    Returns:
    
    The first element that matches the conditions defined by the specified predicate, if found; otherwise BaseSignal (get).
  - trueForAll
```
public final boolean trueForAll(@Nonnull
                                Predicate<Signal> match)
```
    Determines whether every signal in the collection matches the conditions defined by the specified predicate.
    
    Parameters:
    
    match - The delegate defining the conditions to check against.
    
    Returns:
    
    true if every signal in the collection matches the conditions defined by the specified predicate, or if the list has no elements; otherwise false.
  - add
```
public final boolean add(Signal item)
```
    Description copied from interface: java.util.Collection
    
    Ensures that this collection contains the specified element (optional operation). Returns true if this collection changed as a result of the call. (Returns false if this collection does not permit duplicates and already contains the specified element.)
    Collections that support this operation may place limitations on what elements may be added to this collection. In particular, some collections will refuse to add null elements, and others will impose restrictions on the type of elements that may be added. Collection classes should clearly specify in their documentation any restrictions on what elements may be added.
    If a collection refuses to add a particular element for any reason other than that it already contains the element, it must throw an exception (rather than returning false). This preserves the invariant that a collection always contains the specified element after this call returns.
    
    Specified by:
    
    add in interface Collection<Signal>
    
    Parameters:
    
    item - element whose presence in this collection is to be ensured
    
    Returns:
    
    true if this collection changed as a result of the call
  - clear
```
public final void clear()
```
    Description copied from interface: java.util.Collection
    
    Removes all of the elements from this collection (optional operation). The collection will be empty after this method returns.
    
    Specified by:
    
    clear in interface Collection<Signal>
  - remove
```
public final boolean remove(Object item)
```
    Description copied from interface: java.util.Collection
    
    Removes a single instance of the specified element from this collection, if it is present (optional operation). More formally, removes an element e such that (o==null ? e==null : o.equals(e)), if this collection contains one or more such elements. Returns true if this collection contained the specified element (or equivalently, if this collection changed as a result of the call).
    
    Specified by:
    
    remove in interface Collection<Signal>
    
    Parameters:
    
    item - element to be removed from this collection, if present
    
    Returns:
    
    true if an element was removed as a result of this call
  - __remove
```
public final boolean __remove(Signal item)
```
  - equals
```
public boolean equals(Object obj)
```
    Indicates whether another object is exactly equal to this instance.
    
    Specified by:
    
    equals in interface Collection<Signal>
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    obj - The object to compare to this instance.
    
    Returns:
    
    true if obj is an instance of this type and represents the same value as this instance; otherwise false.
    
    See Also:
    
    Object.hashCode(), HashMap
  - equals
```
public final boolean equals(SignalCollection other)
```
    Indicates whether this collection of signals is equivalent to another collection of signals.
    
    Parameters:
    
    other - The other collection of signals.
    
    Returns:
    
    true if each of the signals in other is equal to the corresponding signal in this collection; otherwise false.
  - hashCode
```
public int hashCode()
```
    Returns a hash code for this instance, which is suitable for use in hashing algorithms and data structures like a hash table.
    
    Specified by:
    
    hashCode in interface Collection<Signal>
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    A hash code for the current object.
    
    See Also:
    
    Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)
  - isEmpty
```
public final boolean isEmpty()
```
    Description copied from interface: java.util.Collection
    
    Returns true if this collection contains no elements.
    
    Specified by:
    
    isEmpty in interface Collection<Signal>
    
    Returns:
    
    true if this collection contains no elements
  - addAll
```
public final boolean addAll(Collection<? extends Signal> c)
```
    Description copied from interface: java.util.Collection
    
    Adds all of the elements in the specified collection to this collection (optional operation). The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified collection is this collection, and this collection is nonempty.)
    
    Specified by:
    
    addAll in interface Collection<Signal>
    
    Parameters:
    
    c - collection containing elements to be added to this collection
    
    Returns:
    
    true if this collection changed as a result of the call
    
    See Also:
    
    Collection.add(Object)
  - containsAll
```
public final boolean containsAll(Collection<?> c)
```
    Description copied from interface: java.util.Collection
    
    Returns true if this collection contains all of the elements in the specified collection.
    
    Specified by:
    
    containsAll in interface Collection<Signal>
    
    Parameters:
    
    c - collection to be checked for containment in this collection
    
    Returns:
    
    true if this collection contains all of the elements in the specified collection
    
    See Also:
    
    Collection.contains(Object)
  - toArray
```
public final Object[] toArray()
```
    Description copied from interface: java.util.Collection
    
    Returns an array containing all of the elements in this collection. If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.
    The returned array will be "safe" in that no references to it are maintained by this collection. (In other words, this method must allocate a new array even if this collection is backed by an array). The caller is thus free to modify the returned array.
    This method acts as bridge between array-based and collection-based APIs.
    
    Specified by:
    
    toArray in interface Collection<Signal>
    
    Returns:
    
    an array containing all of the elements in this collection
  - toArray
```
public final <T> T[] toArray(T[] a)
```
    Description copied from interface: java.util.Collection
    Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. If the collection fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this collection.
    If this collection fits in the specified array with room to spare (i.e., the array has more elements than this collection), the element in the array immediately following the end of the collection is set to null. (This is useful in determining the length of this collection only if the caller knows that this collection does not contain any null elements.)
    If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.
    Like the Collection.toArray() method, this method acts as bridge between array-based and collection-based APIs. Further, this method allows precise control over the runtime type of the output array, and may, under certain circumstances, be used to save allocation costs.
    Suppose x is a collection known to contain only strings. The following code can be used to dump the collection into a newly allocated array of String:
```
     String[] y = x.toArray(new String[0]);
```
    Note that toArray(new Object[0]) is identical in function to toArray().
    Specified by:
    
    toArray in interface Collection<Signal>
    
    Type Parameters:
    
    T - the runtime type of the array to contain the collection
    
    Parameters:
    
    a - the array into which the elements of this collection are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.
    
    Returns:
    
    an array containing all of the elements in this collection
  - removeAll
```
public final boolean removeAll(Collection<?> c)
```
    Description copied from interface: java.util.Collection
    
    Removes all of this collection's elements that are also contained in the specified collection (optional operation). After this call returns, this collection will contain no elements in common with the specified collection.
    
    Specified by:
    
    removeAll in interface Collection<Signal>
    
    Parameters:
    
    c - collection containing elements to be removed from this collection
    
    Returns:
    
    true if this collection changed as a result of the call
    
    See Also:
    
    Collection.remove(Object), Collection.contains(Object)
  - retainAll
```
public final boolean retainAll(Collection<?> c)
```
    Description copied from interface: java.util.Collection
    
    Retains only the elements in this collection that are contained in the specified collection (optional operation). In other words, removes from this collection all of its elements that are not contained in the specified collection.
    
    Specified by:
    
    retainAll in interface Collection<Signal>
    
    Parameters:
    
    c - collection containing elements to be retained in this collection
    
    Returns:
    
    true if this collection changed as a result of the call
    
    See Also:
    
    Collection.remove(Object), Collection.contains(Object)

Class SignalCollection

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Constructor Detail

SignalCollection

SignalCollection

SignalCollection

SignalCollection

SignalCollection

SignalCollection

Method Detail

addSignals

addSignals

removeSignals

selectSignals

applyGain

applyFrequencyShift

modifySignals

modifySignals

modifySignalsWithoutRemoval

addNoiseTemperature

computeTotalPower

iterator

contains

copyTo

size

get

indexOf

find

trueForAll

add

clear

remove

__remove

equals

equals

hashCode

isEmpty

addAll

containsAll

toArray

toArray

removeAll

retainAll