package com.acme.math;

import church.lang.ByteStream;
import church.lang.operators.Arithmetic;
import church.lang.operators.Arithmetic.*;
import church.lang.operators.Relational.$$equal;
import church.lang.operators.Relational.$$lte;
import church.lang.operators.Relational.$Max;
import church.lang.operators.Relational.$Min;
import church.lang.operators.Streams.$$encode;
import church.math.Interval;
import church.math.Interval.$Contains;
import church.primitives.Doubles;
import church.primitives.Integers;
import church.primitives.Objects;

import static church.lang.operators.Streams.output;
import static church.math.Interval.interval;

@SuppressWarnings("unchecked")
public class IntervalTest {
    private static final $$encode<ByteStream, String>                $S0  = Objects::$encode;
    private static final $$encode<ByteStream, Integer>               $S1  = Integers::$encode;
    private static final $$encode<ByteStream, Interval<Integer>>     $S2  = Interval.$encode($S0, $S1);
    private static final $Min<Integer>                               $S3  = Integers::min;
    private static final $$prd<Integer, Integer>                     $S4  = Integers::$prd;
    private static final $Max<Integer>                               $S5  = Integers::max;
    private static final $$prd<Interval<Integer>, Interval<Integer>> $S6  = Interval.$prd($S3, $S4, $S5);
    private static final $$equal<Integer>                            $S7  = Integers::$equal;
    private static final $$equal<Interval<Integer>>                  $S8  = Interval.$equal($S7);
    private static final $$encode<ByteStream, Double>                $S9  = Doubles::$encode;
    private static final $$encode<ByteStream, Interval<Double>>      $S10 = Interval.$encode($S0, $S9);
    private static final $$lte<Double>                               $S11 = Doubles::$lte;
    private static final $Contains<Double>                           $S12 = Interval.contains($S11);
    private static final $Additive_identity<Double>                  $S13 = Doubles::additive_identity;
    private static final $Min_value<Double>                          $S14 = Doubles::min_value;
    private static final $Max_value<Double>                          $S15 = Doubles::max_value;
    private static final $$rcp<Double>                               $S16 = Doubles::$rcp;
    private static final $$rcp<Interval<Double>>                     $S17 = Interval.$rcp($S12, $S13, $S14, $S15, $S16);
    private static final $Min<Double>                                $S18 = Doubles::min;
    private static final $$prd<Double, Double>                       $S19 = Doubles::$prd;
    private static final $Max<Double>                                $S20 = Doubles::max;
    private static final $$prd<Interval<Double>, Interval<Double>>   $S21 = Interval.$prd($S18, $S19, $S20);
    private static final $$div<Interval<Double>, Interval<Double>>   $S22 = Arithmetic.$div($S21, $S17);

    public static int spam(int x, int y) {
        return ((x + y) + 7);
    }

    public static void main(String[] args) {
        Interval<Integer> i1 = interval(1, 2);
        Interval<Integer> i2 = interval(3, 4);
        $S0.$encode($S2.$encode(output, $S6.$prd(i1, i2)), "\n");
        assert $S8.$equal($S6.$prd(i1, i2), interval(3, 8));
        Interval<Double> i3 = interval(2.0, 4.0);
        $S0.$encode($S10.$encode(output, $S17.$rcp(i3)), "\n");
        Interval<Double> i4 = interval(-1.0, 2.0);
        $S0.$encode($S10.$encode(output, $S22.$div(i4, i3)), "\n");
        $S0.$encode($S10.$encode(output, $S22.$div(i3, i4)), "\n");
    }

}