type

Arguments

x

a Scilab object: a variable or valid expression.

i

integer code identiying the type of x.

Description

type(x) returns an integer which is the type of x, defined as following:

1

decimal or complex numbers

2

polynomials with real or complex coefficients

4

booleans

5

a sparse matrix.

6

a sparse boolean matrix.

7

Matlab sparse matrix

8

integers stored on 1 (int8), 2 (int16), 4 (int32), or 8 (int64) bytes.

9

graphic handles.

10

text objects.

13

a compiled function in Scilab code.

14

library of compiled Scilab functions.

15

a simple list.

16

a typed list (tlist).

17

a matrix-oriented typed list (mlist).

128

an identifier of a Xcos block, of a lufact()'s result, etc.

129

a size implicit polynomial used for indexing.

130

a built-in Scilab function, aka gateway (C, C++ or Fortran code).

0

An undefined component of a simple list. Such a component may be met as an omitted input argument when calling Scilab function like in foo(a,,b): From within the function, the missing argument is defined but is of null type. Defining L=list(%pi,,%i,,,%z) creates L(2) of type 0; etc. For these objects, isdef() returns %T, but their null type can be tested with type()

Examples

// (Select some lines, right-click and choose "Execute.." to run the selection)
L = list(%pi,,"abc");
type(L(2))                  // undefined component of a list

type(42)                    // decimal numbers
type(%nan)
type(%inf)

type(1+%i)                  // complex numbers

s = sparse([1,2;4,5;3,10],[1,2,3]);
type(s)                     // sparse-encoded decimal or complex numbers

type(%t)                    // booleans

type(s>2)                   // sparse-encoded booleans

g = int8([1 -120 127 312]); // encoded integers
type(g)
type(1.23 * int8(4))

type(1-%z+%z^2)             // polynomials

type(gdf())                 // graphic handles

type("foo")                 // texts

deff('[x] = mymacro(y,z)',['a=3*y+1'; 'x=a*z+y']);
type(mymacro)               // Scilab functions

type(disp)                  // Built-in functions

l = list(1,["a" "b"]);      // simple lists
type(l)

e = tlist(["listtype","field1","field2"], [], []);
type(e)                     // Typed list

h = mlist(['V','name','value'],['a','b';'c' 'd'],[1 2; 3 4]);
type(h)                     // Typed matrix-oriented list

clear s, s.r = %pi          // structures
type(s)

c = {%t %pi %i %z "abc" s}  // cells
type(c)

r = [%z/(1-%z) (1-%z)/%z^2]
type(r)                     // rational fractions

See also

• typeof — explicit type or overloading code of an object
• inttype — type integers used in integer data types
• isreal — check if a variable is stored as a complex matrix
• brackets — Concatenation. Recipients of an assignment. Results of a function
• overloading — display, functions and operators overloading capabilities
• poly — polynomial definition
• rational — Scilab objects, rational in Scilab
• tlist — Scilab object and typed list definition.
• mlist — Scilab object, matrix oriented typed list definition

History