// 
// Decompiled by Procyon v0.6.0
// 

package it.unimi.dsi.fastutil.doubles;

import it.unimi.dsi.fastutil.objects.Reference2FloatFunction;
import it.unimi.dsi.fastutil.objects.Reference2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2ReferenceFunction;
import it.unimi.dsi.fastutil.objects.Object2FloatFunction;
import it.unimi.dsi.fastutil.objects.Object2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2ObjectFunction;
import it.unimi.dsi.fastutil.floats.Float2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2FloatFunction;
import it.unimi.dsi.fastutil.chars.Char2FloatFunction;
import it.unimi.dsi.fastutil.chars.Char2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2CharFunction;
import it.unimi.dsi.fastutil.longs.Long2FloatFunction;
import it.unimi.dsi.fastutil.longs.Long2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2LongFunction;
import it.unimi.dsi.fastutil.ints.Int2FloatFunction;
import it.unimi.dsi.fastutil.ints.Int2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2IntFunction;
import it.unimi.dsi.fastutil.shorts.Short2FloatFunction;
import it.unimi.dsi.fastutil.shorts.Short2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2ShortFunction;
import it.unimi.dsi.fastutil.bytes.Byte2FloatFunction;
import it.unimi.dsi.fastutil.bytes.Byte2DoubleFunction;
import it.unimi.dsi.fastutil.floats.Float2ByteFunction;
import java.util.function.DoubleUnaryOperator;
import it.unimi.dsi.fastutil.Function;

@FunctionalInterface
public interface Double2FloatFunction extends Function<Double, Float>, DoubleUnaryOperator
{
    default double applyAsDouble(final double operand) {
        return this.get(operand);
    }
    
    default float put(final double key, final float value) {
        throw new UnsupportedOperationException();
    }
    
    float get(final double p0);
    
    default float getOrDefault(final double key, final float defaultValue) {
        final float v;
        return ((v = this.get(key)) != this.defaultReturnValue() || this.containsKey(key)) ? v : defaultValue;
    }
    
    default float remove(final double key) {
        throw new UnsupportedOperationException();
    }
    
    @Deprecated
    default Float put(final Double key, final Float value) {
        final double k = key;
        final boolean containsKey = this.containsKey(k);
        final float v = this.put(k, (float)value);
        return containsKey ? Float.valueOf(v) : null;
    }
    
    @Deprecated
    default Float get(final Object key) {
        if (key == null) {
            return null;
        }
        final double k = (double)key;
        final float v;
        return ((v = this.get(k)) != this.defaultReturnValue() || this.containsKey(k)) ? Float.valueOf(v) : null;
    }
    
    @Deprecated
    default Float getOrDefault(final Object key, final Float defaultValue) {
        if (key == null) {
            return defaultValue;
        }
        final double k = (double)key;
        final float v = this.get(k);
        return (v != this.defaultReturnValue() || this.containsKey(k)) ? Float.valueOf(v) : defaultValue;
    }
    
    @Deprecated
    default Float remove(final Object key) {
        if (key == null) {
            return null;
        }
        final double k = (double)key;
        return this.containsKey(k) ? Float.valueOf(this.remove(k)) : null;
    }
    
    default boolean containsKey(final double key) {
        return true;
    }
    
    @Deprecated
    default boolean containsKey(final Object key) {
        return key != null && this.containsKey((double)key);
    }
    
    default void defaultReturnValue(final float rv) {
        throw new UnsupportedOperationException();
    }
    
    default float defaultReturnValue() {
        return 0.0f;
    }
    
    @Deprecated
    default <T> java.util.function.Function<T, Float> compose(final java.util.function.Function<? super T, ? extends Double> before) {
        return super.compose((java.util.function.Function<? super T, ?>)before);
    }
    
    @Deprecated
    default <T> java.util.function.Function<Double, T> andThen(final java.util.function.Function<? super Float, ? extends T> after) {
        return super.andThen((java.util.function.Function<? super Object, ? extends T>)after);
    }
    
    default Double2ByteFunction andThenByte(final Float2ByteFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Byte2FloatFunction composeByte(final Byte2DoubleFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Double2ShortFunction andThenShort(final Float2ShortFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Short2FloatFunction composeShort(final Short2DoubleFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Double2IntFunction andThenInt(final Float2IntFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Int2FloatFunction composeInt(final Int2DoubleFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Double2LongFunction andThenLong(final Float2LongFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Long2FloatFunction composeLong(final Long2DoubleFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Double2CharFunction andThenChar(final Float2CharFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Char2FloatFunction composeChar(final Char2DoubleFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Double2FloatFunction andThenFloat(final Float2FloatFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Float2FloatFunction composeFloat(final Float2DoubleFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default Double2DoubleFunction andThenDouble(final Float2DoubleFunction after) {
        return k -> after.get(this.get(k));
    }
    
    default Double2FloatFunction composeDouble(final Double2DoubleFunction before) {
        return k -> this.get(before.get(k));
    }
    
    default <T> Double2ObjectFunction<T> andThenObject(final Float2ObjectFunction<? extends T> after) {
        return (Double2ObjectFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Object2FloatFunction<T> composeObject(final Object2DoubleFunction<? super T> before) {
        return k -> this.get(before.getDouble(k));
    }
    
    default <T> Double2ReferenceFunction<T> andThenReference(final Float2ReferenceFunction<? extends T> after) {
        return (Double2ReferenceFunction<T>)(k -> after.get(this.get(k)));
    }
    
    default <T> Reference2FloatFunction<T> composeReference(final Reference2DoubleFunction<? super T> before) {
        return k -> this.get(before.getDouble(k));
    }
}