SYMBOL INDEX (732 symbols across 66 files)

FILE: conftest.py
  function workspace_folder (line 12) | def workspace_folder(tmpdir_factory):
  function workspace (line 18) | def workspace(workspace_folder, doctest_namespace):

FILE: src/matlab2cpp/__init__.py
  function m2cpp (line 47) | def m2cpp(args=None):

FILE: src/matlab2cpp/collection.py
  class Project (line 210) | class Project(Node):
    method __init__ (line 211) | def __init__(self, name="", cur=0, line=0, code="", **kws):
  class Program (line 228) | class Program(Node):
    method __init__ (line 229) | def __init__(self, parent, name, **kws):
  class Includes (line 242) | class Includes(Node):
    method __init__ (line 243) | def __init__(self, parent, **kws):
  class Funcs (line 246) | class Funcs(Node):
    method __init__ (line 247) | def __init__(self, parent, line=1, **kws):
  class Inlines (line 250) | class Inlines(Node):
    method __init__ (line 251) | def __init__(self, parent, **kws):
  class Structs (line 254) | class Structs(Node):
    method __init__ (line 255) | def __init__(self, parent, **kws):
  class Headers (line 258) | class Headers(Node):
    method __init__ (line 259) | def __init__(self, parent, **kws):
  class Log (line 262) | class Log(Node):
    method __init__ (line 263) | def __init__(self, parent, **kws):
  class Header (line 266) | class Header(Node):
    method __init__ (line 267) | def __init__(self, parent, name, **kws):
  class Main (line 270) | class Main(Node):
    method __init__ (line 271) | def __init__(self, parent, name="main", **kws):
  class Error (line 274) | class Error(Node):
    method __init__ (line 275) | def __init__(self, parent, name, value, **kws):
  class Warning (line 278) | class Warning(Node):
    method __init__ (line 279) | def __init__(self, parent, name, value, **kws):
  class Counter (line 283) | class Counter(Node):
    method __init__ (line 284) | def __init__(self, parent, name, value, **kws):
  class Inline (line 288) | class Inline(Node):
    method __init__ (line 289) | def __init__(self, parent, name, **kws):
  class Include (line 292) | class Include(Includes):
    method __init__ (line 293) | def __init__(self, parent, name, **kws):
  class Struct (line 296) | class Struct(Structs):          pass
  class Func (line 298) | class Func(Node):           pass
  class Returns (line 299) | class Returns(Node):        pass
  class Params (line 300) | class Params(Node):         pass
  class Declares (line 301) | class Declares(Node):       pass
  class Block (line 303) | class Block(Node):
    method __init__ (line 304) | def __init__(self, parent, **kws):
  class Parfor (line 306) | class Parfor(Block):        pass
  class For (line 307) | class For(Block):           pass
  class While (line 308) | class While(Block):         pass
  class Switch (line 309) | class Switch(Block):        pass
  class Case (line 310) | class Case(Block):          pass
  class Otherwise (line 311) | class Otherwise(Block):     pass
  class Branch (line 312) | class Branch(Block):        pass
  class If (line 313) | class If(Block):            pass
  class Elif (line 314) | class Elif(Block):          pass
  class Else (line 315) | class Else(Block):          pass
  class Tryblock (line 316) | class Tryblock(Block):      pass
  class Try (line 317) | class Try(Block):           pass
  class Catch (line 318) | class Catch(Block):         pass
  class Statement (line 319) | class Statement(Block):     pass
  class Assign (line 321) | class Assign(Node):         pass
  class Assigns (line 322) | class Assigns(Node):
    method __init__ (line 323) | def __init__(self, parent, **kws):
  class Expr (line 326) | class Expr(Node):
    method __init__ (line 327) | def __init__(self, parent, **kws):
  class Opr (line 329) | class Opr(Expr):            pass
  class Exp (line 330) | class Exp(Opr):             pass
  class Elexp (line 331) | class Elexp(Opr):           pass
  class Mul (line 332) | class Mul(Opr):             pass
  class Minus (line 333) | class Minus(Opr):           pass
  class Elmul (line 334) | class Elmul(Opr):           pass
  class Matrixdivision (line 335) | class Matrixdivision(Opr):      pass
  class Elementdivision (line 336) | class Elementdivision(Opr):     pass
  class Leftmatrixdivision (line 337) | class Leftmatrixdivision(Opr):  pass
  class Leftelementdivision (line 338) | class Leftelementdivision(Opr): pass
  class Plus (line 339) | class Plus(Opr):            pass
  class Colon (line 340) | class Colon(Opr):           pass
  class Gt (line 341) | class Gt(Opr):              pass
  class Ge (line 342) | class Ge(Opr):              pass
  class Lt (line 343) | class Lt(Opr):              pass
  class Le (line 344) | class Le(Opr):              pass
  class Ne (line 345) | class Ne(Opr):              pass
  class Eq (line 346) | class Eq(Opr):              pass
  class Band (line 347) | class Band(Opr):            pass
  class Bor (line 348) | class Bor(Opr):             pass
  class Land (line 349) | class Land(Opr):            pass
  class Lor (line 350) | class Lor(Opr):             pass
  class Matrix (line 352) | class Matrix(Node):
    method __init__ (line 353) | def __init__(self, parent, **kws):
  class Vector (line 355) | class Vector(Matrix):       pass
  class Cell (line 357) | class Cell(Node):
    method __init__ (line 358) | def __init__(self, parent, **kws):
  class Paren (line 361) | class Paren(Expr):          pass
  class Neg (line 362) | class Neg(Expr):            pass
  class Not (line 363) | class Not(Expr):            pass
  class Ctranspose (line 364) | class Ctranspose(Expr):     pass
  class Transpose (line 365) | class Transpose(Expr):      pass
  class All (line 366) | class All(Expr):            pass
  class End (line 367) | class End(Expr):            pass
  class Break (line 368) | class Break(Expr):          pass
  class Return (line 369) | class Return(Expr):         pass
  class Int (line 371) | class Int(Node):
    method __init__ (line 372) | def __init__(self, parent, value, **kws):
  class Float (line 375) | class Float(Node):
    method __init__ (line 376) | def __init__(self, parent, value, **kws):
  class Imag (line 380) | class Imag(Node):
    method __init__ (line 381) | def __init__(self, parent, value, **kws):
  class String (line 384) | class String(Node):
    method __init__ (line 385) | def __init__(self, parent, value, **kws):
  class Lambda (line 389) | class Lambda(Node):
    method __init__ (line 390) | def __init__(self, parent, name="", **kws):
  class Pragma_for (line 393) | class Pragma_for(Node):
    method __init__ (line 394) | def __init__(self, parent, value, **kws):
  class Lcomment (line 397) | class Lcomment(Node):
    method __init__ (line 398) | def __init__(self, parent, value, **kws):
  class Bcomment (line 402) | class Bcomment(Node):
    method __init__ (line 403) | def __init__(self, parent, value, **kws):
  class Ecomment (line 407) | class Ecomment(Node):
    method __init__ (line 408) | def __init__(self, parent, value, **kws):
  class Var (line 412) | class Var(Node):
    method __init__ (line 413) | def __init__(self, parent, name, **kws):
  class Get (line 415) | class Get(Var):         pass
  class Set (line 416) | class Set(Var):         pass
  class Fvar (line 418) | class Fvar(Node):
    method __init__ (line 419) | def __init__(self, parent, name, value, **kws):
  class Cvar (line 422) | class Cvar(Node):
    method __init__ (line 423) | def __init__(self, parent, name, **kws):
  class Cget (line 426) | class Cget(Node):
    method __init__ (line 427) | def __init__(self, parent, name, **kws):
  class Fget (line 430) | class Fget(Node):
    method __init__ (line 431) | def __init__(self, parent, name, value, **kws):
  class Sget (line 434) | class Sget(Node):
    method __init__ (line 435) | def __init__(self, parent, name, value, **kws):
  class Nget (line 438) | class Nget(Node):
    method __init__ (line 439) | def __init__(self, parent, name, **kws):
  class Cset (line 442) | class Cset(Node):
    method __init__ (line 443) | def __init__(self, parent, name, **kws):
  class Fset (line 446) | class Fset(Node):
    method __init__ (line 447) | def __init__(self, parent, name, value, **kws):
  class Sset (line 450) | class Sset(Node):
    method __init__ (line 451) | def __init__(self, parent, name, value, **kws):
  class Nset (line 454) | class Nset(Node):
    method __init__ (line 455) | def __init__(self, parent, name, **kws):
  class Resize (line 458) | class Resize(Node):
    method __init__ (line 459) | def __init__(self, parent, **kws):
  class Verbatim (line 462) | class Verbatim(Node):
    method __init__ (line 463) | def __init__(self, parent, name, value, **kws):

FILE: src/matlab2cpp/configure/armadillo.py
  function vec (line 4) | def vec(node):
  function rowvec (line 22) | def rowvec(node):
  function mat (line 42) | def mat(node):
  function cube (line 74) | def cube(node):

FILE: src/matlab2cpp/configure/backends.py
  function Assigns (line 32) | def Assigns(node):
  function Matrix (line 69) | def Matrix(node):
  function Fvar (line 93) | def Fvar(node):
  function Var (line 123) | def Var(node):
  function Get (line 126) | def Get(node):
  function Set (line 129) | def Set(node):
  function Func (line 133) | def Func(node):
  function Returns (line 141) | def Returns(node):
  function Params (line 148) | def Params(node):
  function Declares (line 156) | def Declares(node):
  function Assign (line 165) | def Assign(node):

FILE: src/matlab2cpp/configure/datatypes.py
  function Var (line 7) | def Var(node):
  function Get (line 59) | def Get(node):
  function Set (line 100) | def Set(node):
  function Fvar (line 139) | def Fvar(node):
  function Fset (line 147) | def Fset(node):
  function Sset (line 155) | def Sset(node):
  function Assign (line 164) | def Assign(node):
  function Vector (line 171) | def Vector(node):
  function Matrix (line 221) | def Matrix(node):
  function Transpose (line 268) | def Transpose(node):
  function For (line 281) | def For(node):
  function Neg (line 290) | def Neg(node):
  function opr (line 296) | def opr(node):
  function Minus (line 300) | def Minus(node):
  function Mul (line 305) | def Mul(node):
  function Exp (line 317) | def Exp(node):
  function Elexp (line 323) | def Elexp(node):
  function division (line 331) | def division(node):
  function Colon (line 342) | def Colon(node):
  function Lambda (line 367) | def Lambda(node):
  function Assigns (line 419) | def Assigns(node):

FILE: src/matlab2cpp/configure/frontend.py
  function configure (line 3) | def configure(root, suggest=True, **kws):
  function loop (line 18) | def loop(root, suggest):

FILE: src/matlab2cpp/configure/funcs.py
  function funcs (line 3) | def funcs(node):

FILE: src/matlab2cpp/configure/reserved.py
  function Get_exp (line 6) | def Get_exp(node):
  function Get_log (line 9) | def Get_log(node):
  function Get_log2 (line 12) | def Get_log2(node):
  function Get_log10 (line 15) | def Get_log10(node):
  function Get_power (line 18) | def Get_power(node):
  function Get_floor (line 21) | def Get_floor(node):
  function Get_ceil (line 24) | def Get_ceil(node):
  function Get_fix (line 27) | def Get_fix(node):
  function Get_round (line 30) | def Get_round(node):
  function Get_cos (line 39) | def Get_cos(node):
  function Get_acos (line 42) | def Get_acos(node):
  function Get_cosh (line 45) | def Get_cosh(node):
  function Get_acosh (line 48) | def Get_acosh(node):
  function Get_sin (line 51) | def Get_sin(node):
  function Get_asin (line 54) | def Get_asin(node):
  function Get_sinh (line 57) | def Get_sinh(node):
  function Get_asinh (line 60) | def Get_asinh(node):
  function Get_sqrt (line 63) | def Get_sqrt(node):
  function Get_mod (line 70) | def Get_mod(node):
  function Get_abs (line 73) | def Get_abs(node):
  function Get_tic (line 79) | def Get_tic(node):
  function Assign_tic (line 82) | def Assign_tic(node):
  function Get_toc (line 86) | def Get_toc(node):
  function Assign_toc (line 89) | def Assign_toc(node):
  function Get_any (line 93) | def Get_any(node):
  function Get_size (line 128) | def Get_size(node):
  function Assigns_size (line 208) | def Assigns_size(node):
  function Get_length (line 222) | def Get_length(node):
  function Get_min (line 225) | def Get_min(node):
  function Assigns_min (line 257) | def Assigns_min(node):
  function Assigns_max (line 271) | def Assigns_max(node):
  function Get_fliplr (line 284) | def Get_fliplr(node):
  function Get_flipud (line 288) | def Get_flipud(node):
  function Get_eye (line 292) | def Get_eye(node):
  function Get_diag (line 299) | def Get_diag(node):
  function Get_tril (line 306) | def Get_tril(node):
  function Get_triu (line 310) | def Get_triu(node):
  function Get_trace (line 316) | def Get_trace(node):
  function Get_transpose (line 319) | def Get_transpose(node):
  function Get_ctranspose (line 334) | def Get_ctranspose(node):
  function Get_zeros (line 349) | def Get_zeros(node):
  function Get_rand (line 414) | def Get_rand(node):
  function Get_reshape (line 434) | def Get_reshape(node):
  function Get_nextpow2 (line 438) | def Get_nextpow2(node):
  function Get_fft (line 441) | def Get_fft(node):
  function Get_ifft (line 451) | def Get_ifft(node):
  function Get_interp1 (line 470) | def Get_interp1(node):
  function Get_sum (line 474) | def Get_sum(node):
  function Get_cumsum (line 502) | def Get_cumsum(node):
  function Get_conj (line 505) | def Get_conj(node):
  function Get_real (line 508) | def Get_real(node):
  function Get_convmtx (line 517) | def Get_convmtx(node):
  function Get_conv2 (line 520) | def Get_conv2(node):
  function Get_logspace (line 523) | def Get_logspace(node):
  function Get_find (line 526) | def Get_find(node):

FILE: src/matlab2cpp/datatype.py
  function common_loose (line 41) | def common_loose(vals):
  function common_strict (line 89) | def common_strict(vals):
  function pointer_split (line 125) | def pointer_split(name):
  function get_dim (line 132) | def get_dim(val):
  function get_mem (line 148) | def get_mem(val):
  function get_num (line 164) | def get_num(val):
  function get_name (line 175) | def get_name(dim, mem):
  function get_type (line 179) | def get_type(instance):
  class Dim (line 185) | class Dim(object):
    method __get__ (line 217) | def __get__(self, instance, owner):
    method __set__ (line 222) | def __set__(self, instance, value):
  class Mem (line 227) | class Mem(object):
    method __get__ (line 259) | def __get__(self, instance, owner):
    method __set__ (line 264) | def __set__(self, instance, value):
  class Num (line 269) | class Num(object):
    method __get__ (line 275) | def __get__(self, instance, owner):
    method __set__ (line 280) | def __set__(self, instance, value):
  class Type (line 287) | class Type(object):
    method __get__ (line 330) | def __get__(self, instance, owner):
    method __set__ (line 335) | def __set__(self, instance, value):
  class Suggest (line 345) | class Suggest(object):
    method __set__ (line 349) | def __set__(self, instance, value):
    method __get__ (line 353) | def __get__(self, instance, owner):

FILE: src/matlab2cpp/frontend.py
  function execute_parser (line 12) | def execute_parser(args):

FILE: src/matlab2cpp/matlab_types.py
  function lstripped (line 9) | def lstripped(s):
  function mtypes (line 18) | def mtypes(builder, args):
  function extract_ftypes (line 140) | def extract_ftypes(program, funcs_types, file_path):
  function datatype_string (line 210) | def datatype_string(cols):
  function detect_string (line 264) | def detect_string(code, k):
  function function_code (line 289) | def function_code(program, code):

FILE: src/matlab2cpp/modify.py
  function preorder_transform_AST (line 4) | def preorder_transform_AST(node, nargin = False, suggest = False):
  function postorder_transform_AST (line 36) | def postorder_transform_AST(node):
  function change_to_complex (line 49) | def change_to_complex(project):
  function complex_mul (line 103) | def complex_mul(nodes):
  function remove_close_clear_clc (line 119) | def remove_close_clear_clc(nodes):
  function modify_find (line 128) | def modify_find(nodes):
  function modify_define_first (line 142) | def modify_define_first(project):
  function modify_arma_last (line 158) | def modify_arma_last(project):
  function remove_nargin (line 174) | def remove_nargin(project):
  function add_parameters (line 207) | def add_parameters(project):

FILE: src/matlab2cpp/mwrapmat.py
  class Wrapmat (line 6) | class Wrapmat:
    method __init__ (line 8) | def __init__(self):
    method __del__ (line 15) | def __del__(self):
    method eval_code (line 18) | def eval_code(self, builder):
    method _evaluate (line 47) | def _evaluate(self, code_block):

FILE: src/matlab2cpp/node/backend.py
  function flatten (line 12) | def flatten(node, ordered=False, reverse=False, inverse=False):
  function summary (line 58) | def summary(node, opt):
  function auxillary (line 131) | def auxillary(node, type, convert):
  function resize (line 225) | def resize(node):
  function error (line 258) | def error(node, msg, onlyw=False):
  function create_declare (line 307) | def create_declare(node):
  function suggest_datatype (line 373) | def suggest_datatype(node):
  function translate (line 467) | def translate(node, opt=None):
  function translate_one (line 507) | def translate_one(node, opt):
  function include (line 633) | def include(node, name, **kws):
  function wall_clock (line 733) | def wall_clock(node):
  function plotting (line 750) | def plotting(node):

FILE: src/matlab2cpp/node/frontend.py
  class Node (line 9) | class Node(object):
    method __init__ (line 132) | def __init__(self, parent=None, name="", value="", pointer=0,
    method summary (line 162) | def summary(self, args=None):
    method translate (line 175) | def translate(self, opt=None, only=False):
    method properties (line 193) | def properties(self):
    method auxiliary (line 262) | def auxiliary(self, type=None, convert=False):
    method resize (line 310) | def resize(self):
    method include (line 321) | def include(self, name, **kws):
    method warning (line 345) | def warning(self, msg):
    method error (line 357) | def error(self, msg):
    method create_declare (line 373) | def create_declare(self):
    method suggest_datatype (line 385) | def suggest_datatype(self):
    method wall_clock (line 394) | def wall_clock(self):
    method __getitem__ (line 402) | def __getitem__(self, index):
    method __contains__ (line 452) | def __contains__(self, i):
    method __setitem__ (line 461) | def __setitem__(self, key, val):
    method __len__ (line 464) | def __len__(self):
    method __str__ (line 467) | def __str__(self):
    method __add__ (line 470) | def __add__(self, val):
    method __radd__ (line 473) | def __radd__(self, val):
    method __iter__ (line 476) | def __iter__(self):
    method append (line 479) | def append(self, node):
    method pop (line 482) | def pop(self, index):
    method flatten (line 485) | def flatten(self, ordered=False, reverse=False, inverse=False):
    method plotting (line 521) | def plotting(self):

FILE: src/matlab2cpp/node/reference.py
  class Property_reference (line 21) | class Property_reference(object):
    method __init__ (line 24) | def __init__(self, name, default=None):
    method __get__ (line 27) | def __get__(self, instance, owner):
    method __set__ (line 30) | def __set__(self, instance, value):
  class Recursive_property_reference (line 33) | class Recursive_property_reference(object):
    method __init__ (line 36) | def __init__(self, name):
    method __get__ (line 39) | def __get__(self, instance, owner):
    method __set__ (line 52) | def __set__(self, instance, value):
  class File_reference (line 55) | class File_reference(object):
    method __get__ (line 56) | def __get__(self, instance, owner):
  class Line_reference (line 69) | class Line_reference(object):
    method __get__ (line 71) | def __get__(self, instance, owner):
  class Group_reference (line 95) | class Group_reference(object):
    method __get__ (line 97) | def __get__(self, instance, owner):
  class Func_reference (line 112) | class Func_reference(object):
    method __get__ (line 114) | def __get__(self, instance, owner):
  class Program_reference (line 127) | class Program_reference(object):
    method __get__ (line 128) | def __get__(self, instance, owner):
  class Project_reference (line 141) | class Project_reference(object):
    method __get__ (line 142) | def __get__(self, instance, owner):
  class Names (line 156) | class Names(object):
    method __get__ (line 157) | def __get__(self, instance, owner):
  class Declare_reference (line 161) | class Declare_reference(object):
    method __get__ (line 163) | def __get__(self, instance, owner):

FILE: src/matlab2cpp/parser.py
  function matlab_file_completer (line 20) | def matlab_file_completer(prefix, **kws):
  function create_parser (line 25) | def create_parser():

FILE: src/matlab2cpp/qfunctions.py
  function build (line 28) | def build(
  function qcpp (line 99) | def qcpp(code, suggest=True, **kws):
  function qhpp (line 196) | def qhpp(code, suggest=False):
  function qpy (line 315) | def qpy(code, suggest=True, prefix=False):
  function qlog (line 393) | def qlog(code, suggest=False, **kws):
  function qtree (line 450) | def qtree(code, suggest=False, core=False):
  function qscript (line 544) | def qscript(code, suggest=True, ftypes={}, **kws):

FILE: src/matlab2cpp/rules/_cell.py
  function Cell (line 3) | def Cell(node):
  function Assign (line 11) | def Assign(node):

FILE: src/matlab2cpp/rules/_code_block.py
  function Statement (line 13) | def Statement(node):
  function While (line 44) | def While(node):
  function Branch (line 72) | def Branch(node):
  function If (line 109) | def If(node):
  function Elif (line 146) | def Elif(node):
  function Else (line 190) | def Else(node):
  function Switch (line 232) | def Switch(node):
  function Case (line 273) | def Case(node):
  function Otherwise (line 324) | def Otherwise(node):
  function Tryblock (line 354) | def Tryblock(node):
  function Try (line 387) | def Try(node):
  function Catch (line 404) | def Catch(node):
  function Block (line 431) | def Block(node):
  function Assigns (line 467) | def Assigns(node):
  function Parfor (line 509) | def Parfor(node):
  function For (line 604) | def For(node):
  function Pragma_for (line 705) | def Pragma_for(node):
  function Bcomment (line 711) | def Bcomment(node):
  function Lcomment (line 731) | def Lcomment(node):
  function Ecomment (line 751) | def Ecomment(node):

FILE: src/matlab2cpp/rules/_expression.py
  function Paren (line 4) | def Paren(node):
  function End (line 14) | def End(node):
  function Return (line 57) | def Return(node):
  function Mul (line 95) | def Mul(node):
  function Elmul (line 198) | def Elmul(node):
  function Plus (line 227) | def Plus(node):
  function Minus (line 254) | def Minus(node):
  function Elementdivision (line 278) | def Elementdivision(node):
  function Leftelementdivision (line 329) | def Leftelementdivision(node):
  function Matrixdivision (line 365) | def Matrixdivision(node):
  function Leftmatrixdivision (line 461) | def Leftmatrixdivision(node):
  function Exp (line 557) | def Exp(node):
  function Elexp (line 567) | def Elexp(node):
  function All (line 587) | def All(node):
  function Transpose (line 613) | def Transpose(node):
  function Ctranspose (line 642) | def Ctranspose(node):
  function Colon (line 666) | def Colon(node):

FILE: src/matlab2cpp/rules/_func_lambda.py
  function Get (line 10) | def Get(node):
  function Lambda (line 27) | def Lambda(node):
  function Params (line 72) | def Params(node):
  function Declares (line 84) | def Declares(node):

FILE: src/matlab2cpp/rules/_func_return.py
  function Var (line 32) | def Var(node):
  function Params (line 61) | def Params(node):
  function Declares (line 97) | def Declares(node):
  function Func (line 165) | def Func(node):
  function Main (line 212) | def Main(node):

FILE: src/matlab2cpp/rules/_func_returns.py
  function Func (line 10) | def Func(node):
  function Var (line 50) | def Var(node):
  function Assign (line 73) | def Assign(node):
  function Assigns (line 79) | def Assigns(node):
  function Returns (line 117) | def Returns(node):
  function Params (line 139) | def Params(node):
  function Declares (line 172) | def Declares(node):

FILE: src/matlab2cpp/rules/_matrix.py
  function Vector (line 17) | def Vector(node):
  function Matrix (line 54) | def Matrix(node):
  function Assign (line 151) | def Assign(node):
  function Cell (line 237) | def Cell(node):

FILE: src/matlab2cpp/rules/_program.py
  function add_indenting (line 7) | def add_indenting(text):
  function number_fix (line 34) | def number_fix(text):
  function strip (line 60) | def strip(text):
  function Project (line 79) | def Project(node):
  function Program (line 82) | def Program(node):
  function Includes (line 86) | def Includes(node):
  function Headers (line 89) | def Headers(node):
  function Header (line 93) | def Header(node):
  function Funcs (line 142) | def Funcs(node):
  function Inlines (line 151) | def Inlines(node):
  function Inline (line 171) | def Inline(node):
  function Log (line 176) | def Log(node):
  function Error (line 180) | def Error(node):
  function Warning (line 186) | def Warning(node):
  function Struct (line 192) | def Struct(node):

FILE: src/matlab2cpp/rules/_reserved.py
  function Var (line 39) | def Var(node):
  function Get_NaN (line 51) | def Get_NaN(node):
  function conv_to (line 54) | def conv_to(str, type):
  function Assign_elemwise_ (line 57) | def Assign_elemwise_(node):
  function Get_exp (line 74) | def Get_exp(node):
  function Get_log (line 83) | def Get_log(node):
  function Get_log2 (line 91) | def Get_log2(node):
  function Get_log10 (line 100) | def Get_log10(node) :
  function Get_power (line 107) | def Get_power(node):
  function Get_floor (line 114) | def Get_floor(node):
  function Get_ceil (line 127) | def Get_ceil(node):
  function Get_round (line 136) | def Get_round(node):
  function Get_fix (line 162) | def Get_fix(node):
  function Assign_fix (line 174) | def Assign_fix(node):
  function Get_cos (line 177) | def Get_cos(node):
  function Get_acos (line 184) | def Get_acos(node):
  function Get_cosh (line 191) | def Get_cosh(node):
  function Get_acosh (line 198) | def Get_acosh(node):
  function Get_sin (line 206) | def Get_sin(node):
  function Get_asin (line 213) | def Get_asin(node):
  function Get_sinh (line 220) | def Get_sinh(node):
  function Get_asinh (line 227) | def Get_asinh(node):
  function Get_mod (line 240) | def Get_mod(node):
  function Get_abs (line 246) | def Get_abs(node):
  function Get_sqrt (line 256) | def Get_sqrt(node):
  function Get_and (line 263) | def Get_and(node):
  function Get_or (line 266) | def Get_or(node):
  function Get_not (line 270) | def Get_not(node):
  function Get_any (line 276) | def Get_any(node):
  function Get_all (line 286) | def Get_all(node):
  function Get_isequal (line 298) | def Get_isequal(node):
  function Var_return (line 301) | def Var_return(node):
  function Get_size (line 309) | def Get_size(node):
  function Assign_size (line 384) | def Assign_size(node):
  function Assigns_size (line 392) | def Assigns_size(node):
  function Get_chol (line 429) | def Get_chol(node):
  function Assign_chol (line 433) | def Assign_chol(node):
  function Assigns_chol (line 442) | def Assigns_chol(node):
  function Get_unique (line 460) | def Get_unique(node):
  function Assign_unique (line 464) | def Assign_unique(node):
  function Assigns_unique (line 469) | def Assigns_unique(node):
  function Get_sortrows (line 474) | def Get_sortrows(node):
  function Get_intersect (line 479) | def Get_intersect(node):
  function Assign_intersect (line 484) | def Assign_intersect(node):
  function Assigns_intersect (line 494) | def Assigns_intersect(node):
  function Get_length (line 499) | def Get_length(node):
  function Get_isempty (line 507) | def Get_isempty(node):
  function Get_min (line 511) | def Get_min(node):
  function Assigns_min (line 561) | def Assigns_min(node):
  function Get_max (line 579) | def Get_max(node):
  function Assigns_max (line 630) | def Assigns_max(node):
  function Get_eye (line 652) | def Get_eye(node):
  function Get_trace (line 670) | def Get_trace(node):
  function Get_transpose (line 673) | def Get_transpose(node):
  function Get_ctranspose (line 679) | def Get_ctranspose(node):
  function Get_fliplr (line 685) | def Get_fliplr(node):
  function Get_flipud (line 688) | def Get_flipud(node):
  function Get_ones (line 692) | def Get_ones(node):
  function Get_zeros (line 740) | def Get_zeros(node):
  function Get_qr (line 791) | def Get_qr(node):
  function Assign_qr (line 794) | def Assign_qr(node):
  function Assigns_qr (line 797) | def Assigns_qr(node):
  function Var_rand (line 800) | def Var_rand(node):
  function Get_rand (line 804) | def Get_rand(node):
  function Var_clear (line 807) | def Var_clear(node):
  function Get_clear (line 815) | def Get_clear(node):
  function Var_close (line 818) | def Var_close(node):
  function Get_close (line 821) | def Get_close(node):
  function Var_clc (line 824) | def Var_clc(node):
  function Get_clc (line 827) | def Get_clc(node):
  function Var_clf (line 830) | def Var_clf(node):
  function Get_clf (line 833) | def Get_clf(node):
  function Var_more (line 836) | def Var_more(node):
  function Get_more (line 839) | def Get_more(node):
  function Var_format (line 842) | def Var_format(node):
  function Get_format (line 845) | def Get_format(node):
  function Get__conv_to (line 848) | def Get__conv_to(node):
  function Get__reshape (line 851) | def Get__reshape(node):
  function Get_reshape (line 854) | def Get_reshape(node):
  function Get_nextpow2 (line 857) | def Get_nextpow2(node):
  function Assign_fft (line 862) | def Assign_fft(node):
  function Assign_ifft (line 869) | def Assign_ifft(node):
  function Get_fft (line 872) | def Get_fft(node):
  function Get_ifft (line 900) | def Get_ifft(node):
  function Get_fft2 (line 937) | def Get_fft2(node):
  function Get_ifft2 (line 944) | def Get_ifft2(node):
  function Assign_fft2 (line 951) | def Assign_fft2(node):
  function Assign_ifft2 (line 954) | def Assign_ifft2(node):
  function Get_hankel (line 958) | def Get_hankel(node):
  function Get_interp1 (line 962) | def Get_interp1(node):
  function Assign_interp1 (line 976) | def Assign_interp1(node):
  function Get_linspace (line 979) | def Get_linspace(node):
  function Get_sum (line 983) | def Get_sum(node):
  function Get_cumsum (line 1031) | def Get_cumsum(node):
  function Get_conj (line 1039) | def Get_conj(node):
  function Get_imag (line 1049) | def Get_imag(node):
  function Get_real (line 1052) | def Get_real(node):
  function Var_tic (line 1056) | def Var_tic(node):
  function Get_tic (line 1059) | def Get_tic(node):
  function Assign_tic (line 1064) | def Assign_tic(node):
  function Var_toc (line 1069) | def Var_toc(node):
  function Get_toc (line 1072) | def Get_toc(node):
  function Get_diag (line 1083) | def Get_diag(node):
  function Get_tril (line 1088) | def Get_tril(node):
  function Get_triu (line 1091) | def Get_triu(node):
  function Var_disp (line 1094) | def Var_disp(node):
  function Get_disp (line 1097) | def Get_disp(node):
  function Get_fprintf (line 1110) | def Get_fprintf(node):
  function Get_error (line 1118) | def Get_error(node):
  function Get_convmtx (line 1123) | def Get_convmtx(node):
  function Get_conv2 (line 1127) | def Get_conv2(node):
  function Get_figure (line 1133) | def Get_figure(node):
  function Var_hold (line 1137) | def Var_hold(node):
  function Get_hold (line 1140) | def Get_hold(node):
  function Var_load (line 1157) | def Var_load(node):
  function Get_load (line 1160) | def Get_load(node):
  function Var_clf (line 1172) | def Var_clf(node):
  function Get_clf (line 1175) | def Get_clf(node):
  function Var_cla (line 1179) | def Var_cla(node):
  function Get_cla (line 1182) | def Get_cla(node):
  function Get_show (line 1186) | def Get_show(node):
  function Get_xlabel (line 1190) | def Get_xlabel(node):
  function Get_ylabel (line 1194) | def Get_ylabel(node):
  function Get_title (line 1198) | def Get_title(node):
  function Get_plot (line 1202) | def Get_plot(node):
  function Get_imshow (line 1263) | def Get_imshow(node):
  function Get_imagesc (line 1267) | def Get_imagesc(node):
  function Get_wigb (line 1271) | def Get_wigb(node):
  function Var_colorbar (line 1275) | def Var_colorbar(node):
  function Get_colorbar (line 1278) | def Get_colorbar(node):
  function Get_xlim (line 1282) | def Get_xlim(node):
  function Get_ylim (line 1316) | def Get_ylim(node):
  function Get_caxis (line 1349) | def Get_caxis(node):
  function Get_axis (line 1381) | def Get_axis(node):
  function Var_grid (line 1417) | def Var_grid(node):
  function Get_grid (line 1420) | def Get_grid(node):
  function Get_subplot (line 1437) | def Get_subplot(node):
  function Get_colormap (line 1441) | def Get_colormap(node):
  function Get__splot (line 1453) | def Get__splot(node):
  function Get_logspace (line 1456) | def Get_logspace(node):
  function Get_find (line 1465) | def Get_find(node):

FILE: src/matlab2cpp/rules/_string.py
  function String (line 6) | def String(node):

FILE: src/matlab2cpp/rules/_struct.py
  function Matrix (line 9) | def Matrix(node):

FILE: src/matlab2cpp/rules/_structs.py
  function Counter (line 7) | def Counter(node):
  function Fget (line 13) | def Fget(node):
  function Fset (line 16) | def Fset(node):
  function Matrix (line 19) | def Matrix(node):

FILE: src/matlab2cpp/rules/_unknown.py
  function Assigns (line 7) | def Assigns(node):
  function Matrix (line 13) | def Matrix(node):
  function Get (line 16) | def Get(node):
  function Set (line 44) | def Set(node):

FILE: src/matlab2cpp/rules/armadillo.py
  function configure_arg (line 7) | def configure_arg(node, index):
  function scalar_assign (line 115) | def scalar_assign(node):
  function include (line 166) | def include(node):

FILE: src/matlab2cpp/rules/assign.py
  function Assign (line 4) | def Assign(node):

FILE: src/matlab2cpp/rules/cube.py
  function Get (line 4) | def Get(node):
  function Set (line 98) | def Set(node):
  function Resize (line 190) | def Resize(node):

FILE: src/matlab2cpp/rules/function.py
  function type_string (line 3) | def type_string(node):

FILE: src/matlab2cpp/rules/mat.py
  function Get (line 3) | def Get(node):
  function Set (line 110) | def Set(node):

FILE: src/matlab2cpp/rules/parallel.py
  function variable_lists (line 2) | def variable_lists(node):
  function omp (line 64) | def omp(node, start, stop, step):
  function tbb (line 80) | def tbb(node, start, stop, step):

FILE: src/matlab2cpp/rules/rowvec.py
  function Get (line 3) | def Get(node):
  function Set (line 53) | def Set(node):

FILE: src/matlab2cpp/rules/variables.py
  function Var (line 2) | def Var(node):
  function Fvar (line 7) | def Fvar(node):
  function Cvar (line 17) | def Cvar(node):
  function Set (line 28) | def Set(node):
  function Cset (line 35) | def Cset(node):
  function Sset (line 53) | def Sset(node):
  function Nset (line 59) | def Nset(node):
  function Get (line 62) | def Get(node):
  function Cget (line 65) | def Cget(node):
  function Fget (line 83) | def Fget(node):
  function Sget (line 89) | def Sget(node):
  function Nget (line 92) | def Nget(node):

FILE: src/matlab2cpp/rules/vec.py
  function Get (line 4) | def Get(node):
  function Set (line 60) | def Set(node):

FILE: src/matlab2cpp/setpaths.py
  function multiple_folder_paths (line 4) | def multiple_folder_paths(setpath_file):

FILE: src/matlab2cpp/supplement/__init__.py
  function str_variables (line 26) | def str_variables(types_f={}, types_s={}, types_i=[],

FILE: src/matlab2cpp/supplement/functions.py
  function set (line 4) | def set(node, types):
  function get (line 32) | def get(node):
  class Ftypes (line 59) | class Ftypes(object):
    method __get__ (line 61) | def __get__(self, instance, owner):
    method __set__ (line 63) | def __set__(self, instance, value):

FILE: src/matlab2cpp/supplement/includes.py
  function set (line 6) | def set(node, types):
  function get (line 18) | def get(node):
  function write_to_includes (line 29) | def write_to_includes(include_string):
  class Itypes (line 38) | class Itypes(object):
    method __get__ (line 40) | def __get__(self, instance, owner):
    method __set__ (line 43) | def __set__(self, instance, value):

FILE: src/matlab2cpp/supplement/structs.py
  function set (line 5) | def set(node, types):
  function get (line 34) | def get(node):
  class Stypes (line 56) | class Stypes(object):
    method __get__ (line 58) | def __get__(self, instance, owner):
    method __set__ (line 61) | def __set__(self, instance, value):

FILE: src/matlab2cpp/supplement/suggests.py
  function get (line 1) | def get(node):
  class Sstypes (line 47) | class Sstypes(object):
    method __get__ (line 49) | def __get__(self, instance, owner):
    method __set__ (line 52) | def __set__(self, instance, value):

FILE: src/matlab2cpp/supplement/verbatim.py
  function set (line 4) | def set(D, code):
  function get (line 23) | def get(node):
  class Vtypes (line 34) | class Vtypes(object):
    method __get__ (line 36) | def __get__(self, instance, owner):

FILE: src/matlab2cpp/tree/assign.py
  function multi (line 18) | def multi(self, parent, cur, eq_loc):
  function single (line 96) | def single(self, parent, cur, eq_loc):

FILE: src/matlab2cpp/tree/branches.py
  function trybranch (line 24) | def trybranch(self, parent, cur):
  function switch (line 111) | def switch(self, parent, cur):
  function whileloop (line 240) | def whileloop(self, parent, cur):
  function parforloop (line 315) | def parforloop(self, parent, cur):
  function forloop (line 369) | def forloop(self, parent, cur):
  function ifbranch (line 470) | def ifbranch(self, parent, start):

FILE: src/matlab2cpp/tree/builder.py
  class Builder (line 5) | class Builder(object):
    method __init__ (line 52) | def __init__(self, disp=False, comments=True, original=False, enable_o...
    method __getitem__ (line 76) | def __getitem__(self, index):
    method __str__ (line 97) | def __str__(self):
    method load (line 117) | def load(self, name, code):
    method get_unknowns (line 201) | def get_unknowns(self, index=-1):
    method configure (line 222) | def configure(self, suggest=True, **kws):
    method translate (line 296) | def translate(self):
    method syntaxerror (line 312) | def syntaxerror(self, cur, text):
    method create_program (line 351) | def create_program(self, name):
    method create_function (line 378) | def create_function(self, parent, cur):
    method create_main (line 404) | def create_main(self, parent, cur):
    method create_lambda_assign (line 430) | def create_lambda_assign(self, parent, cur, eq_loc):
    method create_lambda_func (line 455) | def create_lambda_func(self, parent, cur):
    method create_codeblock (line 489) | def create_codeblock(self, parent, cur):
    method create_assigns (line 523) | def create_assigns(self, parent, cur, eq_loc):
    method create_assign (line 548) | def create_assign(self, parent, cur, eq_loc):
    method create_parfor (line 572) | def create_parfor(self, parent, cur):
    method create_for (line 593) | def create_for(self, parent, cur):
    method create_if (line 618) | def create_if(self, parent, cur):
    method create_while (line 654) | def create_while(self, parent, cur):
    method create_switch (line 678) | def create_switch(self, parent, cur):
    method create_try (line 712) | def create_try(self, parent, cur):
    method create_cell (line 738) | def create_cell(self, parent, cur):
    method create_pragma_parfor (line 759) | def create_pragma_parfor(self, parent, cur):
    method create_comment (line 764) | def create_comment(self, parent, cur):
    method create_verbatim (line 786) | def create_verbatim(self, parent, cur):
    method create_string (line 809) | def create_string(self, parent, cur):
    method create_list (line 830) | def create_list(self, parent, cur):
    method create_matrix (line 851) | def create_matrix(self, parent, cur):
    method create_number (line 877) | def create_number(self, parent, cur):
    method create_reserved (line 898) | def create_reserved(self, parent, cur):
    method create_variable (line 927) | def create_variable(self, parent, cur):
    method create_assign_variable (line 948) | def create_assign_variable(self, parent, cur, end=None):
    method create_expression (line 971) | def create_expression(self, parent, cur, end=None):

FILE: src/matlab2cpp/tree/codeblock.py
  function codeblock (line 8) | def codeblock(self, parent, start):

FILE: src/matlab2cpp/tree/expression.py
  function create (line 33) | def create(self, node, start, end=None, start_opr=None):

FILE: src/matlab2cpp/tree/findend.py
  function expression (line 33) | def expression(self, start):
  function expression_space (line 96) | def expression_space(self, start):
  function matrix (line 169) | def matrix(self, start):
  function string (line 228) | def string(self, start):
  function pragma_for (line 252) | def pragma_for(self,start):
  function tbb_for (line 261) | def tbb_for(self, start):
  function comment (line 269) | def comment(self, start):
  function verbatim (line 300) | def verbatim(self, start):
  function dots (line 317) | def dots(self, start):
  function paren (line 339) | def paren(self, start):
  function cell (line 378) | def cell(self, start):

FILE: src/matlab2cpp/tree/functions.py
  function program (line 25) | def program(self, name):
  function function (line 110) | def function(self, parent, cur):
  function main (line 327) | def main(self, parent, cur):
  function lambda_assign (line 381) | def lambda_assign(self, node, cur, eq_loc):
  function lambda_func (line 469) | def lambda_func(self, node, cur):

FILE: src/matlab2cpp/tree/identify.py
  function space_delimiter (line 20) | def space_delimiter(self, start):
  function string (line 63) | def string(self, k):
  function space_delimited (line 96) | def space_delimited(self, start):

FILE: src/matlab2cpp/tree/iterate.py
  function comma_list (line 18) | def comma_list(self, start):
  function space_list (line 82) | def space_list(self, start):

FILE: src/matlab2cpp/tree/misc.py
  function number (line 7) | def number(self, node, start):
  function string (line 135) | def string(self, parent, cur):
  function list (line 180) | def list(self, parent, cur):
  function pragma_for (line 236) | def pragma_for(self, parent, cur):
  function comment (line 256) | def comment(self, parent, cur):
  function verbatim (line 316) | def verbatim(self, parent, cur):
  function matrix (line 345) | def matrix(self, node, cur):
  function cell (line 445) | def cell(self, node, cur):
  function reserved (line 510) | def reserved(self, node, start):

FILE: src/matlab2cpp/tree/suppliment.py
  class Fbuilder (line 2) | class Fbuilder(object):
    method __get__ (line 4) | def __get__(self, instance, owner):
    method __set__ (line 9) | def __set__(self, instance, value):
  class Ibuilder (line 14) | class Ibuilder(object):
    method __get__ (line 16) | def __get__(self, instance, owner):
    method __set__ (line 21) | def __set__(self, instance, value):
  class Sbuilder (line 26) | class Sbuilder(object):
    method __get__ (line 28) | def __get__(self, instance, owner):
    method __set__ (line 33) | def __set__(self, instance, value):
  class Vbuilder (line 38) | class Vbuilder(object):
    method __get__ (line 40) | def __get__(self, instance, owner):
    method __set__ (line 45) | def __set__(self, instance, value):

FILE: src/matlab2cpp/tree/variables.py
  function assign (line 9) | def assign(self, parent, cur, end=None):
  function variable (line 258) | def variable(self, parent, cur):
  function cell_arg (line 501) | def cell_arg(self, cset, cur):

FILE: test/data/function_reference.hpp
  function irowvec (line 10) | irowvec f(irowvec x)
  function g (line 17) | void g()

FILE: test/data/function_reference_2.hpp
  function f (line 10) | void f(irowvec a, ivec b, irowvec& y, ivec& z)
  function g (line 16) | void g()

FILE: test/data/fx_decon.cpp
  function mat (line 12) | mat fx_decon(mat DATA, double dt, int lf, double mu, double flow, int fh...
  function ar_modeling (line 56) | void ar_modeling(cx_vec x, int lf, double mu, cx_vec& yf, cx_vec& yb)

FILE: test/data/simple_assignment.cpp
  function main (line 4) | int main(int argc, char** argv)

FILE: test/test_conversion.py
  function test_fx_decon (line 5) | def test_fx_decon():

FILE: test/test_simple_assignment.py
  function cpp_filename (line 10) | def cpp_filename(request):
  function test_cpp_executables (line 14) | def test_cpp_executables(cpp_filename):
  function hpp_filename (line 31) | def hpp_filename(request):
  function test_hpp_executables (line 35) | def test_hpp_executables(hpp_filename):