using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Azimuth;
using Azimuth.RootFinding;

namespace Azimuth.UnitTests.RootFinding
{
    public class BruteForceBracketerTests : UnitTestSharp.TestFixture
    {
        public void BracketRoot()
        {
            Func<Scalar, Scalar> function = x => x * x - 1;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, -1.01, function, derivative, 1000, ref iterations);

            Check(rightBound.Value >= -1);
            CheckEqual(BruteForceBracketer.BracketResult.ROOT_BRACKETED, success);
        }

        public void LocalMinima()
        {
            Func<Scalar, Scalar> function = x => x * x;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, -0.01, function, derivative, 1000, ref iterations);

            Check(rightBound.Value >= 0);
            CheckEqual(BruteForceBracketer.BracketResult.LOCAL_EXTREMA_BRACKETED, success);
        }

        public void InitialGuessIsRoot()
        {
            Func<Scalar, Scalar> function = x => x * x;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, 0, function, derivative, 1000, ref iterations);

            Check(rightBound.Value >= 0);
            CheckEqual(BruteForceBracketer.BracketResult.ROOT_BRACKETED, success);
        }

        public void InitialGuessIsExtrema()
        {
            Func<Scalar, Scalar> function = x => x * x - 1;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, 0, function, derivative, 1000, ref iterations);

            Check(rightBound.Value == 0);
            CheckEqual(BruteForceBracketer.BracketResult.LOCAL_EXTREMA_BRACKETED, success);
        }

        public void StumbleUponRoot()
        {
            Func<Scalar, Scalar> function = x => x * x - 1;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, -1 - Scalar.FuzzyEqualityEpsilon, function, derivative, 1000, ref iterations);

            Check(rightBound.Value == -1);
            CheckEqual(BruteForceBracketer.BracketResult.ROOT_BRACKETED, success);
        }

        public void StumbleUponExtrema()
        {
            Func<Scalar, Scalar> function = x => x * x + 1;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, -Scalar.FuzzyEqualityEpsilon, function, derivative, 1000, ref iterations);

            Check(rightBound.Value == 0);
            CheckEqual(BruteForceBracketer.BracketResult.LOCAL_EXTREMA_BRACKETED, success);
        }

        public void MovingInWrongDirection()
        {
            Func<Scalar, Scalar> function = x => x * x - 1;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, -.5, function, derivative, 1000, ref iterations);

            Check(Scalar.IsNaN(rightBound));
            CheckEqual(BruteForceBracketer.BracketResult.MALFORMED_INPUT, success);
        }

        public void BoundsExceeded()
        {
            Func<Scalar, Scalar> function = x => x * x - 1;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, -20.5, function, derivative, 1000, ref iterations);

            Check(Scalar.IsNaN(rightBound));
            CheckEqual(BruteForceBracketer.BracketResult.BOUNDS_EXCEEDED, success);
        }

        public void MaxIterationsExceeded()
        {
            Func<Scalar, Scalar> function = x => x * x - 1;
            Func<Scalar, Scalar> derivative = x => 2 * x;

            Scalar rightBound;
            int iterations = 0;
            var success = BruteForceBracketer.BracketRoot(out rightBound, -2.5, function, derivative, 10, ref iterations);

            Check(Scalar.IsNaN(rightBound));
            CheckEqual(BruteForceBracketer.BracketResult.MAX_ITERATIONS_EXCEEDED, success);
        }
    }
}