overloading

Description

In Scilab, variable display, functions and operators may be defined for new objects using functions (Scilab coded or primitives).

Display: The display of new objects defined by tlist structure may be overloaded (the default display is similar to list's one). The overloading function must have no output argument and a single input argument. It's name is formed as follow %<tlist_type>_p where %<tlist_type> stands for the first entry of the tlist type component truncated to the first 9 characters.
Operators: Each operator which is not defined for given operands type may be defined. The overloading function must have a single output argument and one or two inputs according to the number of operands. The function name is formed as follow:

for binary operators: %<first_operand_type>_<op_code>_<second_operand_type>;

for unary operators: %<operand_type>_<op_code>;

extraction and insertion operators which are n-nary operators are described below.

Be careful, only the types registered by the typename function can be used in an overloading macros.

<operand_type>, <first_operand_type>, <second_operand_type> are sequence of characters associated with each data type as described in the following table:

data type	char code	typeof	comments
double matrix	`s`	`constant`
polynomial matrix	`p`	`polynomial`
boolean matrix	`b`	`boolean`
sparse matrix	`sp`	`sparse`
boolean sparse matrix	`spb`	`boolean sparse`
integer matrix	`i`	`int8, int16, int32, int64, uint8, uint16, uint32, uint64`
string matrix	`c`	`string`
handle	`h`	`handle`
hard-coded function	`fptr`	`fptr`
script function	`function`	`function`
library	`f`	`library`
list	`l`	`list`
tlist	`tlist type`	`tlist type`	the first string in the first tlist entry
mlist	`mlist type`	`mlist type`	the first string in the first mlist entry
pointer	`ptr`	`pointer`
cell	`ce`	`ce`
structure	`st`	`st`
rational	`r`	`rational`
linear state space	`lss`	`state-space`
implicit list	`ip`	`implicitlist`	1:1:$
undefined\|null object	`0`	`listdelete, void`	see null(), list()

<op_code> is a single character associated with each operator as described in the following table:

`op`	char code
`'`	t
`+`	a
`-`	s
`*`	m
`/`	r
`\`	l
`^`	p
`.*`	x
`./`	d
`.\`	q
`.*.`	k
`./.`	y
`.\.`	z
`:`	b
`*.`	u
`/.`	v
`\.`	w
`[a,b]`	c
`[a;b]`	f
`() extraction`	e
`() insertion`	i
`==`	o
`<>`	n
`\|`	g
`&`	h
`.^`	j
`.'`	0
`<`	1
`>`	2
`<=`	3
`>=`	4
`~`	5
`iext`	6

The overloading function for extraction syntax b= a(i1, ..., in) has the following syntax: b = %<type_of_a>_e(i1, ..., in, a)

and the syntax [x1, .., xm] = a(i1, ..., in) has the following syntax: [x1, .., xm] = %<type_of_a>_e(i1, ..., in, a) .

The overloading function associated to the insertion syntax a(i1, ..., in) = b has the following syntax: a = %<type_of_b>_i_<type_of_a>(i1, ..., in, b, a) .

The 6 char code may be used for some complex insertion algorithm like x.b(2) = 33 where b field is not defined in the structure x. The insertion is automatically decomposed into temp = x.b; temp(2) = 33; x.b = temp. The 6 char code is used for the first step of this algorithm. The 6 overloading function is very similar to the e's one.

Functions :: Some basic primitive function may also be overloaded for new data type. When such function is undefined for a particular data types the function %<type_of_an_argument>_<function_name> is called. User may add in this called function the definition associated with the input data types.

Examples

//DISPLAY
            var = tlist('tab', ['a', 'b'], ['x'; 'y'], rand(2, 2)) // the type of var is 'tab'

            typeof(var)

            function []=%tab_p(l)
            disp([[' '; l(3)] [l(2); string(l(4))]])
            endfunction

            var // after overloading

//OPERATOR
            's' + 1 // it is impossible to add a number to a string

            function x=%c_a_s(a, b)
            x = a + string(b);
            endfunction

            's' + 1 // after overloading

//FUNCTION
            sin('2 * x') // the sin function does not work with a string

            function x=%c_sin(a)
            x = 'sin(' + a + ')'
            endfunction

            sin('2 * x') // after overloading

History

Version Description

6.0

function replaces mc as overloading code for functions in Scilab language.

hm is no longer used for hypermatrix, as for matrices s is used instead.

Report an issue
<< macrovar	Fonctions avancées	tree2code >>

Description

Examples

See also

History