/*
 * Copyright (c) 2018 Goldman Sachs and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Eclipse Distribution License v. 1.0 which accompany this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 */

package org.eclipse.collections.api.list.primitive;

import org.eclipse.collections.api.DoubleIterable;
import org.eclipse.collections.api.block.function.primitive.DoubleIntToObjectFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleToObjectFunction;
import org.eclipse.collections.api.block.predicate.primitive.DoublePredicate;
import org.eclipse.collections.api.block.procedure.primitive.DoubleProcedure;
import org.eclipse.collections.api.list.ListIterable;
import org.eclipse.collections.api.ordered.primitive.ReversibleDoubleIterable;
import org.eclipse.collections.api.tuple.primitive.DoubleDoublePair;
import org.eclipse.collections.api.tuple.primitive.DoubleObjectPair;

This file was automatically generated from template file primitiveList.stg.
Since:
3.0./**
 * This file was automatically generated from template file primitiveList.stg.
 *
 * @since 3.0.
 */
public interface DoubleList extends ReversibleDoubleIterable
{
    double get(int index);

    double dotProduct(DoubleList list);

    int binarySearch(double value);

    int lastIndexOf(double value);

    @Override
    DoubleList select(DoublePredicate predicate);

    @Override
    DoubleList reject(DoublePredicate predicate);

    
Since:
9.0./**
     * @since 9.0.
     */
    @Override
    default DoubleList tap(DoubleProcedure procedure)
    {
        this.forEach(procedure);
        return this;
    }

    @Override
    <V> ListIterable<V> collect(DoubleToObjectFunction<? extends V> function);

    
Returns a new ListIterable using results obtained by applying the specified function to each element
and its corresponding index.
Since:
9.1./**
     * Returns a new ListIterable using results obtained by applying the specified function to each element
     * and its corresponding index.
     *
     * @since 9.1.
     */
    @Override
    default <V> ListIterable<V> collectWithIndex(DoubleIntToObjectFunction<? extends V> function)
    {
        int[] index = { 0 };
        return this.collect(each -> function.value(each, index[0]++));
    }

    
Follows the same general contract as List.equals(Object). /**
     * Follows the same general contract as {@link java.util.List#equals(Object)}.
     */
    @Override
    boolean equals(Object o);

    
Follows the same general contract as List.hashCode(). /**
     * Follows the same general contract as {@link java.util.List#hashCode()}.
     */
    @Override
    int hashCode();

    
Returns an immutable copy of this list. If the list is immutable, it returns itself.
/**
     * Returns an immutable copy of this list. If the list is immutable, it returns itself.
     */
    ImmutableDoubleList toImmutable();

    
Since:
6.0./**
     * @since 6.0.
     */
    @Override
    DoubleList distinct();

    
Since:
5.0./**
     * @since 5.0.
     */
    @Override
    DoubleList toReversed();

    
See Also:
subList.subList(int fromIndex, int toIndex)
Since:
5.0./**
     * @see java.util.List#subList(int fromIndex, int toIndex)
     * @since 5.0.
     */
    DoubleList subList(int fromIndex, int toIndex);

    
Returns a ListIterable formed from this DoubleList and another DoubleList by combining corresponding elements in pairs. If one of the two DoubleLists is longer than the other, its remaining elements are ignored. 
Since:
9.1./**
     * Returns a {@code ListIterable} formed from this {@code DoubleList} and another {@code DoubleList} by
     * combining corresponding elements in pairs. If one of the two {@code DoubleList}s is longer than the other, its
     * remaining elements are ignored.
     *
     * @since 9.1.
     */
    default ListIterable<DoubleDoublePair> zipDouble(DoubleIterable iterable)
    {
        throw new UnsupportedOperationException("Default method to prevent breaking backwards compatibility");
    }

    
Returns a ListIterable formed from this DoubleList and a ListIterable by combining corresponding elements in pairs. If one of the two Lists is longer than the other, its remaining elements are ignored. 
Since:
9.1./**
     * Returns a {@code ListIterable} formed from this {@code DoubleList} and a {@code ListIterable} by
     * combining corresponding elements in pairs. If one of the two Lists is longer than the other, its
     * remaining elements are ignored.
     *
     * @since 9.1.
     */
    default <T> ListIterable<DoubleObjectPair<T>> zip(Iterable<T> iterable)
    {
        throw new UnsupportedOperationException("Default method to prevent breaking backwards compatibility");
    }
}