bsxfun.cc File Reference

#include <list>
#include <string>
#include <vector>
#include "lo-mappers.h"
#include "defun.h"
#include "interpreter.h"
#include "oct-map.h"
#include "ov-colon.h"
#include "ov-fcn-handle.h"
#include "unwind-prot.h"
#include "variables.h"

Go to the source code of this file.

Macros
#define	BSXDEF(T)
#define	BSXEND(T)
#define	BSXINIT(T, CLS, EXTRACTOR)
#define	BSXLOOP(T, CLS, EXTRACTOR)
#define	REGISTER_OP_HANDLER(OP, BTYP, NDA, FUNOP)    bsxfun_handler_table[OP][BTYP] = bsxfun_forward_op<NDA, FUNOP>
#define	REGISTER_REL_HANDLER(REL, BTYP, NDA, FUNREL)    bsxfun_handler_table[REL][BTYP] = bsxfun_forward_rel<NDA, FUNREL>
#define	REGISTER_STD_HANDLERS(BTYP, NDA)

Typedefs
typedef octave_value(*	bsxfun_handler) (const octave_value &, const octave_value &)

Enumerations
enum	bsxfun_builtin_op {   bsxfun_builtin_plus = 0 , bsxfun_builtin_minus , bsxfun_builtin_times , bsxfun_builtin_divide ,   bsxfun_builtin_max , bsxfun_builtin_min , bsxfun_builtin_eq , bsxfun_builtin_ne ,   bsxfun_builtin_lt , bsxfun_builtin_le , bsxfun_builtin_gt , bsxfun_builtin_ge ,   bsxfun_builtin_and , bsxfun_builtin_or , bsxfun_builtin_power , bsxfun_builtin_unknown ,   bsxfun_num_builtin_ops = bsxfun_builtin_unknown }

Functions
octave_value_list	Fbsxfun (octave::interpreter &interp, const octave_value_list &args, int)

Variables
const char *	bsxfun_builtin_names []
bsxfun_handler	bsxfun_handler_table [bsxfun_num_builtin_ops][btyp_num_types]

Macro Definition Documentation

BSXDEF

#define BSXDEF

(

T

)

Value:

          T result_ ## T;                       \
          bool have_ ## T = false;

BSXEND

#define BSXEND

(

T

)

Value:

          (have_ ## T)                          \
            retval(0) = result_ ## T;

BSXINIT

#define BSXINIT	(		T,
			CLS,
			EXTRACTOR
	)

Value:

              (result_type == CLS)                                      \
                {                                                       \
                  have_ ## T = true;                                    \
                  result_ ## T = tmp(0). EXTRACTOR ## _array_value ();  \
                  result_ ## T .resize (dvc);                           \
                }

BSXLOOP

#define BSXLOOP	(		T,
			CLS,
			EXTRACTOR
	)

Value:

                  (have_ ## T)                                          \
                    {                                                   \
                      if (tmp(0).class_name () != CLS)                  \
                        {                                               \
                          have_ ## T = false;                           \
                          C = result_ ## T;                             \
                          C = cat_op (C, tmp(0), ra_idx);       \
                        }                                               \
                      else                                              \
                        result_ ## T .insert (tmp(0). EXTRACTOR ## _array_value (), ra_idx); \
                    }

REGISTER_OP_HANDLER

#define REGISTER_OP_HANDLER	(		OP,
			BTYP,
			NDA,
			FUNOP
	)		bsxfun_handler_table[OP][BTYP] = bsxfun_forward_op<NDA, FUNOP>

REGISTER_REL_HANDLER

#define REGISTER_REL_HANDLER	(		REL,
			BTYP,
			NDA,
			FUNREL
	)		bsxfun_handler_table[REL][BTYP] = bsxfun_forward_rel<NDA, FUNREL>

REGISTER_STD_HANDLERS

#define REGISTER_STD_HANDLERS	(		BTYP,
			NDA
	)

Value:

  REGISTER_OP_HANDLER (bsxfun_builtin_plus, BTYP, NDA, bsxfun_add);     \
  REGISTER_OP_HANDLER (bsxfun_builtin_minus, BTYP, NDA, bsxfun_sub);    \
  REGISTER_OP_HANDLER (bsxfun_builtin_times, BTYP, NDA, bsxfun_mul);    \
  REGISTER_OP_HANDLER (bsxfun_builtin_divide, BTYP, NDA, bsxfun_div);   \
  REGISTER_OP_HANDLER (bsxfun_builtin_max, BTYP, NDA, bsxfun_max);      \
  REGISTER_OP_HANDLER (bsxfun_builtin_min, BTYP, NDA, bsxfun_min);      \
  REGISTER_REL_HANDLER (bsxfun_builtin_eq, BTYP, NDA, bsxfun_eq);       \
  REGISTER_REL_HANDLER (bsxfun_builtin_ne, BTYP, NDA, bsxfun_ne);       \
  REGISTER_REL_HANDLER (bsxfun_builtin_lt, BTYP, NDA, bsxfun_lt);       \
  REGISTER_REL_HANDLER (bsxfun_builtin_le, BTYP, NDA, bsxfun_le);       \
  REGISTER_REL_HANDLER (bsxfun_builtin_gt, BTYP, NDA, bsxfun_gt);       \
  REGISTER_REL_HANDLER (bsxfun_builtin_ge, BTYP, NDA, bsxfun_ge)

Typedef Documentation

bsxfun_handler

typedef octave_value(* bsxfun_handler) (const octave_value &, const octave_value &)

Definition at line 95 of file bsxfun.cc.

Enumeration Type Documentation

bsxfun_builtin_op

enum bsxfun_builtin_op

Enumerator
bsxfun_builtin_plus
bsxfun_builtin_minus
bsxfun_builtin_times
bsxfun_builtin_divide
bsxfun_builtin_max
bsxfun_builtin_min
bsxfun_builtin_eq
bsxfun_builtin_ne
bsxfun_builtin_lt
bsxfun_builtin_le
bsxfun_builtin_gt
bsxfun_builtin_ge
bsxfun_builtin_and
bsxfun_builtin_or
bsxfun_builtin_power
bsxfun_builtin_unknown
bsxfun_num_builtin_ops

Definition at line 45 of file bsxfun.cc.

Function Documentation

Fbsxfun()

octave_value_list Fbsxfun	(	octave::interpreter &	interp,
		const octave_value_list &	args,
		int
	)

Definition at line 317 of file bsxfun.cc.

References A, B, error(), symbol_table::find_function(), octave_value::function_value(), octave_value::is_builtin_function(), octave_value::is_function_handle(), octave_value::is_string(), octave_value::is_undefined(), print_usage(), and octave_value::string_value().

Variable Documentation

bsxfun_builtin_names

const char* bsxfun_builtin_names[]

Initial value:

=
{
  "plus",
  "minus",
  "times",
  "rdivide",
  "max",
  "min",
  "eq",
  "ne",
  "lt",
  "le",
  "gt",
  "ge",
  "and",
  "or",
  "power"
}

Definition at line 66 of file bsxfun.cc.

bsxfun_handler_table

bsxfun_handler bsxfun_handler_table[bsxfun_num_builtin_ops][btyp_num_types]

Definition at line 99 of file bsxfun.cc.