overloading

capacidades de overloading ("sobrecarga") de exibições, funções e operadores

Descrição

No Scilab, exibições, funções e operadores de variáveis podem ser definidos para novos objetos utilizando funções (codificadas no Scilab ou primitivas).

Exibição (Display): a exibição de objetos definidos por uma estrutura tlist pode ser sobrecarregada (a exibição padrão é semelhante a de list's). A função de sobrecarga não deve ter argumentos de saída e deve ter um único argumento de entrada. Seu nome é formado como segue: %<tlist_type>_p onde %<tlist_type> significa a primeira entrada do componente do tipo tlist truncado aos 9 primeiros caracteres.
Operadores (Operators): cada operador que não está definido para dados tipos de operandos pode ser definido. A função de sobrecarga deve ter um único argumento de saída e um ou dois de entrada de acordo com o número de operandos. O nome da função é definido como segue:

para operadores binários: %<tipo_do_primeiro_operando>_<código_do_ operador>_<tipo_do_segundo_operando>

para operadores unários: %<tipo_do_operando>_<código_do_operador>

Operadores de extração e inserção que são n-nários são descritos abaixo.

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

<tipo_do_operando>, <tipo_do_primeiro_operando>, <tipo_do_segundo_operando> são seqüências de caracteres associadas a cada tipo de dado como descrito na tabela seguinte:

tipo de dado	código "char"
booleano	`b`
esparso booleano	`spb`
inteiro	`i`
número decimal	`s`
matriz esparsa	`sp`
matriz esparsa do Matlab	`msp`
polinômio	`p`
fração racional	`r`
texto	`c`
gráfico	`h`

tipo de dado	código "char"
`function`	`function`
hard-coded função	`fptr`
biblioteca	`f`
lista	`l`
tlist	`tlist_type`
mlist	`mlist_type`
lista implícita	`ip`
cell	`ce`
structure	`st`
linear dynamical system	`lss`
ponteiro	`ptr`
undefined\|null object	`0`

<código_do_operador> é um único caractere associado a cada operador como descrito na tabela seguinte:

`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

A função de sobrecarga para sintaxe de extração b=a(i1,...,in) tem a seguinte seqüência de chamamento: b=%<tipo_de_a>_e(i1,...,in,a)

e a sintaxe[x1,..,xm]=a(i1,...,in) tem a seguinte seqüência de chamamento: [x1,..,xm]=%<tipo_de_a>_e(i1,...,in,a)

A função de sobrecarga associada à sintaxe de inserção a(i1,...,in)=b tem a segunite seqüência de chamamento:a=%<tipo_de_b>_i_<tipo_de_a>(i1,...,in,b,a) .

O código "char" 6 pode ser usado para alguns algoritmos de inserção complexos como x.b(2) = 33 onde o campo b não está definido na estrutura x. A inserção é automaticamente decomposta em temp=x.b; temp(2) = 33; x.b = temp. O código "char" 6 é usado para o primeiro passo desse algoritmo. A função de sobrecarga de 6 é muito semelhante à função de e's.

Funções (Functions): algumas funções primitivas básicas também podem ser sobrecarregadas para novos tipo de dados. Quando tal função não é definida para tipos de dados particulares, a função %<tipo_de_um_argumento>_<nome_da_função> é chamada. O usuário pode adicionar a esta função chamada a definição associada aos tipos de dados de entrada.

Exemplos

//EXIBIÇÃO
            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

//OPERADOR
            '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

//FUNÇÃO
            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

Ver Também

Histórico

Versão	Descrição
6.0	`function` replaces `mc` as overloading code for functions in Scilab language.

Report an issue
<< macrovar	Funções	tree2code >>

Copyright (c) 2022-2024 (Dassault Systèmes)
Copyright (c) 2017-2022 (ESI Group)
Copyright (c) 2011-2017 (Scilab Enterprises)
Copyright (c) 1989-2012 (INRIA)
Copyright (c) 1989-2007 (ENPC)
with contributors

Last updated:
Mon Jan 03 14:35:42 CET 2022