Custom implementation of numpy in C++. More...

Typedefs
typedef double	ndArrayValue

Enumerations
enum	indexing { xy , ij }

Functions
template<std::size_t ND>
boost::multi_array< ndArrayValue, ND >::index	getIndex (const boost::multi_array< ndArrayValue, ND > &m, const ndArrayValue *requestedElement, const unsigned short int direction)
	Gets the index of one element in a multi_array in one axis.

template<std::size_t ND>
boost::array< typename boost::multi_array< ndArrayValue, ND >::index, ND >	getIndexArray (const boost::multi_array< ndArrayValue, ND > &m, const ndArrayValue *requestedElement)
	Gets the index of one element in a multi_array.

template<typename Array , typename Element , typename Functor >
void	for_each (const boost::type< Element > &type_dispatch, Array A, Functor &xform)

template<typename Element , typename Functor >
void	for_each (const boost::type< Element > &, Element &Val, Functor &xform)
	Function to apply a function to all elements of a multi_array.

template<typename Element , typename Iterator , typename Functor >
void	for_each (const boost::type< Element > &type_dispatch, Iterator begin, Iterator end, Functor &xform)
	Function to apply a function to all elements of a multi_array.

template<typename Array , typename Functor >
void	for_each (Array &A, Functor xform)

template<typename T , long unsigned int ND> requires std::is_floating_point<T>
::value constexpr std::vector< boost::multi_array< T, ND > >	gradient (boost::multi_array< T, ND > inArray, std::initializer_list< T > args)

boost::multi_array< double, 1 >	linspace (double start, double stop, long unsigned int num)
	Implements the numpy linspace function.

template<typename T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr std::vector< boost::multi_array< T, ND > >	meshgrid (const boost::multi_array< T, 1 >(&cinput)[ND], bool sparsing=false, indexing indexing_type=xy)

template<class T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr boost::multi_array< T, ND >	element_wise_apply (const boost::multi_array< T, ND > &input_array, std::function< T(T)> func)
	Creates a new array and fills it with the values of the result of the function called on the input array element-wise.

template<class T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr boost::multi_array< T, ND >	sqrt (const boost::multi_array< T, ND > &input_array)
	Implements the numpy sqrt function on multi arrays.

template<class T > requires std::is_arithmetic<T>
::value constexpr T	sqrt (const T input)
	Implements the numpy sqrt function on scalars.

template<class T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr boost::multi_array< T, ND >	exp (const boost::multi_array< T, ND > &input_array)
	Implements the numpy exp function on multi arrays.

template<class T > requires std::is_arithmetic<T>
::value constexpr T	exp (const T input)
	Implements the numpy exp function on scalars.

template<class T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr boost::multi_array< T, ND >	log (const boost::multi_array< T, ND > &input_array)
	Implements the numpy log function on multi arrays.

template<class T > requires std::is_arithmetic<T>
::value constexpr T	log (const T input)
	Implements the numpy log function on scalars.

template<class T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr boost::multi_array< T, ND >	pow (const boost::multi_array< T, ND > &input_array, const T exponent)
	Implements the numpy pow function on multi arrays.

template<class T > requires std::is_arithmetic<T>
::value constexpr T	pow (const T input, const T exponent)
	Implements the numpy pow function on scalars.

template<class T , long unsigned int ND>
constexpr boost::multi_array< T, ND >	element_wise_duo_apply (boost::multi_array< T, ND > const &lhs, boost::multi_array< T, ND > const &rhs, std::function< T(T, T)> func)

template<typename T , typename inT , long unsigned int ND> requires std::is_integral<inT>
::value &&std::is_arithmetic< T >::value constexpr boost::multi_array< T, ND >	zeros (inT(&dimensions_input)[ND])
	Implements the numpy zeros function for an n-dimensionl multi array.

template<typename T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr T	max (boost::multi_array< T, ND > const &input_array)
	Implements the numpy max function for an n-dimensionl multi array.

template<class T , class... Ts, class = std::enable_if_t<(std::is_same_v<T, Ts> && ...)>> requires std::is_arithmetic<T>
::value constexpr T	max (T input1, Ts... inputs)
	Implements the numpy max function for an variadic number of arguments.

template<typename T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr T	min (boost::multi_array< T, ND > const &input_array)
	Implements the numpy min function for an n-dimensionl multi array.

template<class T , class... Ts, class = std::enable_if_t<(std::is_same_v<T, Ts> && ...)>> requires std::is_arithmetic<T>
constexpr T	min (T input1, Ts... inputs)
	Implements the numpy min function for an variadic number of arguments.

template<typename T > requires std::is_arithmetic<T>
::value constexpr T	abs (T input)
	Implements the numpy abs function for a scalar.

template<typename T , long unsigned int ND> requires std::is_arithmetic<T>
::value constexpr boost::multi_array< T, ND - 1 >	slice (boost::multi_array< T, ND > const &input_array, std::size_t slice_index)
	Slices the array through one dimension and returns a ND - 1 dimensional array.

matplot::vector_2d	convert_to_matplot (const boost::multi_array< double, 2 > &arr)
	Convert a 2D boost::multi_array to a matplot::vector_2d.

Detailed Description

Custom implementation of numpy in C++.

Typedef Documentation

◆ ndArrayValue

typedef double np::ndArrayValue

Definition at line 22 of file np.hpp.

Enumeration Type Documentation

◆ indexing

enum np::indexing

Definition at line 172 of file np.hpp.

    {
        xy,
        ij
    };

Function Documentation

◆ abs()

template<typename T >
requires std::is_arithmetic<T>

::value constexpr T np::abs ( T input )

inlineconstexpr

Implements the numpy abs function for a scalar.

Definition at line 463 of file np.hpp.

    {
        return std::abs(input);
    }

◆ element_wise_apply()

template<class T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr boost::multi_array< T, ND > np::element_wise_apply	(	const boost::multi_array< T, ND > &	input_array,
		std::function< T(T)>	func
	)

inlineconstexpr

Creates a new array and fills it with the values of the result of the function called on the input array element-wise.

Definition at line 243 of file np.hpp.

    {
 
        // Create output array copying extents
        using arrayIndex = boost::multi_array<double, ND>::index;
        using ndIndexArray = boost::array<arrayIndex, ND>;
        boost::detail::multi_array::extent_gen<ND> output_extents;
        std::vector<size_t> shape_list;
        for (std::size_t i = 0; i < ND; i++)
        {
            shape_list.push_back(input_array.shape()[i]);
        }
        std::copy(shape_list.begin(), shape_list.end(), output_extents.ranges_.begin());
        boost::multi_array<T, ND> output_array(output_extents);
 
        // Looping through the elements of the output array
        const T *p = input_array.data();
        ndIndexArray index;
        for (std::size_t i = 0; i < input_array.num_elements(); i++)
        {
            index = getIndexArray(input_array, p);
            output_array(index) = func(input_array(index));
            ++p;
        }
        return output_array;
    }

◆ element_wise_duo_apply()

template<class T , long unsigned int ND>

constexpr boost::multi_array< T, ND > np::element_wise_duo_apply	(	boost::multi_array< T, ND > const &	lhs,
		boost::multi_array< T, ND > const &	rhs,
		std::function< T(T, T)>	func
	)

inlineconstexpr

Creates a new array in which the value at each index is the the result of the input function applied to an element of the left hand side array and one on the righ hand side array in the same index Outputs a copy of the result

Definition at line 337 of file np.hpp.

    {
        // Create output array copying extents
        using arrayIndex = boost::multi_array<double, ND>::index;
        using ndIndexArray = boost::array<arrayIndex, ND>;
        boost::detail::multi_array::extent_gen<ND> output_extents;
        std::vector<size_t> shape_list;
        for (std::size_t i = 0; i < ND; i++)
        {
            shape_list.push_back(lhs.shape()[i]);
        }
        std::copy(shape_list.begin(), shape_list.end(), output_extents.ranges_.begin());
        boost::multi_array<T, ND> output_array(output_extents);
 
        // Looping through the elements of the output array
        const T *p = lhs.data();
        ndIndexArray index;
        for (std::size_t i = 0; i < lhs.num_elements(); i++)
        {
            index = getIndexArray(lhs, p);
            output_array(index) = func(lhs(index), rhs(index));
            ++p;
        }
        return output_array;
    }

◆ exp() [1/2]

template<class T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr boost::multi_array< T, ND > np::exp ( const boost::multi_array< T, ND > & input_array )

inlineconstexpr

Implements the numpy exp function on multi arrays.

Definition at line 289 of file np.hpp.

    {
        std::function<T(T)> func = (T(*)(T))std::exp;
        return element_wise_apply(input_array, func);
    }

◆ exp() [2/2]

template<class T >
requires std::is_arithmetic<T>

::value constexpr T np::exp ( const T input )

inlineconstexpr

Implements the numpy exp function on scalars.

Definition at line 297 of file np.hpp.

    {
        return std::exp(input);
    }

◆ for_each() [1/4]

template<typename Array , typename Functor >

void np::for_each	(	Array &	A,
		Functor	xform
	)

inline

Function to apply a function to all elements of a multi_array Simple overload

Definition at line 80 of file np.hpp.

    {
        // Dispatch to the proper function
        for_each(boost::type<typename Array::element>(), A.begin(), A.end(), xform);
    }

◆ for_each() [2/4]

template<typename Element , typename Functor >

void np::for_each	(	const boost::type< Element > &	,
		Element &	Val,
		Functor &	xform
	)

inline

Function to apply a function to all elements of a multi_array.

Definition at line 59 of file np.hpp.

    {
        Val = xform(Val);
    }

◆ for_each() [3/4]

template<typename Array , typename Element , typename Functor >

void np::for_each	(	const boost::type< Element > &	type_dispatch,
		Array	A,
		Functor &	xform
	)

inline

Function to apply a function to all elements of a multi_array Simple overload

Definition at line 51 of file np.hpp.

    {
        for_each(type_dispatch, A.begin(), A.end(), xform);
    }

◆ for_each() [4/4]

template<typename Element , typename Iterator , typename Functor >

void np::for_each	(	const boost::type< Element > &	type_dispatch,
		Iterator	begin,
		Iterator	end,
		Functor &	xform
	)

inline

Function to apply a function to all elements of a multi_array.

Definition at line 66 of file np.hpp.

    {
        while (begin != end)
        {
            for_each(type_dispatch, *begin, xform);
            ++begin;
        }
    }

◆ getIndex()

template<std::size_t ND>

boost::multi_array< ndArrayValue, ND >::index np::getIndex	(	const boost::multi_array< ndArrayValue, ND > &	m,
		const ndArrayValue *	requestedElement,
		const unsigned short int	direction
	)

inline

Gets the index of one element in a multi_array in one axis.

Definition at line 27 of file np.hpp.

    {
        int offset = requestedElement - m.origin();
        return (offset / m.strides()[direction] % m.shape()[direction] + m.index_bases()[direction]);
    }

◆ getIndexArray()

template<std::size_t ND>

boost::array< typename boost::multi_array< ndArrayValue, ND >::index, ND > np::getIndexArray	(	const boost::multi_array< ndArrayValue, ND > &	m,
		const ndArrayValue *	requestedElement
	)

inline

Gets the index of one element in a multi_array.

Definition at line 36 of file np.hpp.

    {
        using indexType = boost::multi_array<ndArrayValue, ND>::index;
        boost::array<indexType, ND> _index;
        for (unsigned int dir = 0; dir < ND; dir++)
        {
            _index[dir] = getIndex(m, requestedElement, dir);
        }
 
        return _index;
    }

◆ gradient()

template<typename T , long unsigned int ND>
requires std::is_floating_point<T>

::value constexpr std::vector< boost::multi_array< T, ND > > np::gradient	(	boost::multi_array< T, ND >	inArray,
		std::initializer_list< T >	args
	)

inlineconstexpr

Takes the gradient of a n-dimensional multi_array Uses ij indexing Todo: Implement xy indexing

Definition at line 90 of file np.hpp.

    {
        // static_assert(args.size() == ND, "Number of arguments must match the number of dimensions of the array");
        using arrayIndex = boost::multi_array<T, ND>::index;
 
        using ndIndexArray = boost::array<arrayIndex, ND>;
 
        // constexpr std::size_t n = sizeof...(Args);
        std::size_t n = args.size();
        // std::tuple<Args...> store(args...);
        std::vector<T> arg_vector = args;
        boost::multi_array<T, ND> my_array;
        std::vector<boost::multi_array<T, ND>> output_arrays;
        for (std::size_t i = 0; i < n; i++)
        {
            boost::multi_array<T, ND> dfdh = inArray;
            output_arrays.push_back(dfdh);
        }
 
        ndArrayValue *p = inArray.data();
        ndIndexArray index;
        for (std::size_t i = 0; i < inArray.num_elements(); i++)
        {
            index = getIndexArray(inArray, p);
            /*
            std::cout << "Index: ";
            for (std::size_t j = 0; j < n; j++)
            {
                std::cout << index[j] << " ";
            }
            std::cout << "\n";
            */
            // Calculating the gradient now
            // j is the axis/dimension
            for (std::size_t j = 0; j < n; j++)
            {
                ndIndexArray index_high = index;
                T dh_high;
                if ((long unsigned int)index_high[j] < inArray.shape()[j] - 1)
                {
                    index_high[j] += 1;
                    dh_high = arg_vector[j];
                }
                else
                {
                    dh_high = 0;
                }
                ndIndexArray index_low = index;
                T dh_low;
                if (index_low[j] > 0)
                {
                    index_low[j] -= 1;
                    dh_low = arg_vector[j];
                }
                else
                {
                    dh_low = 0;
                }
 
                T dh = dh_high + dh_low;
                T gradient = (inArray(index_high) - inArray(index_low)) / dh;
                // std::cout << gradient << "\n";
                output_arrays[j](index) = gradient;
            }
            // std::cout << " value = " << inArray(index) << "  check = " << *p << std::endl;
            ++p;
        }
        return output_arrays;
    }

◆ linspace()

boost::multi_array< double, 1 > np::linspace	(	double	start,
		double	stop,
		long unsigned int	num
	)

inline

Implements the numpy linspace function.

Definition at line 161 of file np.hpp.

    {
        double step = (stop - start) / (num - 1);
        boost::multi_array<double, 1> output(boost::extents[num]);
        for (std::size_t i = 0; i < num; i++)
        {
            output[i] = start + i * step;
        }
        return output;
    }

◆ log() [1/2]

template<class T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr boost::multi_array< T, ND > np::log ( const boost::multi_array< T, ND > & input_array )

inlineconstexpr

Implements the numpy log function on multi arrays.

Definition at line 304 of file np.hpp.

    {
        std::function<T(T)> func = std::log<T>();
        return element_wise_apply(input_array, func);
    }

◆ log() [2/2]

template<class T >
requires std::is_arithmetic<T>

::value constexpr T np::log ( const T input )

inlineconstexpr

Implements the numpy log function on scalars.

Definition at line 312 of file np.hpp.

    {
        return std::log(input);
    }

◆ max() [1/2]

template<typename T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr T np::max ( boost::multi_array< T, ND > const & input_array )

inlineconstexpr

Implements the numpy max function for an n-dimensionl multi array.

Definition at line 384 of file np.hpp.

    {
        T max = 0;
        bool max_not_set = true;
        const T *data_pointer = input_array.data();
        for (std::size_t i = 0; i < input_array.num_elements(); i++)
        {
            T element = *data_pointer;
            if (max_not_set || element > max)
            {
                max = element;
                max_not_set = false;
            }
            ++data_pointer;
        }
        return max;
    }

◆ max() [2/2]

template<class T , class... Ts, class = std::enable_if_t<(std::is_same_v<T, Ts> && ...)>>
requires std::is_arithmetic<T>

::value constexpr T np::max	(	T	input1,
		Ts...	inputs
	)

inlineconstexpr

Implements the numpy max function for an variadic number of arguments.

Definition at line 404 of file np.hpp.

    {
        T max = input1;
        for (T input : {inputs...})
        {
            if (input > max)
            {
                max = input;
            }
        }
        return max;
    }

◆ meshgrid()

template<typename T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr std::vector< boost::multi_array< T, ND > > np::meshgrid	(	const boost::multi_array< T, 1 >(&)	cinput[ND],
		bool	sparsing = `false`,
		indexing	indexing_type = `xy`
	)

inlineconstexpr

Implementation of meshgrid TODO: Implement sparsing=true If the indexing type is xx, then reverse the order of the first two elements of ci if the number of dimensions is 2 or 3 In accordance with the numpy implementation

Definition at line 184 of file np.hpp.

    {
        using arrayIndex = boost::multi_array<T, ND>::index;
        using oneDArrayIndex = boost::multi_array<T, 1>::index;
        using ndIndexArray = boost::array<arrayIndex, ND>;
        std::vector<boost::multi_array<T, ND>> output_arrays;
        boost::multi_array<T, 1> ci[ND];
        // Copy elements of cinput to ci, do the proper inversions
        for (std::size_t i = 0; i < ND; i++)
        {
            std::size_t source = i;
            if (indexing_type == xy && (ND == 3 || ND == 2))
            {
                if (i == 0)
                    source = 1;
                else if (i == 1)
                    source = 0;
                else
                    source = i;
            }
            ci[i] = boost::multi_array<T, 1>();
            ci[i].resize(boost::extents[cinput[source].num_elements()]);
            ci[i] = cinput[source];
        }
        // Deducing the extents of the N-Dimensional output
        boost::detail::multi_array::extent_gen<ND> output_extents;
        std::vector<size_t> shape_list;
        for (std::size_t i = 0; i < ND; i++)
        {
            shape_list.push_back(ci[i].shape()[0]);
        }
        std::copy(shape_list.begin(), shape_list.end(), output_extents.ranges_.begin());
 
        // Creating the output arrays
        for (std::size_t i = 0; i < ND; i++)
        {
            boost::multi_array<T, ND> output_array(output_extents);
            ndArrayValue *p = output_array.data();
            ndIndexArray index;
            // Looping through the elements of the output array
            for (std::size_t j = 0; j < output_array.num_elements(); j++)
            {
                index = getIndexArray(output_array, p);
                oneDArrayIndex index_1d;
                index_1d = index[i];
                output_array(index) = ci[i][index_1d];
                ++p;
            }
            output_arrays.push_back(output_array);
        }
        if (indexing_type == xy && (ND == 3 || ND == 2))
        {
            std::swap(output_arrays[0], output_arrays[1]);
        }
        return output_arrays;
    }

◆ min() [1/2]

template<typename T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr T np::min ( boost::multi_array< T, ND > const & input_array )

inlineconstexpr

Implements the numpy min function for an n-dimensionl multi array.

Definition at line 419 of file np.hpp.

    {
        T min = 0;
        bool min_not_set = true;
        const T *data_pointer = input_array.data();
        for (std::size_t i = 0; i < input_array.num_elements(); i++)
        {
            T element = *data_pointer;
            if (min_not_set || element < min)
            {
                min = element;
                min_not_set = false;
            }
            ++data_pointer;
        }
        return min;
    }

◆ min() [2/2]

template<class T , class... Ts, class = std::enable_if_t<(std::is_same_v<T, Ts> && ...)>>
requires std::is_arithmetic<T>

constexpr T np::min	(	T	input1,
		Ts...	inputs
	)

inlineconstexpr

Implements the numpy min function for an variadic number of arguments.

Definition at line 439 of file np.hpp.

    {
        T min = input1;
        for (T input : {inputs...})
        {
            if (input < min)
            {
                min = input;
            }
        }
        return min;
    }
 
    template <typename T, long unsigned int ND>
    requires std::is_arithmetic<T>::value inline constexpr boost::multi_array<T, ND> abs(boost::multi_array<T, ND> const &input_array)
    {
        std::function<T(T)> abs_func = [](T input)
        { return std::abs(input); };
        return element_wise_apply(input_array, abs_func);
    }

◆ pow() [1/2]

template<class T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr boost::multi_array< T, ND > np::pow	(	const boost::multi_array< T, ND > &	input_array,
		const T	exponent
	)

inlineconstexpr

Implements the numpy pow function on multi arrays.

Definition at line 319 of file np.hpp.

    {
        std::function<T(T)> pow_func = [exponent](T input)
        { return std::pow(input, exponent); };
        return element_wise_apply(input_array, pow_func);
    }

◆ pow() [2/2]

template<class T >
requires std::is_arithmetic<T>

::value constexpr T np::pow	(	const T	input,
		const T	exponent
	)

inlineconstexpr

Implements the numpy pow function on scalars.

Definition at line 328 of file np.hpp.

    {
        return std::pow(input, exponent);
    }

◆ slice()

template<typename T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr boost::multi_array< T, ND - 1 > np::slice	(	boost::multi_array< T, ND > const &	input_array,
		std::size_t	slice_index
	)

inlineconstexpr

Slices the array through one dimension and returns a ND - 1 dimensional array.

Definition at line 470 of file np.hpp.

    {
 
        // Deducing the extents of the N-Dimensional output
        boost::detail::multi_array::extent_gen<ND - 1> output_extents;
        std::vector<size_t> shape_list;
        for (std::size_t i = 1; i < ND; i++)
        {
            shape_list.push_back(input_array.shape()[i]);
        }
        std::copy(shape_list.begin(), shape_list.end(), output_extents.ranges_.begin());
 
        boost::multi_array<T, ND - 1> output_array(output_extents);
 
        const T *p = input_array.data();
        boost::array<std::size_t, ND> index;
        for (std::size_t i = 0; i < input_array.num_elements(); i++)
        {
            index = getIndexArray(input_array, p);
            output_array(index) = input_array[slice_index](index);
            p++;
        }
        return output_array;
    }

◆ sqrt() [1/2]

template<class T , long unsigned int ND>
requires std::is_arithmetic<T>

::value constexpr boost::multi_array< T, ND > np::sqrt ( const boost::multi_array< T, ND > & input_array )

inlineconstexpr

Implements the numpy sqrt function on multi arrays.

Definition at line 274 of file np.hpp.

    {
        std::function<T(T)> func = (T(*)(T))std::sqrt;
        return element_wise_apply(input_array, func);
    }

◆ sqrt() [2/2]

template<class T >
requires std::is_arithmetic<T>

::value constexpr T np::sqrt ( const T input )

inlineconstexpr

Implements the numpy sqrt function on scalars.

Definition at line 282 of file np.hpp.

    {
        return std::sqrt(input);
    }

◆ zeros()

template<typename T , typename inT , long unsigned int ND>
requires std::is_integral<inT>

::value &&std::is_arithmetic< T >::value constexpr boost::multi_array< T, ND > np::zeros ( inT(&) dimensions_input[ND] )

inlineconstexpr

Implements the numpy zeros function for an n-dimensionl multi array.

Definition at line 365 of file np.hpp.

    {
        // Deducing the extents of the N-Dimensional output
        boost::detail::multi_array::extent_gen<ND> output_extents;
        std::vector<size_t> shape_list;
        for (std::size_t i = 0; i < ND; i++)
        {
            shape_list.push_back(dimensions_input[i]);
        }
        std::copy(shape_list.begin(), shape_list.end(), output_extents.ranges_.begin());
        // Applying a function to return zero always to all of its elements
        boost::multi_array<T, ND> output_array(output_extents);
        std::function<T(T)> zero_func = [](T input)
        { return 0; };
        return element_wise_apply(output_array, zero_func);
    }

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ ndArrayValue

Enumeration Type Documentation

◆ indexing

Function Documentation

◆ abs()

◆ element_wise_apply()

◆ element_wise_duo_apply()

◆ exp() [1/2]

◆ exp() [2/2]

◆ for_each() [1/4]

◆ for_each() [2/4]

◆ for_each() [3/4]

◆ for_each() [4/4]

◆ getIndex()

◆ getIndexArray()

◆ gradient()

◆ linspace()

◆ log() [1/2]

◆ log() [2/2]

◆ max() [1/2]

◆ max() [2/2]

◆ meshgrid()

◆ min() [1/2]

◆ min() [2/2]

◆ pow() [1/2]

◆ pow() [2/2]

◆ slice()

◆ sqrt() [1/2]

◆ sqrt() [2/2]

◆ zeros()