//-------------------------------------------------------------------------
        public virtual double?getRoot(System.Func <double, double> function, double?x)
        {
            ArgChecker.notNull(function, "function");
            ArgChecker.notNull(x, "x");
            DoubleFunction1D f = DoubleFunction1D.from(function);

            return(getRoot(f, f.derivative(), x));
        }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testConversion()
        public virtual void testConversion()
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.function.Function<double, double> f1 = x -> x * x * x + 2 * x * x - 7 * x + 12;
            System.Func <double, double> f1 = x => x * x * x + 2 * x * x - 7 * x + 12;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final DoubleFunction1D f2 = DoubleFunction1D.from(f1);
            DoubleFunction1D f2 = DoubleFunction1D.from(f1);

            for (int i = 0; i < 100; i++)
            {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final double x = Math.random();
                double x = GlobalRandom.NextDouble;
                assertEquals(f2.applyAsDouble(x), F1.applyAsDouble(x), 0);
                assertEquals(f2.derivative().applyAsDouble(x), F1.derivative().applyAsDouble(x), 0);
            }
        }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expectedExceptions = IllegalArgumentException.class) public void testConvertNull()
        public virtual void testConvertNull()
        {
            DoubleFunction1D.from(null);
        }
 /// <summary>
 /// {@inheritDoc} </summary>
 /// <exception cref="MathException"> If the root is not found in 1000 attempts; if the Newton
 ///   step takes the estimate for the root outside the original bounds. </exception>
 public override double?getRoot(System.Func <double, double> function, double?x1, double?x2)
 {
     ArgChecker.notNull(function, "function");
     return(getRoot(DoubleFunction1D.from(function), x1, x2));
 }
 /// <summary>
 /// Uses the function and its derivative. This method uses an initial guess for the root, rather than bounds. </summary>
 /// <param name="function"> The function, not null </param>
 /// <param name="derivative"> The derivative, not null </param>
 /// <param name="x"> The initial guess for the root, not null </param>
 /// <returns> The root </returns>
 /// <exception cref="MathException"> If the root is not found in 1000 attempts. </exception>
 public virtual double?getRoot(System.Func <double, double> function, System.Func <double, double> derivative, double?x)
 {
     return(getRoot(DoubleFunction1D.from(function), DoubleFunction1D.from(derivative), x));
 }
 /// <summary>
 /// Uses the function and its derivative. </summary>
 /// <param name="function"> The function, not null </param>
 /// <param name="derivative"> The derivative, not null </param>
 /// <param name="x1"> The first bound of the root, not null </param>
 /// <param name="x2"> The second bound of the root, not null </param>
 /// <returns> The root </returns>
 /// <exception cref="MathException"> If the root is not found in 1000 attempts; if the Newton
 ///   step takes the estimate for the root outside the original bounds. </exception>
 public virtual double?getRoot(System.Func <double, double> function, System.Func <double, double> derivative, double?x1, double?x2)
 {
     checkInputs(function, x1, x2);
     ArgChecker.notNull(derivative, "derivative");
     return(getRoot(DoubleFunction1D.from(function), DoubleFunction1D.from(derivative), x1, x2));
 }