build(CppAD): brought in CppAD for autodiff

we need an autodiff library at some point (or we need to roll our own but I do not think that makes sense). CppAD is well tested and header only and easy to include. It is also Liscene compatible with GPL v3.0. Here we bring it in as a dependency

build-config/cppad/include/cppad/utility/check_simple_vector.hpp

@@ -0,0 +1,199 @@
+# ifndef CPPAD_UTILITY_CHECK_SIMPLE_VECTOR_HPP
+# define CPPAD_UTILITY_CHECK_SIMPLE_VECTOR_HPP
+/* --------------------------------------------------------------------------
+CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-20 Bradley M. Bell
+
+CppAD is distributed under the terms of the
+             Eclipse Public License Version 2.0.
+
+This Source Code may also be made available under the following
+Secondary License when the conditions for such availability set forth
+in the Eclipse Public License, Version 2.0 are satisfied:
+      GNU General Public License, Version 2.0 or later.
+---------------------------------------------------------------------------- */
+/*
+$begin CheckSimpleVector$$
+$spell
+    alloc
+    const
+    cppad.hpp
+    CppAD
+$$
+
+$section Check Simple Vector Concept$$
+
+
+$head Syntax$$
+$codei%# include <cppad/utility/check_simple_vector.hpp>
+%$$
+$codei%CheckSimpleVector<%Scalar%, %Vector%>()%$$
+$pre
+$$
+$codei%CheckSimpleVector<%Scalar%, %Vector%>(%x%, %y%)%$$
+
+
+$head Purpose$$
+Preforms compile and run time checks that the type specified
+by $icode Vector$$ satisfies all the requirements for
+a $cref SimpleVector$$ class with
+$cref/elements of type/SimpleVector/Elements of Specified Type/$$
+$icode Scalar$$.
+If a requirement is not satisfied,
+a an error message makes it clear what condition is not satisfied.
+
+$head x, y$$
+If the arguments $icode x$$ and $icode y$$ are present,
+they have prototype
+$codei%
+    const %Scalar%& %x%
+    const %Scalar%& %y%
+%$$
+In addition, the check
+$codei%
+    %x% == %x%
+%$$
+will return the boolean value $code true$$, and
+$codei%
+    %x% == %y%
+%$$
+will return $code false$$.
+
+$head Restrictions$$
+If the arguments $icode x$$ and $icode y$$ are not present,
+the following extra assumption is made by $code CheckSimpleVector$$:
+If $icode x$$ is a $icode Scalar$$ object
+$codei%
+    %x% = 0
+    %y% = 1
+%$$
+assigns values to the objects $icode x$$ and $icode y$$.
+In addition,
+$icode%x% == %x%$$ would return the boolean value $code true$$ and
+$icode%x% == %y%$$ would return $code false$$.
+
+$head Include$$
+The file $code cppad/utility/check_simple_vector.hpp$$
+is included by $code cppad/cppad.hpp$$
+but it can also be included separately with out the rest
+if the CppAD include files.
+
+$head Parallel Mode$$
+The routine $cref/thread_alloc::parallel_setup/ta_parallel_setup/$$
+must be called before it
+can be used in $cref/parallel/ta_in_parallel/$$ mode.
+
+$head Example$$
+$children%
+    example/utility/check_simple_vector.cpp
+%$$
+The file $cref check_simple_vector.cpp$$
+contains an example and test of this function where $icode S$$
+is the same as $icode T$$.
+The comments in this example suggest a way to change the example
+so $icode S$$ is not the same as $icode T$$.
+
+$end
+---------------------------------------------------------------------------
+*/
+
+# include <cstddef>
+# include <cppad/core/cppad_assert.hpp>
+# include <cppad/local/define.hpp>
+# include <cppad/utility/thread_alloc.hpp>
+
+namespace CppAD {
+
+# ifdef NDEBUG
+    template <class Scalar, class Vector>
+    inline void CheckSimpleVector(const Scalar& x, const Scalar& y)
+    { }
+    template <class Scalar, class Vector>
+    inline void CheckSimpleVector(void)
+    { }
+# else
+    template <class S, class T>
+    struct ok_if_S_same_as_T { };
+
+    template <class T>
+    struct ok_if_S_same_as_T<T,T> { T value; };
+
+    template <class Scalar, class Vector>
+    void CheckSimpleVector(const Scalar& x, const Scalar& y)
+    {   CPPAD_ASSERT_FIRST_CALL_NOT_PARALLEL
+        static size_t count;
+        if( count > 0  )
+            return;
+        count++;
+
+        // value_type must be type of elements of Vector
+        typedef typename Vector::value_type value_type;
+
+        // check that elements of Vector have type Scalar
+        struct ok_if_S_same_as_T<Scalar, value_type> x_copy;
+        x_copy.value = x;
+
+        // check default constructor
+        Vector d;
+
+        // size member function
+        CPPAD_ASSERT_KNOWN(
+            d.size() == 0,
+            "default construtor result does not have size zero"
+        );
+
+        // resize to same size as other vectors in test
+        d.resize(1);
+
+        // check sizing constructor
+        Vector s(1);
+
+        // check element assignment
+        s[0] = y;
+        CPPAD_ASSERT_KNOWN(
+            s[0] == y,
+            "element assignment failed"
+        );
+
+        // check copy constructor
+        s[0] = x_copy.value;
+        const Vector c(s);
+        s[0] = y;
+        CPPAD_ASSERT_KNOWN(
+            c[0] == x,
+            "copy constructor is shallow"
+        );
+
+        // vector assignment operator
+        d[0] = x;
+        s    = d;
+        s[0] = y;
+        CPPAD_ASSERT_KNOWN(
+            d[0] == x,
+            "assignment operator is shallow"
+        );
+
+        // element access, right side const
+        // element assignment, left side not const
+        d[0] = c[0];
+        CPPAD_ASSERT_KNOWN(
+            d[0] == x,
+            "element assignment from const failed"
+        );
+    }
+    template <class Scalar, class Vector>
+    void CheckSimpleVector(void)
+    {   Scalar x;
+        Scalar y;
+
+        // use assignment and not constructor
+        x = 0;
+        y = 1;
+
+        CheckSimpleVector<Scalar, Vector>(x, y);
+    }
+
+# endif
+
+} // end namespace CppAD
+
+# endif