casadi::FunctionBuffer Class Reference

Evaluate a Function repeatedly with minimal overhead. More...

#include <function.hpp>

Detailed Description

A FunctionBuffer holds the work vectors and a memory object of a Function and evaluates it directly on caller-owned contiguous double buffers, skipping argument conversion and allocation. Bind each input with set_arg and each output with set_res (nonzeros in column-major order, see nz_from_in), then evaluate; the results appear in the bound output buffers and ret() gives the return code (0 on success). The buffers must stay alive and unchanged in size while the FunctionBuffer is used.

Function.buffer() returns a pair (FunctionBuffer, callable): the callable runs one evaluation; bind numpy arrays with memoryview.

>>> x = SX.sym("x"); y = SX.sym("y", 2)
>>> f = Function("f", [x, y], [x*y], ["x", "y"], ["r"])
>>> fb, evaluate = f.buffer()
>>> a = np.array([2.0]); b = np.array([3.0, 4.0]); r = np.zeros(2)
>>> fb.set_arg(0, memoryview(a)); fb.set_arg(1, memoryview(b))
>>> fb.set_res(0, memoryview(r))
>>> evaluate()
>>> r, fb.ret()
(array([6., 8.]), 0)
>>> a[0] = 5; evaluate(); print(r)
[15. 20.]
>>> try:
...   fb.set_arg(1, memoryview(a))
... except RuntimeError as e:
...   print("Buffer is not large enough" in str(e))
True

See also

Function::nz_from_in, Function::checkout, Function::sz_w

Extra doc: https://github.com/casadi/casadi/wiki/L_1y9

Definition at line 5263 of file function.hpp.

Public Member Functions
	FunctionBuffer (const Function &f)
	Create a buffer for f, allocating its work vectors and a memory object. More...
	~FunctionBuffer ()
	FunctionBuffer (const FunctionBuffer &f)
FunctionBuffer &	operator= (const FunctionBuffer &f)
void	set_arg (casadi_int i, const double *a, casadi_int size)
	Bind a contiguous buffer holding the nonzeros of input i. More...
void	set_res (casadi_int i, double *a, casadi_int size)
	Bind a contiguous buffer that receives the nonzeros of output i. More...
int	ret ()
	Get the return code of the last evaluation (0 on success) More...
void	_eval ()
void *	_self ()
Dict	stats () const
	Get the statistics of the memory object used by this buffer, see Function::stats. More...

Constructor & Destructor Documentation

FunctionBuffer() [1/2]

casadi::FunctionBuffer::FunctionBuffer

(

const Function &

f

)

Extra doc: https://github.com/casadi/casadi/wiki/L_1ya

Definition at line 2150 of file function.cpp.

                                                  : f_(f) {
    w_.resize(f_.sz_w());
    iw_.resize(f_.sz_iw());
    arg_.resize(f_.sz_arg());
    res_.resize(f_.sz_res());
    if (f_->checkout_) {
      mem_ = f_->checkout_();
    } else {
      mem_ = f_.checkout();
      mem_internal_ = f_.memory(mem_);
    }
    f_node_ = f.operator->();
  }

References casadi::Function::checkout(), casadi::FunctionInternal::checkout_, casadi::Function::memory(), casadi::Function::sz_arg(), casadi::Function::sz_iw(), casadi::Function::sz_res(), and casadi::Function::sz_w().

~FunctionBuffer()

casadi::FunctionBuffer::~FunctionBuffer

(

)

Definition at line 2164 of file function.cpp.

                                  {
    if (f_->release_) {
      f_->release_(mem_);
    } else {
      f_.release(mem_);
    }
  }

References casadi::Function::release(), and casadi::FunctionInternal::release_.

FunctionBuffer() [2/2]

casadi::FunctionBuffer::FunctionBuffer

(

const FunctionBuffer &

f

)

Definition at line 2172 of file function.cpp.

      : f_(f.f_), w_(f.w_), iw_(f.iw_), arg_(f.arg_), res_(f.res_), f_node_(f.f_node_) {
    if (f_->checkout_) {
      mem_ = f_->checkout_();
    } else {
      mem_ = f_.checkout();
      mem_internal_ = f_.memory(mem_);
    }
  }

References casadi::Function::checkout(), casadi::FunctionInternal::checkout_, and casadi::Function::memory().

Member Function Documentation

_eval()

void casadi::FunctionBuffer::_eval

(

)

Definition at line 2216 of file function.cpp.

                             {
    if (f_node_->eval_) {
      ret_ = f_node_->eval_(get_ptr(arg_), get_ptr(res_), get_ptr(iw_), get_ptr(w_), mem_);
    } else {
      ret_ = f_node_->eval(get_ptr(arg_), get_ptr(res_), get_ptr(iw_), get_ptr(w_), mem_internal_);
    }
  }

References casadi::FunctionInternal::eval(), casadi::FunctionInternal::eval_, and casadi::get_ptr().

_self()

void* casadi::FunctionBuffer::_self ( )

inline

Definition at line 5311 of file function.hpp.

{ return this; }

operator=()

FunctionBuffer & casadi::FunctionBuffer::operator=

(

const FunctionBuffer &

f

)

Definition at line 2182 of file function.cpp.

                                                                   {
    if (this == &f) return *this;
 
    if (f_->release_) {
      f_->release_(mem_);
    } else {
      f_.release(mem_);
    }
 
    f_ = f.f_;
    w_ = f.w_; iw_ = f.iw_; arg_ = f.arg_; res_ = f.res_; f_node_ = f.f_node_;
    // Checkout fresh memory
    if (f_->checkout_) {
      mem_ = f_->checkout_();
    } else {
      mem_ = f_.checkout();
      mem_internal_ = f_.memory(mem_);
    }
 
    return *this;
  }

References casadi::Function::checkout(), casadi::FunctionInternal::checkout_, casadi::Function::memory(), casadi::Function::release(), and casadi::FunctionInternal::release_.

ret()

int casadi::FunctionBuffer::ret

(

)

Definition at line 2223 of file function.cpp.

                          {
    return ret_;
  }

set_arg()

void casadi::FunctionBuffer::set_arg	(	casadi_int	i,
		const double *	a,
		casadi_int	size
	)

size is the buffer size in bytes; it must be at least nnz_in(i)*sizeof(double) or an error is raised. The values are read in column-major (Fortran) order of the input sparsity.

Pass a memoryview of a numpy array: set_arg(0, memoryview(a)).

Extra doc: https://github.com/casadi/casadi/wiki/L_1yb

Definition at line 2204 of file function.cpp.

                                                                             {
    casadi_assert(size>=f_.nnz_in(i)*sizeof(double),
     "Buffer is not large enough. Needed " + str(f_.nnz_in(i)*sizeof(double)) +
     " bytes, got " + str(size) + ".");
    arg_.at(i) = a;
  }

References casadi::Function::nnz_in(), and casadi::str().

set_res()

void casadi::FunctionBuffer::set_res	(	casadi_int	i,
		double *	a,
		casadi_int	size
	)

size is the buffer size in bytes, at least nnz_out(i)*sizeof(double). Values are written in column-major order of the output sparsity.

Pass a memoryview of a numpy array: set_res(0, memoryview(r)).

Extra doc: https://github.com/casadi/casadi/wiki/L_1yc

Definition at line 2210 of file function.cpp.

                                                                       {
    casadi_assert(size>=f_.nnz_out(i)*sizeof(double),
     "Buffer is not large enough. Needed " + str(f_.nnz_out(i)*sizeof(double)) +
     " bytes, got " + str(size) + ".");
    res_.at(i) = a;
  }

References casadi::Function::nnz_out(), and casadi::str().

stats()

Dict casadi::FunctionBuffer::stats

(

)

const

Definition at line 2231 of file function.cpp.

                                   {
    return f_.stats(mem_);
  }

References casadi::Function::stats().

---

The documentation for this class was generated from the following files:

• function.hpp
• function.cpp