/*

* This file is part of CasADi.

*

* CasADi -- A symbolic framework for dynamic optimization.

* Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,

* KU Leuven. All rights reserved.

* Copyright (C) 2011-2014 Greg Horn

*

* CasADi is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 3 of the License, or (at your option) any later version.

*

* CasADi is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with CasADi; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

*

*/

#include "function_internal.hpp"

#include "casadi_misc.hpp"

#include "sx_function.hpp"

#include "mx_function.hpp"

#include "switch.hpp"

#include "bspline.hpp"

#include "nlpsol.hpp"

#include "mapsum.hpp"

#include "conic.hpp"

#include "jit_function.hpp"

#include "serializing_stream.hpp"

#include "serializer.hpp"

#include "tools.hpp"

#include "filesystem_impl.hpp"

#include <cctype>

#include <fstream>

#include <typeinfo>

namespace casadi {

// Throw informative error message

#define THROW_ERROR(FNAME, WHAT) \

throw CasadiException("Error in Function::" FNAME " for '" + this->name() + "' "\

"[" + this->class_name() + "] at " + CASADI_WHERE + ":\n"\

+ std::string(WHAT));

// Throw informative error message from constructor

#define THROW_ERROR_NOOBJ(FNAME, WHAT, CLASS_NAME) \

throw CasadiException("Error in Function::" FNAME " for '" + name + "' "\

"[" CLASS_NAME "] at " + CASADI_WHERE + ":\n"\

+ std::string(WHAT));

Function::Function() {

}

Function::~Function() {

}

bool Function::proceed_to(std::istream& file, const std::string& str) {

// Make sure that the file is ready for reading

if (!file.good()) return false;

// Have we already wrapped around once?

//bool wrapped_around = false;

// Read line-by-line

std::string tmp;

while (true) {

// Read a word

std::streampos cur_pos = file.tellg();

file >> tmp;

if (!file.good()) return false;

// Check if match

if (str==tmp) return true;

// If comment, continue to the end of the line

if (tmp.at(0)=='#') {

file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

continue;

}

// If mismatching name, rewind and break

file.seekg(cur_pos);

return false;

}

}

Function::Function(const std::string& fname) {

casadi_error("Not implemented");

}

Function::Function(const std::string& name,

const std::vector<SX>& ex_in, const std::vector<SX>& ex_out,

const Dict& opts) {

construct(name, ex_in, ex_out, {}, {}, opts);

}

Function::Function(const std::string& name,

const std::vector<SX>& ex_in, const std::vector<SX>& ex_out,

const std::vector<std::string>& name_in,

const std::vector<std::string>& name_out,

const Dict& opts) {

construct(name, ex_in, ex_out, name_in, name_out, opts);

}

Function::Function(const std::string& name,

const std::vector<MX>& ex_in, const std::vector<MX>& ex_out,

const Dict& opts) {

construct(name, ex_in, ex_out, {}, {}, opts);

}

Function::Function(const std::string& name,

const std::vector<MX>& ex_in, const std::vector<MX>& ex_out,

const std::vector<std::string>& name_in,

const std::vector<std::string>& name_out,

const Dict& opts) {

construct(name, ex_in, ex_out, name_in, name_out, opts);

}

Function::Function(const std::string& name,

SXIList ex_in, const SXVector& ex_out, const Dict& opts) {

construct(name, SXVector(ex_in), ex_out, {}, {}, opts);

}

Function::Function(const std::string& name,

const SXVector& ex_in, SXIList ex_out, const Dict& opts) {

construct(name, ex_in, SXVector(ex_out), {}, {}, opts);

}

Function::Function(const std::string& name, SXIList ex_in, SXIList ex_out, const Dict& opts) {

construct(name, SXVector(ex_in), SXVector(ex_out), {}, {}, opts);

}

Function::Function(const std::string& name, SXIList ex_in, const SXVector& ex_out,

const StringVector& name_in,

const StringVector& name_out, const Dict& opts) {

construct(name, SXVector(ex_in), ex_out, name_in, name_out, opts);

}

Function::Function(const std::string& name, const SXVector& ex_in, SXIList ex_out,

const StringVector& name_in, const StringVector& name_out, const Dict& opts) {

construct(name, ex_in, SXVector(ex_out), name_in, name_out, opts);

}

Function::Function(const std::string& name, SXIList ex_in, SXIList ex_out,

const StringVector& name_in, const StringVector& name_out, const Dict& opts) {

construct(name, SXVector(ex_in), SXVector(ex_out), name_in, name_out, opts);

}

Function::Function(const std::string& name,

MXIList ex_in, const MXVector& ex_out, const Dict& opts) {

construct(name, MXVector(ex_in), ex_out, {}, {}, opts);

}

Function::Function(const std::string& name,

const MXVector& ex_in, MXIList ex_out, const Dict& opts) {

construct(name, ex_in, MXVector(ex_out), {}, {}, opts);

}

Function::Function(const std::string& name, MXIList ex_in, MXIList ex_out, const Dict& opts) {

construct(name, MXVector(ex_in), MXVector(ex_out), {}, {}, opts);

}

Function::Function(const std::string& name, MXIList ex_in, const MXVector& ex_out,

const StringVector& name_in, const StringVector& name_out, const Dict& opts) {

construct(name, MXVector(ex_in), ex_out, name_in, name_out, opts);

}

Function::Function(const std::string& name, const MXVector& ex_in, MXIList ex_out,

const StringVector& name_in, const StringVector& name_out, const Dict& opts) {

construct(name, ex_in, MXVector(ex_out), name_in, name_out, opts);

}

Function::Function(const std::string& name, MXIList ex_in, MXIList ex_out,

const StringVector& name_in, const StringVector& name_out, const Dict& opts) {

construct(name, MXVector(ex_in), MXVector(ex_out), name_in, name_out, opts);

}

Function::Function(const std::string& name, const std::map<std::string, SX>& dict,

const std::vector<std::string>& name_in, const std::vector<std::string>& name_out,

const Dict& opts) {

construct(name, dict, name_in, name_out, opts);

}

Function::Function(const std::string& name, const std::map<std::string, MX>& dict,

const std::vector<std::string>& name_in, const std::vector<std::string>& name_out,

const Dict& opts) {

construct(name, dict, name_in, name_out, opts);

}

template<typename M>

void Function::construct(const std::string& name, const std::map<std::string, M>& dict,

const std::vector<std::string>& name_in,

const std::vector<std::string>& name_out,

const Dict& opts) {

std::vector<M> ex_in(name_in.size()), ex_out(name_out.size());

for (auto&& i : dict) {

std::vector<std::string>::const_iterator it;

if ((it = std::find(name_in.begin(), name_in.end(), i.first))!=name_in.end()) {

// Input expression

ex_in[it-name_in.begin()] = i.second;

} else if ((it = std::find(name_out.begin(), name_out.end(), i.first))!=name_out.end()) {

// Output expression

ex_out[it-name_out.begin()] = i.second;

} else {

// Neither

casadi_error("Unknown dictionary entry: '" + i.first + "'");

}

}

construct(name, ex_in, ex_out, name_in, name_out, opts);

}

void Function::construct(const std::string& name,

const std::vector<SX>& ex_in, const std::vector<SX>& ex_out,

const std::vector<std::string>& name_in,

const std::vector<std::string>& name_out,

const Dict& opts) {

try {

own(new SXFunction(name, ex_in, ex_out, name_in, name_out));

(*this)->construct(opts);

// Perform external transformations

auto it = opts.find("external_transform");

if (it!=opts.end()) {

auto v = it->second.to_vector_vector();

for (const std::vector<GenericType>& vec : v) {

casadi_assert(vec.size()>=2, "external_transform: inner list must be length >=2");

casadi_assert(vec.size()<=3, "external_transform: inner list must be length <=3");

std::string name = vec[0].to_string();

std::string op = vec[1].to_string();

Dict opts = vec.size()==3 ? vec[2].to_dict() : Dict();

operator=(external_transform(name, op, (*this), opts));

}

}

} catch(std::exception& e) {

THROW_ERROR_NOOBJ("Function", e.what(), "SXFunction");

}

}

void Function::construct(const std::string& name,

const std::vector<MX>& ex_in, const std::vector<MX>& ex_out,

const std::vector<std::string>& name_in,

const std::vector<std::string>& name_out,

const Dict& opts) {

try {

own(new MXFunction(name, ex_in, ex_out, name_in, name_out));

(*this)->construct(opts);

// Perform post-construction expand

auto it = opts.find("post_expand");

if (it!=opts.end()) {

if (!it->second) return;

auto it = opts.find("post_expand_options");

if (it==opts.end()) {

operator=((*this).expand());

} else {

operator=((*this).expand((*this).name(), it->second));

}

}

// Perform external transformations

it = opts.find("external_transform");

if (it!=opts.end()) {

auto v = it->second.to_vector_vector();

for (const std::vector<GenericType>& vec : v) {

casadi_assert(vec.size()>=2, "external_transform: inner list must be length >=2");

casadi_assert(vec.size()<=3, "external_transform: inner list must be length <=3");

std::string name = vec[0].to_string();

std::string op = vec[1].to_string();

Dict opts = vec.size()==3 ? vec[2].to_dict() : Dict();

operator=(external_transform(name, op, (*this), opts));

}

}

} catch(std::exception& e) {

THROW_ERROR_NOOBJ("Function", e.what(), "MXFunction");

}

}

Function Function::jit(const std::string& name, const std::string& body,

const std::vector<std::string>& name_in,

const std::vector<std::string>& name_out,

const Dict& opts) {

// Pass empty vectors -> default values

std::vector<Sparsity> sparsity_in, sparsity_out;

return jit(name, body, name_in, name_out, sparsity_in, sparsity_out, opts);

}

Function Function::jit(const std::string& name, const std::string& body,

const std::vector<std::string>& name_in,

const std::vector<std::string>& name_out,

const std::vector<Sparsity>& sparsity_in,

const std::vector<Sparsity>& sparsity_out,

const Dict& opts) {

try {

return create(new JitFunction(name, body, name_in, name_out,

sparsity_in, sparsity_out), opts);

} catch(std::exception& e) {

THROW_ERROR_NOOBJ("jit", e.what(), "JitFunction");

}

}

Function Function::expand() const {

Dict opts = (*this)->generate_options("clone");

return expand(name(), opts);

}

Function Function::expand(const std::string& name, const Dict& opts) const {

casadi_assert(!has_free(),

"Function with free symbols cannot be expanded. "

"List of free variables in your Function: " +

join(get_free(), ","));

Dict my_opts = (*this)->generate_options("clone");

update_dict(my_opts, opts);

std::vector<SX> ex_in = sx_in();

std::vector<SX> ex_out = Function(*this)(ex_in);

return Function(name, ex_in, ex_out, name_in(), name_out(), my_opts);

}

Function Function::simplify(const Dict& opts) const {

return simplify(name(), opts);

}

Function Function::simplify(const std::string& name, const Dict& opts) const {

try {

return (*this)->simplify(name, opts);

} catch(std::exception& e) {

THROW_ERROR("simplify", e.what());

}

}

Function Function::create(FunctionInternal* node) {

Function ret;

ret.own(node);

return ret;

}

Function Function::create(FunctionInternal* node, const Dict& opts) {

Function ret = create(node);

ret->construct(opts);

return ret;

}

FunctionInternal* Function::operator->() const {

casadi_assert_dev(!is_null());

return get();

}

FunctionInternal* Function::get() const {

return static_cast<FunctionInternal*>(SharedObject::get());

}

void Function::call(const std::vector<DM> &arg, std::vector<DM> &res,

bool always_inline, bool never_inline) const {

try {

(*this)->call(arg, res, always_inline, never_inline);

} catch(std::exception& e) {

THROW_ERROR("call", e.what());

}

}

void Function::call(const std::vector<SX> &arg, std::vector<SX>& res,

bool always_inline, bool never_inline) const {

try {

(*this)->call(arg, res, always_inline, never_inline);

} catch(std::exception& e) {

THROW_ERROR("call", e.what());

}

}

void Function::call(const std::vector<MX> &arg, std::vector<MX>& res,

bool always_inline, bool never_inline) const {

try {

(*this)->call(arg, res, always_inline, never_inline);

} catch(std::exception& e) {

THROW_ERROR("call", e.what());

}

}

std::vector<const double*> Function::buf_in(Function::VecArg arg) const {

casadi_assert_dev(arg.size()==n_in());

auto arg_it=arg.begin();

std::vector<const double*> buf_arg(sz_arg());

for (casadi_uint i=0; i<arg.size(); ++i) {

casadi_assert_dev(arg_it->size()==nnz_in(i));

buf_arg[i] = get_ptr(*arg_it++);

}

return buf_arg;

}

std::vector<double*> Function::buf_out(Function::VecRes res) const {

res.resize(n_out());

auto res_it=res.begin();

std::vector<double*> buf_res(sz_res());

for (casadi_uint i=0; i<res.size(); ++i) {

res_it->resize(nnz_out(i));

buf_res[i] = get_ptr(*res_it++);

}

return buf_res;

}

std::vector<double*> Function::buf_out(Function::VPrRes res) const {

casadi_assert_dev(res.size()==n_out());

auto res_it=res.begin();

std::vector<double*> buf_res(sz_res());

for (casadi_uint i=0; i<res.size(); ++i) {

casadi_assert_dev(*res_it!=0);

(*res_it)->resize(nnz_out(i));

buf_res[i] = get_ptr(**res_it++);

}

return buf_res;

}

std::vector<const double*> Function::buf_in(Function::MapArg arg) const {

// Return value (RVO)

std::vector<const double*> ret(sz_arg(), nullptr);

// Read inputs

for (auto i=arg.begin(); i!=arg.end(); ++i) {

casadi_int ind = index_in(i->first);

casadi_assert_dev(i->second.size()==nnz_in(ind));

ret[ind] = get_ptr(i->second);

}

return ret;

}

std::vector<double*> Function::buf_out(Function::MapRes res) const {

// Return value (RVO)

std::vector<double*> ret(sz_res(), nullptr);

// Read outputs

for (auto i=res.begin(); i!=res.end(); ++i) {

casadi_int ind = index_out(i->first);

i->second.resize(nnz_out(ind));

ret[ind] = get_ptr(i->second);

}

return ret;

}

std::vector<double*> Function::buf_out(Function::MPrRes res) const {

// Return value (RVO)

std::vector<double*> ret(sz_res(), nullptr);

// Read outputs

for (auto i=res.begin(); i!=res.end(); ++i) {

casadi_int ind = index_out(i->first);

casadi_assert_dev(i->second!=0);

i->second->resize(nnz_out(ind));

ret[ind] = get_ptr(*i->second);

}

return ret;

}

template<typename D>

void Function::call_gen(std::vector<const D*> arg, std::vector<D*> res) const {

// Input buffer

casadi_assert_dev(arg.size()>=n_in());

arg.resize(sz_arg());

// Output buffer

casadi_assert_dev(res.size()>=n_out());

res.resize(sz_res());

// Work vectors

std::vector<casadi_int> iw(sz_iw());

std::vector<D> w(sz_w());

// Evaluate memoryless

(*this)(get_ptr(arg), get_ptr(res), get_ptr(iw), get_ptr(w), 0);

}

void Function::operator()(std::vector<const double*> arg, std::vector<double*> res) const {

return call_gen(arg, res);

}

void Function::operator()(std::vector<const bvec_t*> arg, std::vector<bvec_t*> res) const {

return call_gen(arg, res);

}

void Function::operator()(std::vector<const SXElem*> arg, std::vector<SXElem*> res) const {

return call_gen(arg, res);

}

int Function::rev(std::vector<bvec_t*> arg, std::vector<bvec_t*> res) const {

// Input buffer

casadi_assert_dev(arg.size()>=n_in());

arg.resize(sz_arg());

// Output buffer

casadi_assert_dev(res.size()>=n_out());

res.resize(sz_res());

// Work vectors

std::vector<casadi_int> iw(sz_iw());

std::vector<bvec_t> w(sz_w());

// Evaluate memoryless

return rev(get_ptr(arg), get_ptr(res), get_ptr(iw), get_ptr(w), 0);

}

Function Function::fold(casadi_int N, const Dict& opts) const {

Function base = mapaccum(N, opts);

std::vector<MX> base_in = base.mx_in();

std::vector<MX> out = base(base_in);

out[0] = out[0](Slice(), range((N-1)*size2_out(0), N*size2_out(0))); // NOLINT

return Function("fold_"+name(), base_in, out, name_in(), name_out(), opts);

}

Function Function::mapaccum(casadi_int N, const Dict& opts) const {

return mapaccum("mapaccum_"+name(), N, opts);

}

Function Function::mapaccum(const std::string& name, casadi_int N, const Dict& opts) const {

return mapaccum(name, N, 1, opts);

}

Function Function::mapaccum(const std::string& name, casadi_int N, casadi_int n_accum,

const Dict& opts) const {

Dict options = opts;

// Default base

casadi_int base = 10;

auto it = options.find("base");

if (it!=options.end()) {

base = it->second;

options.erase(it);

}

casadi_assert(N>0, "mapaccum: N must be positive");

if (base==-1)

return mapaccum(name, std::vector<Function>(N, *this), n_accum, options);

casadi_assert(base>=2, "mapaccum: base must be positive");

// Decompose N into

std::vector<Function> chain;

Function c = *this;

while (N!=0) {

casadi_int r = N % base;

chain.insert(chain.end(), r, c);

N = (N-r)/base;

c = c.mapaccum(c.name()+"_acc"+str(base), std::vector<Function>(base, c), n_accum, options);

}

return mapaccum(name, chain, n_accum, options);

}

Function Function::mapaccum(const std::string& name,

const std::vector<Function>& chain, casadi_int n_accum,

const Dict& opts) const {

// Shorthands

casadi_int n_in = this->n_in(), n_out = this->n_out();

// Consistency checks

casadi_assert(!chain.empty(), "mapaccum: chain must be non-empty");

casadi_assert(n_accum<=std::min(n_in, n_out), "mapaccum: too many accumulators");

// Quick return?

if (chain.size()==1) return chain[0];

// Get symbolic expressions for inputs and outputs

std::vector<MX> arg = mx_in();

std::vector<MX> res;

// Vectorized inputs and outputs

std::vector<std::vector<MX>> varg(n_in), vres(n_out);

for (casadi_int i=0; i<n_accum; ++i) varg[i].push_back(arg[i]);

// For each function call

for (const auto& f : chain) {

// Stacked input expressions

for (casadi_int i=n_accum; i<n_in; ++i) {

arg[i] = MX::sym(name_in(i) + "_" + str(i), f.sparsity_in(i));

varg[i].push_back(arg[i]);

}

// Call f

res = f(arg);

// Save output expressions

for (casadi_int i=0; i<n_out; ++i) vres[i].push_back(res[i]);

// Copy function output to input

std::copy_n(res.begin(), n_accum, arg.begin());

for (casadi_int i=0; i<n_accum; ++i) {

// Ony get last component (allows nested calls)

casadi_int ncol_out=f.size2_out(i), ncol_in=size2_in(i);

if (ncol_out>ncol_in) {

arg[i] = horzsplit(arg[i], {0, ncol_out-ncol_in, ncol_out}).back();

}

}

}

// Construct return

for (casadi_int i=0; i<n_in; ++i) arg[i] = horzcat(varg[i]);

for (casadi_int i=0; i<n_out; ++i) res[i] = horzcat(vres[i]);

return Function(name, arg, res, name_in(), name_out(), opts);

}

Function Function::mapaccum(const std::string& name, casadi_int n,

const std::vector<casadi_int>& accum_in,

const std::vector<casadi_int>& accum_out,

const Dict& opts) const {

// Shorthands

casadi_int n_in = this->n_in(), n_out = this->n_out();

// Consistency checks

casadi_assert_dev(in_range(accum_in, n_in) && isUnique(accum_in));

casadi_assert_dev(in_range(accum_out, n_out) && isUnique(accum_out));

casadi_assert_dev(accum_in.size()==accum_out.size());

casadi_int n_accum=accum_in.size();

// Quick return if no need to reorder

if (accum_in==range(n_accum) && accum_out==range(n_accum)) {

return mapaccum(name, n, n_accum, opts);

}

// Need to do some reordering

std::vector<casadi_int> temp_in = complement(accum_in, n_in);

std::vector<casadi_int> order_in = accum_in;

order_in.insert(order_in.end(), temp_in.begin(), temp_in.end());

std::vector<casadi_int> temp_out = complement(accum_out, n_out);

std::vector<casadi_int> order_out = accum_out;

order_out.insert(order_out.end(), temp_out.begin(), temp_out.end());

Function ret = slice("slice_" + name, order_in, order_out);

ret = ret.mapaccum("mapacc_" + name, n, n_accum, opts);

return ret.slice(name, lookupvector(order_in, n_in),

lookupvector(order_out, n_out), opts);

}

Function Function::mapaccum(const std::string& name, casadi_int n,

const std::vector<std::string>& accum_in,

const std::vector<std::string>& accum_out,

const Dict& opts) const {

std::vector<casadi_int> accum_in_num, accum_out_num;

for (const std::string& s : accum_in) accum_in_num.push_back(index_in(s));

for (const std::string& s : accum_out) accum_out_num.push_back(index_out(s));

return mapaccum(name, n, accum_in_num, accum_out_num, opts);

}

Function Function::map(casadi_int n,

const std::vector<bool>& reduce_in,

const std::vector<bool>& reduce_out,

const Dict& opts) const {

return MapSum::create("mapsum_" + str(n) + "_" + name(), "serial",

*this, n, reduce_in, reduce_out, opts);

}

Function Function::map(const std::string& name, const std::string& parallelization, casadi_int n,

const std::vector<casadi_int>& reduce_in, const std::vector<casadi_int>& reduce_out,

const Dict& opts) const {

// Wrap in an MXFunction

Function f = map(n, parallelization);

// Start with the fully mapped inputs

std::vector<MX> arg = f.mx_in();

std::vector<MX> f_arg = arg;

// Replace reduced inputs

for (casadi_int i : reduce_in) {

arg[i] = mx_in(i);

f_arg[i] = repmat(arg[i], 1, n);

}

// Get fully mapped outputs

std::vector<MX> res = f(f_arg);

// Replace reduced outputs

for (casadi_int i : reduce_out) {

res[i] = repsum(res[i], 1, n);

}

// Construct return

return Function(name, arg, res, name_in(), name_out());

}

Function Function::map(const std::string& name, const std::string& parallelization, casadi_int n,

const std::vector<std::string>& reduce_in, const std::vector<std::string>& reduce_out,

const Dict& opts) const {

std::vector<casadi_int> reduce_in_num, reduce_out_num;

for (const std::string& s : reduce_in) reduce_in_num.push_back(index_in(s));

for (const std::string& s : reduce_out) reduce_out_num.push_back(index_out(s));

return map(name, parallelization, n, reduce_in_num, reduce_out_num, opts);

}

Function

Function::map(casadi_int n, const std::string& parallelization,

casadi_int max_num_threads) const {

casadi_assert(max_num_threads>=1, "max_num_threads invalid.");

// No need for logic when we are not saturating the limit

if (n<=max_num_threads) return map(n, parallelization);

// Floored division

casadi_int d = n/max_num_threads;

if (d*max_num_threads==n) {

// Easy when n is divisable by max_num_threads

return map(d, "serial").map(max_num_threads, parallelization);

} else {

// Create a base map that computes a bit too much

Function base = map(d+1, "serial").map(max_num_threads, parallelization);

std::vector<MX> ret_in, base_in;

casadi_int rem = (d+1)*max_num_threads-n;

for (casadi_int i=0;i<n_in();++i) {

MX arg = MX::sym("arg", repmat(sparsity_in(i), 1, n));

ret_in.push_back(arg);

MX last_arg = arg(Slice(), range((n-1)*size2_in(i), n*size2_in(i))); // NOLINT

base_in.push_back(horzcat(arg, repmat(last_arg, 1, rem)));

}

std::vector<MX> ret_out = base(base_in);

for (casadi_int i=0;i<n_out();++i) {

ret_out[i] = horzsplit(ret_out[i], {0, n*size2_out(i), ret_out[i].size2()})[0];

}

return Function("helper", ret_in, ret_out, name_in(), name_out());

}

}

Function

Function::map(casadi_int n, const std::string& parallelization) const {

// Make sure not degenerate

casadi_assert(n>0, "Degenerate map operation");

// Quick return if possible

if (n==1) return *this;

// Unroll?

if (parallelization=="unroll" || parallelization=="inline") {

// Construct symbolic inputs

std::vector<MX> arg(n_in());

std::vector<std::vector<MX>> v(n, arg);

std::vector<MX> tmp(n);

for (casadi_int i=0; i<arg.size(); ++i) {

for (casadi_int k=0; k<n; ++k) {

tmp[k] = v[k][i] = MX::sym(name_in(i)+"_"+str(k), sparsity_in(i));

}

arg[i] = horzcat(tmp);

}

// Evaluate

if (parallelization=="unroll") {

for (auto&& w : v) w = (*this)(w);

} else {

for (auto&& w : v) call(std::vector<MX>(w), w, !is_a("SXFunction"), false);

}

// Gather outputs

std::vector<MX> res(n_out());

for (casadi_int i=0; i<res.size(); ++i) {

for (casadi_int k=0; k<n; ++k) tmp[k] = v[k][i];

res[i] = horzcat(tmp);

}

// Construct function

return Function(name() + "_" + str(n), arg, res, name_in(), name_out());

} else {

// Generate/retrieve potentially cached map

return (*this)->map(n, parallelization);

}

}

Function Function::

slice(const std::string& name, const std::vector<casadi_int>& order_in,

const std::vector<casadi_int>& order_out, const Dict& opts) const {

try {

return (*this)->slice(name, order_in, order_out, opts);

} catch(std::exception& e) {

THROW_ERROR("slice", e.what());

}

}

std::vector<MX> Function::mapsum(const std::vector< MX > &x,

const std::string& parallelization) const {

try {

return (*this)->mapsum_mx(x, parallelization);

} catch(std::exception& e) {

THROW_ERROR("mapsum", e.what());

}

}

Function Function::conditional(const std::string& name, const std::vector<Function>& f,

const Function& f_def, const Dict& opts) {

try {

return create(new Switch(name, f, f_def), opts);

} catch(std::exception& e) {

THROW_ERROR_NOOBJ("conditional", e.what(), "Switch");

}

}

Function Function::conditional(const std::string& name,

const Function& f, const Dict& opts) {

try {

// Create a dummy function with the same signature as f

std::vector<MX> dummy_in = f.mx_in();

std::vector<MX> dummy_out(f.n_out());

for (casadi_int i = 0; i < dummy_out.size(); ++i) {

dummy_out.at(i) = MX::zeros(f.sparsity_out(i));

}

Function dummy("dummy_" + f.name(), dummy_in, dummy_out, f.name_in(), f.name_out());

// Form a conditional call

return if_else(name, f, dummy, opts);

} catch(std::exception& e) {

THROW_ERROR_NOOBJ("conditional", e.what(), "Switch");

}

}

Function Function::bspline(const std::string &name,

const std::vector< std::vector<double> >& knots,

const std::vector<double>& coeffs, const std::vector<casadi_int>& degree,

casadi_int m, const Dict& opts) {

try {

casadi_assert(degree.size()==knots.size(), "Degree list length (" + str(degree.size()) + ") "

"must match knot list length (" + str(knots.size()) + ").");

MX x = MX::sym("x", degree.size());

std::vector<std::string> lookup_mode;

Dict opts_remainder = extract_from_dict(opts, "lookup_mode", lookup_mode);

Dict opts_bspline;

opts_bspline["lookup_mode"] = lookup_mode;

MX y = MX::bspline(x, DM(coeffs), knots, degree, m, opts_bspline);

return Function(name, {x}, {y}, opts_remainder);

} catch(std::exception& e) {

THROW_ERROR_NOOBJ("bspline", e.what(), "BSpline");

}

}

Function Function::if_else(const std::string& name, const Function& f_true,

const Function& f_false, const Dict& opts) {

try {

return create(new Switch(name, std::vector<Function>(1, f_false), f_true), opts);

} catch(std::exception& e) {

THROW_ERROR_NOOBJ("if_else", e.what(), "Switch");

}

}

casadi_int Function::n_in() const {

return (*this)->n_in_;

}

casadi_int Function::n_out() const {

return (*this)->n_out_;

}

casadi_int Function::size1_in(casadi_int ind) const {

return (*this)->size1_in(ind);

}

casadi_int Function::size2_in(casadi_int ind) const {

return (*this)->size2_in(ind);

}

casadi_int Function::size1_out(casadi_int ind) const {

return (*this)->size1_out(ind);

}

casadi_int Function::size2_out(casadi_int ind) const {

return (*this)->size2_out(ind);

}

std::pair<casadi_int, casadi_int> Function::size_in(casadi_int ind) const {

return (*this)->size_in(ind);

}

std::pair<casadi_int, casadi_int> Function::size_out(casadi_int ind) const {

return (*this)->size_out(ind);

}

casadi_int Function::nnz_in() const {

return (*this)->nnz_in();

}

casadi_int Function::nnz_out() const {

return (*this)->nnz_out();

}

casadi_int Function::numel_in() const {

return (*this)->numel_in();

}

casadi_int Function::numel_out() const {

return (*this)->numel_out();

}

casadi_int Function::nnz_in(casadi_int ind) const {

return (*this)->nnz_in(ind);

}

casadi_int Function::nnz_out(casadi_int ind) const {

return (*this)->nnz_out(ind);

}

casadi_int Function::numel_in(casadi_int ind) const {

return (*this)->numel_in(ind);

}

casadi_int Function::numel_out(casadi_int ind) const {

return (*this)->numel_out(ind);

}

bool Function::uses_output() const {

return (*this)->uses_output();

}

#ifdef WITH_DEPRECATED_FEATURES

Function Function::jacobian_old(casadi_int iind, casadi_int oind) const {

// Redirect to factory class

std::vector<std::string> s_in = name_in();

std::vector<std::string> s_out = name_out();

s_out.insert(s_out.begin(), "jac:" + name_out(oind) + ":" + name_in(iind));

return factory(name() + "_jac", s_in, s_out);

}

Function Function::hessian_old(casadi_int iind, casadi_int oind) const {

// Redirect to factory class

std::vector<std::string> s_in = name_in();

std::vector<std::string> s_out = name_out();

s_out.insert(s_out.begin(), "grad:" + name_out(oind) + ":" + name_in(iind));

s_out.insert(s_out.begin(),

"hess:" + name_out(oind) + ":" + name_in(iind) + ":" + name_in(iind));

return factory(name() + "_hess", s_in, s_out);

}

const Sparsity Function::

sparsity_jac(casadi_int iind, casadi_int oind, bool compact, bool symmetric) const {

try {

return (*this)->jac_sparsity(oind, iind, compact, symmetric);

} catch(std::exception& e) {

THROW_ERROR("sparsity_jac", e.what());

}

}

#endif // WITH_DEPRECATED_FEATURES

Function Function::jacobian() const {

try {

return (*this)->jacobian();

} catch(std::exception& e) {

THROW_ERROR("jacobian", e.what());

}

}

bool Function::test_cast(const SharedObjectInternal* ptr) {

return dynamic_cast<const FunctionInternal*>(ptr)!=nullptr;

}

Dict Function::stats(int mem) const {

if (!(*this)->has_memory(mem)) {

THROW_ERROR("stats",

"No stats available: Function/solver was not yet numerically evaluated.");

}

try {

return (*this)->get_stats(memory(mem));

} catch(std::exception& e) {

THROW_ERROR("stats", e.what());

}

}

const std::vector<Sparsity>& Function::jac_sparsity(bool compact) const {

// Make sure all are calculated

for (casadi_int oind = 0; oind < n_out(); ++oind) {

for (casadi_int iind = 0; iind < n_in(); ++iind) {

(void)jac_sparsity(oind, iind, compact);

}

}

// Return reference to internal cache

return (*this)->jac_sparsity_[compact];

}

Sparsity Function::jac_sparsity(casadi_int oind, casadi_int iind, bool compact) const {

try {

bool symm = (*this)->jac_is_symm(oind, iind);

symm = symm && sparsity_out(oind).is_dense();

return (*this)->jac_sparsity(oind, iind, compact, symm);

} catch(std::exception& e) {

THROW_ERROR("jac_sparsity", e.what());

}

}

const std::vector<std::string>& Function::name_in() const {

return (*this)->name_in_;

}

const std::vector<std::string>& Function::name_out() const {

return (*this)->name_out_;

}

casadi_int Function::index_in(const std::string &name) const {

try {

return (*this)->index_in(name);

} catch(std::exception& e) {

THROW_ERROR("index_in", e.what());

}

}

casadi_int Function::index_out(const std::string &name) const {

try {

return (*this)->index_out(name);

} catch(std::exception& e) {

THROW_ERROR("index_out", e.what());

}

}

bool Function::has_in(const std::string &name) const {

for (const std::string& s : (*this)->name_in_) {

if (s==name) return true;

}

return false;

}

bool Function::has_out(const std::string &name) const {

for (const std::string& s : (*this)->name_out_) {

if (s==name) return true;

}

return false;

}