Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Change language to: Français - Português - 日本語 - Русский

See the recommended documentation of this function

Scilab Help >> Scilab > Scilab keywords > dot

# dot

(.) symbol

### Syntax

```123.33

a.*b
a .*. b

%pi * (%e + ..
%i)

cd ..
dir ..```

### Description

.

Dot is used to mark decimal point for numbers : 3.25 and 0.001

.<op>

used in conjunction with other operator symbols (`*/ \ ^ '`) to form other operators. Element-by-element multiplicative operations are obtained using `.* , .^ , ./ , .\` or `.'`. For example, `C = A ./ B` is the matrix with elements `c(i,j) = a(i,j)/b(i,j)`. Kronecker product is noted `.*.` . Note that when dot is used with an operation, it is not considered part of the number directly preceding the dot, therefore `2.*x` and `2 .*x` are evaluated as `(2).*x` and not as `2.0*x`.

..

Continuation mark. Two or more dots at the end of a line (or followed by a comment) causes the following line to be a continuation.

Continuation lines are handled by a preprocessor which builds a long logical line from a sequence of continuation lines. So the continuation marks can be used to cut a line at any point.

The following function `foo`:

```function foo()
plot2d()
xtitle(["General title"; "It can be multiline, so quite long"], ..
"This is the X-axis title", "Y title")
endfunction```

is equivalent to:

```function foo()
plot2d()

xtitle(["General title"; "It can be multiline, so quite long"], "This is the X-axis title", "Y title")
endfunction```

The logical line formed by physical line 3 and physical line 4 is built as if it was entirely written in the physical line 4 while physical line 3 would be empty. This is done this way because continuation marks can be put anywhere even inside an expression. The difference between logical and physical lines is of importance when dealing with edition (scinotes, edit) and within error messages (whereami), when the line number is provided or displayed.

There are exceptions to this rule in a matrix environment to ease up readibility of scilab scripts. The following example shows some differences between the matrix and non matrix environment.

```// In the matrix environment .. is a continuation of the line
// except on some cases where readibility is important

// my_matrix == [1 2 3 -4 5 6]
my_matrix = [ 1 2 3 -4 5 6] // the minus sign here is unary

// my_matrix == [1 2 -1 5 6]
my_matrix = [ 1 2 3 -... // minus separated by .. is always considered a binary operation
4 5 6]```

An error is generated if the continuation mark is inside a language token, variable name, reserved word.

```// this is possible is Scilab
for a_word = 1:10
disp("test " + string(a_word))
end

// This generate an error
for a_...
word = 1:10
disp("test " + string(a_word))
end
// Scilab cannot parse this line```

An error is generated if any word except a comment is found after the continuation mark.

```this_wont_work = 3 + ... 4 // Scilab cannot parse this

this_wont_work_either = 3 + ... /* a multiline comment
followed by some text */ 4

this_works = 3 + ... /* a multiline comment
followed by text and a newline */
4```
".." parameter

When functions are used in a console-oriented way, `..` is not considered as a continuation mark but as a simple argument. The most common usage is with `cd ..`, `dir ..` or `ls ..` actually standing for `cd("..")`, etc.

### Examples

```//decimal point
1.345

//used as part of an operator
x = [1 2 3]; x .^2 .*x // a space is not required between 2 and dot

// When writing rows of a matrix on different lines, ".." can be used but are not mandatory.
N_row = [   ..
63.    89.    3.   ..
91.    56.    22.  ..
15.    64.    40.  ..
]
// Without the continuation mark, the matrix is read row by row:
N_square = [
63.    89.    3.
91.    56.    22.
15.    64.    40.
]

// Within very long instructions like when creating uicontrol where many properties must be set,
// continuation marks are almost mandatory and allow to write and set one property per line
// in a readable way. A single huge line would not comply with Scilab coding style:
fig = figure("figure_name", "FIGURE", ..
"dockable",    "off", ..
"axes_size",   [990,670], ..
"infobar_visible", "off", ..
"toolbar",     "none", ..
"default_axes","off", ..
"layout",      "border", ..
"background",  color(244,244,244), ..
"tag",         "figure_1", ..
"visible",     "on");

// Console-oriented calls with some ".." argument
d = pwd(); cd SCI/contrib
cd ..   // stands for cd("..") and expects nothing on the next line
cd(d)   // Go back to your working directory

// This expression does not work anymore in Scilab 6
a = "here I start a very long string...  //but I'm not in the mood of continuing
- and here I go on"
// This one is the correct expression now
a = "here I start a very long string"+...  //but I'm not in the mood of continuing
"    - and here I go on"
// This expression is not allowed anymore in Scilab 6: scalar number must be written on one line
y = 12..
45```

• star — (*) multiplication operator
• hat — (^) exponentiation
• slash — (/) right division and feed back
• backslash — (\) left matrix division.
• whereami — display current instruction calling tree
• edit — function editing

### History

 Version Description 6.0.0 It is not possible anymore to cut a scalar number. To cut a single string, "+.." operators must be used. In console-oriented calls, `myfun ..` no longer expects a continuation on the next line.