using System;
using System.Collections.Generic;

namespace Spo
{
    public struct ResultData
    {
        public readonly double A, B, Left, Right, Functionleft, Functionright;

        public ResultData(double a, double b, double left, double right, double functionleft, double functionright)
        {
            A = a;
            B = b;
            Left = left;
            Right = right;
            Functionleft = functionleft;
            Functionright = functionright;
        }

        public override string ToString()
        {
            return string.Format("{0:f}\t{1:f}\t{2:f}\t{3:f}\t{4:f}\t{5:f}", A, B, Left, Right, Functionleft,
                                 Functionright);
        }
    }

    public abstract class Solver
    {

        protected readonly Func<double, double> Function;
        protected readonly double L;
        protected double A, B, Lambda, Mu;

        public double Result { get; private set; }

        protected Solver(Func<double, double> function, double a, double b, double l)
        {
            Function = function;
            A = a;
            B = b;
            L = l;
        }

        public IEnumerable<ResultData> Solve()
        {
            if (IncorrectData)
                throw new ArgumentException();
            PlaceStartPoints();
            do
            {
                double y1 = Function(Lambda);
                double y2 = Function(Mu);
                yield return new ResultData(A, B, Lambda, Mu, y1, y2);
                if (y1 > y2)
                {
                    A = Lambda;
                    PlaceNewPointsIfGreater();
                }
                else
                {
                    B = Mu;
                    PlaceNewPointsIfLower();
                }
            } while (Condition);
            Result = Middle;
        }

        private double Delta
        {
            get { return B - A; }
        }

        protected double Middle
        {
            get { return (A + B)/2; }
        }

        protected virtual bool IncorrectData
        {
            get { return L < 0; }
        }

        protected virtual bool Condition
        {
            get { return Delta > L; }
        }

        protected abstract void PlaceStartPoints();
        protected abstract void PlaceNewPointsIfGreater();
        protected abstract void PlaceNewPointsIfLower();
    }
}

using System;

namespace Spo
{
    public class GoldenRatio : Solver
    {
        private readonly double k;

        public GoldenRatio(Func<double, double> function, double a, double b, double l)
            : base(function, a, b, l)
        {
            k = (Math.Sqrt(5) - 1)/2;
        }


        protected override void PlaceStartPoints()
        {
            NewLambda();
            NewMu();
        }

        protected override void PlaceNewPointsIfGreater()
        {
            Lambda = Mu;
            NewMu();
        }

        protected override void PlaceNewPointsIfLower()
        {
            Mu = Lambda;
            NewLambda();
        }

        private void NewLambda()
        {
            Lambda = A + (1 - k) * (B - A);
        }

        private void NewMu()
        {
            Mu = A + k*(B - A);
        }
    }
}

let rec dichotomy f a b e l =
    let middle = (a+b)/2.
    let lambda = middle - e
    let mu = middle + e
    if b - a < l then
        middle
    else
    let FLambda = f lambda
    let Fmu = f mu
    if FLambda < Fmu then
        dichotomy f a mu e l
    else
        dichotomy f lambda b e l
let f x = x**2.0
let result = dichotomy f -1. 2. 0.00001 0.0001
printfn "%f" result