Please note that the recommended version of Scilab is 2023.1.0. This page might be outdated.
See the recommended documentation of this function
brackets [,;]
Concatenation. Recipients of an assignment. Results of a function
Syntax
Mh = [m11 m12 m13.. m1N] or [m11, m12, m13,.., m1N] Mv = [m11 ; m21 ; m31..; mN1] M = [m11, m12,...; m21, m22,...;...] [r1, r2,...] = func(...) [r1, r2,.., rN] = (e1, e2, .., eN) [r1, r2,.., rk] = (e1, e2, .., ek,.., eN) [r1, r2,.., rN] = mylist(:) [r1, r2,.., rN] = S.field([i1 i2.. iN])
Arguments
 m11, m12,...
Set of objects to be concatenated (and merged: the former individual containers are removed). The following subsets of types of objects can be mixed inbetween, but are mutually exclusive:
 Matrices of booleans, reals, complex numbers, polynomials, rationals: The data type of the concatenated result is set by the rules defined below (see the type conversions rules).
 Matrices of encoded integers of any
inttype.
Encoded integers of different inttypes can't be concatenated together.
 Arrays of cells.
 Arrays of structures with same fields. Fields may be in different orders from an array to other ones.
 Typed lists of type syslin.
 M, Mh, Mv
Matrices with the type of all
m##
(if they all have the same data type). cells arrays (ifmi
are so). structures arrays (ifmi
are so). e1, e2,..
Input objects (literals like
1.23
or"abcd"
, variables, or expressions likea+%pi
, etc). mylist
a simple list
 S.field
Array of Structures with a field named
field
. i1, i2,..
Indices of components selected from
S
. r1, r2,...
Output variables
Description
 [] on righthand side: concatenators
[..] bundle their contents of simple and compatible types into a homogeneous vector, matrix or hypermatrix.
An horizontal or a vertical concatenation is a binary iterated operator. It is performed stepbystep from lefttoright, and from toptobottom. Thus,[1 3 5 7]
is performed as[[[1 3] 5] 7]
.Inside brackets,
 spaces (blanks or tabs) or commas are used as columns separators.
Using commas instead of spaces is safer. For instance,
[2 1 +%i]
means[2, 1, %i]
, while[2 1 + %i]
means[2, 1+%i]
 semicolons or carriagereturn are used as rows separators.
Multiple rows do not need the continuation dots
..
Types conversions
In some limits, brackets may be applied on a set of data having different but compatible types. In this case, some data are converted into the dominating type available in the set. The main conversion rules are the following:
 boolean < encoded integers.
 boolean < decimal number < complex
 decimal number < polynomial < rational
booleans and polynomials are not compatible.
[%t 2. %z]
is accepted:[%t 2.]
is first converted into[1. 2.]
, and then[[1. 2.] %z]
is accepted.[%z %t 2.]
is rejected and yields an error. Indeed,[%z %t]
can't be converted first.
 The result becomes complexencoded as soon as a complexencoded
component  value, polynomial, or rational  is met in the
list (even with a null imaginary part)
Similarly, the result becomes sparseencoded as soon as a sparseencoded component is met and processed.
 It is possible to concatenate polynomials or/and rationals
having different variable names. Then, the first polynomial
or rational met in the list sets the variable name to the
concatenation result:
[%z, 1+%s, 1%i*%s] // => [z, 1+z, 1iz]
.  Any encoded integer can be concatenated only with booleans or
with integers of the same inttype. Thus, the expressions
[int8(2) uint8(7)]
,[int8(2) int16(7)]
,[int8(2) 1.]
will all yield an error.  Text components can be concatenated (in the set meaning,
with brackets) only with other text components or with the
empty matrix
[]
.
Overloading
 [,]: horizontal concatenation:
This operator is binary and automatically
iterated from left to right. Its overloading
code is
"c"
.  [;]: vertical concatenation:
This operator is binary and automatically
iterated from top to bottom. Its overloading
code is
"f"
.
 spaces (blanks or tabs) or commas are used as columns separators.
 [] on lefthand side of a
"="
assignment In this case, brackets are no longer concatenators. They are used as left and right delimiters of a series of variables used as recipients.
 Recipients must be variables. Literal expressions are not accepted.
 Variables shall be separated with comas.
 In a distributive assignment, there must
be at most as many LHS recipients
as output sources, not more. If there are less
recipients on the left than sources on the right,
noncollected data sources are ignored. Examples :
[a,b]=(%pi,"Hi", %z)
is OK, but%z
is ignored.[a,b,c]=(%pi,"Hi")
yields an error becausec
expects some foods.
[a,b,a] = (%pi, %z, "Allo")
performs assignments from left to right, such that finallya = "Allo"
.
Examples
// Horizontal concatenations a = [ %pi 4 1 ] b1 = grand(3,4,"uin",0,10) b2 = grand(3,2,"uin",0,10) b = [b1 b2] // they must have the same number of rows // Vertical concatenations a = [2 ; 10 ; 7] b1 = grand(2,4,"uin",0,10) b2 = grand(3,4,"uin",0,10) b = [b1 ; b2] // they must have the same number of columns // Mixed horizontal and vertical concatenations a = [ 3 7 ; 6, 5 ] b = [ 1:3 ; 7:3:13] c = [ a b ; a b] d = [ 3 5 1 4 ] e = [ d d d d d d ] // Concatenation of various types of data: ['this is' ; 'a column' ; 'of texts'] s = poly(0,'s');[1/s,2/s] [tf2ss(1/s),tf2ss(2/s)] [%t %f %f %T %F] // Heterogeneous concatenations with automatical types conversions [%T int8(5)] [%T %pi %f 2] [%pi, 2+%i, %F] v = [%pi+0*%i, %F, %z, (1%z)^2 ]; typeof(v), isreal(v) v = [10 1/%z], typeof(v) // Incompatible heterogeneous concatenations => ERRORS [%F %z] [int8(%pi) uint8(%e)] [int8(%pi) int16(%e)] [int8(%pi) %e] // Concatenation of cells arrays: c1 = {%pi %t}; c2 = {%z "abc"}; c = [[{%i} c1] ; [c2, {1/%z^2}]] // comma mandatory, to not parse c2{1/%z^2}
Distributive assignments:
// Output from a function. Most often, output results are serially optional: M = rand(3,3); [u, s] = schur(M) // we expect and use both results u and s u = schur(M) // we expect and store only the first result u // Direct RHS list [a, b, c] = (%pi, %t, "test") [a, b] = (%e, %f, "Hello") [a, b, a] = (%pi, %t, "test"); a // Explicit RHS list L = list(%z, %i, %t, %pi, "Text"); [a, b, c] = L(:) // RHS structure s(2,3).r = %pi; s(2,1).r = %i; s(2,2) = %e; s(2,:).r s.r([2 4 6]) [a, b, c] = s.r([2 4 6]) // Forbidden / Rejected LHS expressions (=> error) [m, n, m+n] = myfun(a,b) // Symbolic expressions like "m+n" are forbidden [p, 4.5, q] = myfun(a,b) // Literal LHS values or expressions like "4.5" are forbidden [r, s+3 ] = myfun(a,b) // Expressions mixing literals and symbols like "s+3" can't be LHS recipients
> [a, b, c] = (%pi, %t, "test") a = 3.1415927 b = T c = test > [a, b] = (%e, %f, "Hello") a = 2.7182818 b = F > [a, b, a] = (%pi, %t, "test"); a a = test
See also
 cat — stacks vectors matrices or arrays into an hypermatrix or hyperarray
 lstcat — list concatenation
 comma — (,) comma; instruction, argument separator
 semicolon — (;) ending expression and row separator
 parentheses — ( ) left and right parenthesis
 empty — empty matrix. Array ranges destructor.
 overloading — display, functions and operators overloading capabilities
History
Version  Description 
6.0  Brackets [..] and braces
{..} are no longer equivalent 
6.1 

Report an issue  
<< backslash  Scilab keywords  colon (:) >> 