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`
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

- tlist
- disp
- symbols
- typeof
- type
- typename

## Histórico

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.