conditional assignment octave

previous episode

Octave programming, making choices, next episode.

Overview Teaching: 30 min Exercises: 0 min Questions How can programs do different things for different data values? Objectives Construct a conditional statement using if, elseif, and else Test for equality within a conditional statement Combine conditional tests using AND and OR Build a nested loop

Our previous lessons have shown us how to manipulate data and repeat things. However, the programs we have written so far always do the same things, regardless of what data they’re given. We want programs to make choices based on the values they are manipulating.

The tool that Octave gives us for doing this is called a conditional statement , and it looks like this:

The second line of this code uses the keyword if to tell Octave that we want to make a choice. If the test that follows is true, the body of the if (i.e., the lines between if and else ) are executed. If the test is false, the body of the else (i.e., the lines between else and end ) are executed instead. Only one or the other is ever executed.

Conditional statements don’t have to have an else block. If there isn’t one, Octave simply doesn’t do anything if the test is false:

We can also chain several tests together using elseif . This makes it simple to write a script that gives the sign of a number:

One important thing to notice in the code above is that we use a double equals sign == to test for equality rather than a single equals sign. This is because the latter is used to mean assignment. In our test, we want to check for the equality of num and 0 , not assign 0 to num . This convention was inherited from C, and it does take a bit of getting used to…

We can also combine tests, using && (and) and || (or). && is true if both tests are true:

|| is true if either test is true:

In this case, “either” means “either or both”, not “either one or the other but not both”.

True and False Statements 1 and 0 aren’t the only values in Octave that are true or false. In fact, any value can be used in an if or elseif . After reading and running the code below, explain what the rule is for which values that are considered true and which are considered false. a. if '' disp('empty string is true') end b. if 'foo' disp('non empty string is true') end c. if [] disp ('empty array is true') end d. if [22.5, 1.0] disp ('non empty array is true') end e. if [0, 0] disp ('array of zeros is true') end f. if true disp('true is true') end

Close Enough Write a script called near that performs a test on two variables, and displays 1 when the first variable is within 10% of the other and 0 otherwise. Compare your implementation with your partner’s: do you get the same answer for all possible pairs of numbers?

Another thing to realize is that if statements can be also combined with loops. For example, if we want to sum the positive numbers in a list, we can write this:

With a little extra effort, we can calculate the positive and negative sums in a loop:

We can even put one loop inside another:

Nesting Will changing the order of nesting in the above loop change the output? Why? Write down the output you might expect from changing the order of the loops, then rewrite the code to test your hypothesis. Octave (and most other languges in the C family) provides in-place operators that work like this: x = 1; x += 1; x *= 3; Rewrite the code that sums the positive and negative values in an array using these in-place operators. Do you think that the result is more or less readable than the original?

Currently, our script analyze.m reads in data, analyzes it, and saves plots of the results. If we would rather display the plots interactively, we would have to remove (or comment out ) the following code:

And, we’d also have to change this line of code, from:

This is not a lot of code to change every time, but it’s still work that’s easily avoided using conditionals. Here’s our script re-written to use conditionals to switch between saving plots as images and plotting them interactively:

Key Points Use if and else to make choices based on values in your program.

Introduction to Octave: Loops and If Statements

1 for loops, 2 while loops, 3.1 relational operators, 3.2 logical operators, 3.3 elseif and else statements, 4 breaking out of a loop.

A for loop will run a piece of code again and again for a certain number of iterations:

A while loop will to continue to run while a certain condition is met. In this example, the cosine of an angle is calculated using the Taylor series with additional terms being added until Octave runs out of precision (ie until the new term does not change the value stored in Octave’s memory due to it being too small):

If you accidentally write a while loop that runs forever, press Ctrl+C to cancel it.

3 If Statements

Code that follows an if statement will only run if the statement is true:

You can use relational operators to construct statements:

• < : less than
• <= : less than or equal
• > : greater than
• >= : greater than or equal
• ~= : not equal

Multiple logical statements can be joined together by using logical operators:

• & : and

An if statement can be followed by one or more elseif statements and these can be followed by an else statement :

• If the original if statement is true, it will run
• Else if the original statement is false and the first elseif statement is true, then only the first elseif statement will run
• Else if the original if statement and the first elseif statement are both false and the second elseif statement is true, then only the second elseif statement will run
• This logic goes on for each elseif statement
• If all the if and elseif statements are false, then the else statement will run

The break command will break out of a loop (either a for loop or a while loop) if it is run. It can be put inside an if statement to allow the loop to run until the condition is met:

10.1 The if Statement

The if statement is Octave’s decision-making statement. There are three basic forms of an if statement. In its simplest form, it looks like this:

condition is an expression that controls what the rest of the statement will do. The then-body is executed only if condition is true.

The condition in an if statement is considered true if its value is nonzero, and false if its value is zero. If the value of the conditional expression in an if statement is a vector or a matrix, it is considered true only if it is non-empty and all of the elements are nonzero. The conceptually equivalent code when condition is a matrix is shown below.

The second form of an if statement looks like this:

If condition is true, then-body is executed; otherwise, else-body is executed.

Here is an example:

In this example, if the expression rem (x, 2) == 0 is true (that is, the value of x is divisible by 2), then the first printf statement is evaluated, otherwise the second printf statement is evaluated.

The third and most general form of the if statement allows multiple decisions to be combined in a single statement. It looks like this:

Any number of elseif clauses may appear. Each condition is tested in turn, and if one is found to be true, its corresponding body is executed. If none of the conditions are true and the else clause is present, its body is executed. Only one else clause may appear, and it must be the last part of the statement.

In the following example, if the first condition is true (that is, the value of x is divisible by 2), then the first printf statement is executed. If it is false, then the second condition is tested, and if it is true (that is, the value of x is divisible by 3), then the second printf statement is executed. Otherwise, the third printf statement is performed.

Note that the elseif keyword must not be spelled else if , as is allowed in Fortran. If it is, the space between the else and if will tell Octave to treat this as a new if statement within another if statement’s else clause. For example, if you write

Octave will expect additional input to complete the first if statement. If you are using Octave interactively, it will continue to prompt you for additional input. If Octave is reading this input from a file, it may complain about missing or mismatched end statements, or, if you have not used the more specific end statements ( endif , endfor , etc.), it may simply produce incorrect results, without producing any warning messages.

It is much easier to see the error if we rewrite the statements above like this,

using the indentation to show how Octave groups the statements. See Functions and Scripts .

© 1996–2020 John W. Eaton Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions. https://octave.org/doc/v6.3.0/The-if-Statement.html

Octave Programming Tutorial/Loops and conditions

Loops are used to repeat a block of code for a known or unknown number of times, depending on the type of loop. Using loops, you will draw some nice pictures of fractals and shapes drawn with random dots.

• 1.1.1 A Word of Caution
• 1.2 Exercises
• 2.1 Exercise
• 2.2 Example: The Mandelbrot fractal
• 3.1 Exercise
• 3.2 Challenge
• 4 The break and continue statements
• 5.1 Example: The fractal fern

The for loop [ edit | edit source ]

We use for loops to repeat a block of code for a list of known values. As an example, we'll calculate the mean of a list of values. The mean is calculated from

We set up a vector with some values

and calculate the mean with

Line 2: Set sum equal to 0. Line 3: For each value in x, assign it to entry. Line 4: Increment sum by entry. Line 5: Ends the for loop when there are no more members of x. Line 6: Assign the final value of sum divided by the length of x to x_mean.

TO DO: get a better example and explain the code.

In general, we write a for loop as

The ... represents the block of code that is executed exactly once for each value inside the vector .

Example: The Sierpinski triangle [ edit | edit source ]

The Sierpinski triangle is a fractal that can be generated with a very simple algorithm.

• Start on a vertex of an equilateral triangle.
• Select a vertex of the triangle at random.
• Move to the point halfway between where you are now and the selected vertex.
• Repeat from step 2.

Plotting the points that you visit by following this procedure, generates the following picture.

The code that generates this fractal is shown bellow. Note that this code uses one very simple for loop to generate the fractal (for i = 1:N ; ... ; end)

A Word of Caution [ edit | edit source ]

For performance reasons, it's best to perform as few tasks as possible inside 'for' loops, and graphical operations like plot should be moved outside of loops whenever possible. By simply storing all x values in a matrix and then plotting as shown below, the run time for the code to produce this figure drops to a few seconds, even when iterating over 100,000 elements (which the code above warns not to do).

By initializing x as a matrix of the full final size ahead of time, this processing time can be reduced still further to only 1 or 2 seconds on modern hardware. In general, if a loop can be replaced with vectorization, it should be.

Exercises [ edit | edit source ]

• Write a script that does the same thing as the linspace function. It should start at some value, xstart , stop at xstop and create a vector that contains N values evenly spaced from xstart to xstop . You can use the zeros function to create a zero-filled vector of the right size. Use help zeros to find out how the function works.

The while loop [ edit | edit source ]

The while loop also executes a block of code more than once but stops based on a logical condition. For example

will multiply x by 2 until its value exceeds 1000. Here, x < 1000 is the condition of the loop. As long as the condition holds (is true), the loop will continue executing. As soon as it is false, the loop terminates and the first instruction after the loop is executed.

The general form of a while loop is

Exercise [ edit | edit source ]

Example: The Mandelbrot fractal [ edit | edit source ]

The Mandelbrot set is another fractal and is generated by checking how long it takes a complex number to become large. For each complex number, c ,

We record all of these i values and assign a colour to each of them. This is used to generate an image like this one.

You can download the code that generates this fractal from Mandelbrot.m . Note that there is a while loop (inside some for loops) that tests whether the complex number z has modulus less than 2:

The first condition in the while loop checks that we do not perform too many iterations. For some values of c the iteration will go on forever if we let it.

See also another version by Christopher Wellons

The do...until statement [ edit | edit source ]

These loops are very similar to while loops in that they keep executing based on whether a given condition is true or false. There are however some important difference between while and do...until loops.

• while loops have their conditions at the beginning of the loop; do...until loops have theirs at the end.
• while loops repeat as long as the condition is true; do...until loops continue as long as theirs is false.
• while will execute 0 or more times (because the condition is at the beginning); do...until loops will execute 1 or more times (since the condition is at the end).

The general form of a do...until loop is

Write a script that calculates the greatest common divisor (GCD) of two positive integers. You can do this using Euclid's algorithm.

Challenge [ edit | edit source ]

Write a script that generates random number pairs (a, b) that are distributed uniformly

• as in the second image below

The break and continue statements [ edit | edit source ]

Sometimes it is necessary to stop a loop somewhere in the middle of its execution or to move on to the next value in a for loop without executing the rest of the loop code for the current value. This is where the break and continue statements are useful.

The following code demonstrates how the break statement works.

Without the break statement, the loop would keep executing forever since the condition of the while loop is always true. The break allows you to jump past the end of the loop (to the statement after the endwhile).

The break statement can be used in any loop: for , while or do...until .

The continue statement also jumps from the inside of a loop but returns to the beginning of the loop rather than going to the end. In a

• for loop, the next value inside the vector will be assigned to the for variable (if there are any left) and the loop restarted with that value;
• while loop, the condition at the beginning of the loop will be retested and the loop continued if it is still true;
• do...until loop, the condition at the end of the loop will be tested and the loop continued from the beginning if it is still false.

As an example, the following code will fill the lower triangular part of a square matrix with 1s and the rest with 0s.

Note that the inner for skips (continues) over the code that assigns a 1 to an entry of A whenever the column index is greater than the row index.

The if statement [ edit | edit source ]

The general form of the if statement is

If condition1 evaluates to true, the statements in the block immediately following the if are executed. If condition1 is false, the next condition ( condition2 in the elseif ) is checked and its statements executed if it is true. You can have as many elseif statements as you like. The final set of statements, after the else , is executed if all of the conditions evaluate to false. Note that the elseif and else parts of the if statement are optional.

The following are all valid if statements:

Example: The fractal fern [ edit | edit source ]

This algorithm is not quite complete. Have a look at the .m file available from http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=4372&objectType=file .

The image to the right can be generated with the following algorithm:

You can download the code that generates this fractal as fracfern.m (this is disabled for now).

Return to the Octave Programming tutorial index

• Book:Octave Programming Tutorial
• Pages with broken file links

Navigation menu

Technology eXplorer

• Octave:1> Expressions and operators

Expressions are the basic building block of statements in Octave. It can be created using values, variables that have already been created, operators, functions, and parentheses. An expression evaluates to value and can serve as a statement on its own. Generally, statements contain one or more expressions that specify data to be operated on. Like the earlier articles, we encourage readers planning to learn octave/Matlab to try the exercises marked as “ Ex “.

Assignment Expressions

As the name suggests an assignment expression is used to store a value in a variable. The most common assignment operator is “=”, which evaluates the value of an expression on right and stores the output in a variable on left. Assignment operator can be used with other mathematical operators also to shorten the expression e.g. “+=”, “-=”, “*=” e.t.c. In such a case, the operation is performed on the initial left-hand side variable and right-hand side expression. And the final value is updated in the left-hand-side variable.

Like any programming language, two kinds of operators can be possible: unary operators, which operate on a single value or operand; and binary operators, which operate on two values or operands. A “-” operator is both unary (negation) as well as binary (minus) in nature. In this article, we will discuss basic operator use only. As the series progresses we will introduce more advanced use cases.

Increment Operators

Adding to a variable is called incrementing. But in general, both increment and decrement are defined as addition or subtraction of 1 from the variable. It is denoted as “++” or “–” symbol. Increment operators can be used both before or after the variable. In both cases, the variable is incremented or decremented. But the output of expression will be updated value if an operator is used before variable, else previous value will be returned.

Arithmetic Operators

Some of the common operators that can be used with numeric expressions:

• “ + ” addition
• “ – ” negation, minus
• “ * ” multiplication
• “ / ” division
• “ \ ” left division (x\y is equivalent to y/x)
• “ ^ ” or “ * ” exponent

When the data used is matrix or vector all the above operators can also be used with a dot before the operator to denote element-wise operation e.g. “x* y” is normal multiplication while “x. *y” is element-wise multiplication. In this case, two more operators are introduced. The use of these operators is discussed in “Octave:1>Matrix and Vector Operations”.

• “ ‘ ” complex conjugate transpose
• “ .’ ” transpose

Comparison Operators

These are the relation operators that return the logical type value after evaluation of an expression.

• “ < ” true if LHS is less then RHS
• “ <= ” true if LHS is less then or equal to RHS
• “ > ” true if LHS is greater then RHS
• “ >= ” true if LHS is greater then or equal to RHS
• “ == ” true if LHS is equal to the RHS
• “ != ” or “ ~= ” true if LHS is not equal to the RHS

All of Octave’s comparison operators return a value of 1 if the comparison is true, or 0 if it is false. In the case of a matrix or vector, these operators work on an element-by-element basis.

Boolean Operators

A boolean expression can be divided into two types when dealing with octave. The first one is element-wise boolean, in this case, if a value is 0 then it is considered false else true.

• “ & ” element wise AND e.g. 2 & 3 = 1(true).
• “ | ” element-wise OR
• “ ! ” or “ ~ ” element-wise NOT

On the other hand, the second type of boolean operators is called short circuit operators. these only operate on logical type operands.

• “ && ” logical AND
• “ || ” logical OR
• “ format ” command changes the output precision. The default value is short, i.e. 4 digits after the decimal point.
• “ … ” three dots (ellipsis) are used to continue the expression in the next line as a continuation. this is very helpful for the readability of long expressions.
• “ help ” command can elaborate more about the operators e.g. “ help + “.

This article should serve as the introduction to operators and basic expressions in GNU Octave. We will visit these back with advanced use cases at multiple stages in the ongoing series. Please write down any queries/suggestions related to the article as a comment.

Octave development takes a lot of time and expertise. Your contributions help to ensure that Octave will continue to improve.

Operator Precedence

Operator precedence determines how operators are grouped when different operators appear close by in one expression.

In the above expression, if we go left to right solving operators, the output should be 14. But if we go from right to left, the output should be 20. Although the actual answer is different from both indicating that one of the operators got preference over another. In the above example, it is clear that ‘*’ has higher precedence than ‘+’. Operators are mentioned below in order of decreasing precedence. Unless noted, all operators group left to right.

• Function call and array indexing, cell array indexing, and structure element indexing.
• Postfix increment, and postfix decrement .
• Transpose and exponentiation.
• Unary plus, unary minus, prefix increment, prefix decrement, and logical “not”
• Multiply and divide
• Add, subtract
• Colon (Index expression allows to reference or extract selected elements of a matrix or vector)
• Element-wise “and”
• Element-wise “or”
• Logical “and”
• Logical “or”

Reference: https://octave.org/doc/v4.2.1/Operator-Precedence.html#Operator-Precedence

Use this article as a reference while formatting an expression. If the precedecence rule is not kept in mind then it might be possible to get the result which is not desired at all. Please write down any queries/suggestions related to the article as a comment.

• GNU Octave – Scientific Programming Language
• Octave:1> Getting Started
• Octave:1> Variables and Constants
• Octave:1> Built-In Functions, Commands, and Package
• Octave:2> Vectors and Matrices Basics
• Octave:2> Scripts and Algorithm
• Octave:2> Conditional Execution

Octave:2> Functions

Octave:3> file operations, octave:3> data visualization, share this:.

• Click to share on Twitter (Opens in new window)
• Click to share on Facebook (Opens in new window)
• Click to share on LinkedIn (Opens in new window)
• Click to share on Reddit (Opens in new window)
• Click to share on WhatsApp (Opens in new window)
• Click to email a link to a friend (Opens in new window)
• Click to print (Opens in new window)
• Click to share on Tumblr (Opens in new window)
• Click to share on Pinterest (Opens in new window)
• Click to share on Pocket (Opens in new window)
• Click to share on Telegram (Opens in new window)

By Purnendu Kumar

Purnendu is currently working as Senior Project Engineer at QuNu Labs, Indias only Quantum security company. He has submitted his thesis for Masters (MS by research 2014-17) in electrical engineering at IIT Madras for doing his research on “constant fraction discriminator” and “amplitude and rise-time compensated discriminator” for precise time stamping of Resistive Plate Chamber detector signals. In collaboration with India Based Neutrino observatory project, he has participated in design and upgrade of FPGA-based data acquisition system, test-jig development, and discrete front-end design. After completion of his bachelors in Electrical Engineering (Power and Electronics), he was awarded Junior Research Fellowship at Department of Physics and Astro-physics, University of Delhi under same (INO) project. His current interest is in high-speed circuit design, embedded systems, IoT, FPGA implementation and optimization of complex algorithms, experimental high-energy physics, and quantum mechanics.

Related Post

Jupyter notebook to wordpress conversion, git – an intro to “the stupid content tracker(tm)”, color targets for imaging and display devices.

Next: Increment Operators , Previous: Boolean Expressions , Up: Expressions   [ Contents ][ Index ]

8.6 Assignment Expressions ¶

An assignment is an expression that stores a new value into a variable. For example, the following expression assigns the value 1 to the variable z :

After this expression is executed, the variable z has the value 1. Whatever old value z had before the assignment is forgotten. The ‘ = ’ sign is called an assignment operator .

Assignments can store string values also. For example, the following expression would store the value "this food is good" in the variable message :

(This also illustrates concatenation of strings.)

Most operators (addition, concatenation, and so on) have no effect except to compute a value. If you ignore the value, you might as well not use the operator. An assignment operator is different. It does produce a value, but even if you ignore the value, the assignment still makes itself felt through the alteration of the variable. We call this a side effect .

The left-hand operand of an assignment need not be a variable (see Variables ). It can also be an element of a matrix (see Index Expressions ) or a list of return values (see Calling Functions ). These are all called lvalues , which means they can appear on the left-hand side of an assignment operator. The right-hand operand may be any expression. It produces the new value which the assignment stores in the specified variable, matrix element, or list of return values.

It is important to note that variables do not have permanent types. The type of a variable is simply the type of whatever value it happens to hold at the moment. In the following program fragment, the variable foo has a numeric value at first, and a string value later on:

When the second assignment gives foo a string value, the fact that it previously had a numeric value is forgotten.

Assignment of a scalar to an indexed matrix sets all of the elements that are referenced by the indices to the scalar value. For example, if a is a matrix with at least two columns,

sets all the elements in the second column of a to 5.

When an assignment sets the value of a vector, matrix, or array element at a position or dimension outside of that variable’s current size, the array size will be increased to accommodate the new values:

Attempting to increase the size of an array such that the desired output size is ambiguous will result in an error:

This is because adding the 9th element creates an ambiguity in the desired array position for the value 10, each possibility requiring a different array size expansion to accommodate the assignment.

Assignments may be made with fewer specified elements than would be required to fill the newly expanded array as long as the assignment is unambiguous. In these cases the array will be automatically padded with null values:

For all built-in types, the null value will be appropriate to that object type.

Numeric arrays:

Logical arrays:

Character arrays:

Cell arrays:

Struct arrays:

Note that Octave currently is unable to concatenate arbitrary object types into arrays. Such behavior must be explicitly defined within the object class or attempts at concatenation will result in an error. See Object Oriented Programming

Assigning an empty matrix ‘ [] ’ works in most cases to allow you to delete rows or columns of matrices and vectors. See Empty Matrices . For example, given a 4 by 5 matrix A , the assignment

deletes the third row of A , and the assignment

deletes the first, third, and fifth columns.

Deleting part of an array object will necessarily resize the object. When the deletion allows for consistent size reduction across a dimension, e.g., one element of a vector, or one row or column of a matrix, the size along that dimension will be reduced while preserving dimensionality. If, however, dimensionality cannot be maintained, the object will be reshaped into a vector following column-wise element ordering:

An assignment is an expression, so it has a value. Thus, z = 1 as an expression has the value 1. One consequence of this is that you can write multiple assignments together:

stores the value 0 in all three variables. It does this because the value of z = 0 , which is 0, is stored into y , and then the value of y = z = 0 , which is 0, is stored into x .

This is also true of assignments to lists of values, so the following is a valid expression

that is exactly equivalent to

In expressions like this, the number of values in each part of the expression need not match. For example, the expression

is equivalent to

The number of values on the left side of the expression can, however, not exceed the number of values on the right side. For example, the following will produce an error.

The symbol ~ may be used as a placeholder in the list of lvalues, indicating that the corresponding return value should be ignored and not stored anywhere:

This is cleaner and more memory efficient than using a dummy variable. The nargout value for the right-hand side expression is not affected. If the assignment is used as an expression, the return value is a comma-separated list with the ignored values dropped.

A very common programming pattern is to increment an existing variable with a given value, like this

This can be written in a clearer and more condensed form using the += operator

Similar operators also exist for subtraction ( -= ), multiplication ( *= ), and division ( /= ). An expression of the form

is evaluated as

where op can be either + , - , * , or / , as long as expr2 is a simple expression with no side effects. If expr2 also contains an assignment operator, then this expression is evaluated as

where temp is a placeholder temporary value storing the computed result of evaluating expr2 . So, the expression

You can use an assignment anywhere an expression is called for. For example, it is valid to write x != (y = 1) to set y to 1 and then test whether x equals 1. But this style tends to make programs hard to read. Except in a one-shot program, you should rewrite it to get rid of such nesting of assignments. This is never very hard.

8.6 Assignment Expressions

An assignment is an expression that stores a new value into a variable. For example, the following expression assigns the value 1 to the variable z :

After this expression is executed, the variable z has the value 1. Whatever old value z had before the assignment is forgotten. The ‘ = ’ sign is called an assignment operator .

Assignments can store string values also. For example, the following expression would store the value "this food is good" in the variable message :

(This also illustrates concatenation of strings.)

Most operators (addition, concatenation, and so on) have no effect except to compute a value. If you ignore the value, you might as well not use the operator. An assignment operator is different. It does produce a value, but even if you ignore the value, the assignment still makes itself felt through the alteration of the variable. We call this a side effect .

The left-hand operand of an assignment need not be a variable (see Variables ). It can also be an element of a matrix (see Index Expressions ) or a list of return values (see Calling Functions ). These are all called lvalues , which means they can appear on the left-hand side of an assignment operator. The right-hand operand may be any expression. It produces the new value which the assignment stores in the specified variable, matrix element, or list of return values.

It is important to note that variables do not have permanent types. The type of a variable is simply the type of whatever value it happens to hold at the moment. In the following program fragment, the variable foo has a numeric value at first, and a string value later on:

When the second assignment gives foo a string value, the fact that it previously had a numeric value is forgotten.

Assignment of a scalar to an indexed matrix sets all of the elements that are referenced by the indices to the scalar value. For example, if a is a matrix with at least two columns,

sets all the elements in the second column of a to 5.

Assigning an empty matrix ‘ [] ’ works in most cases to allow you to delete rows or columns of matrices and vectors. See Empty Matrices . For example, given a 4 by 5 matrix A , the assignment

deletes the third row of A , and the assignment

deletes the first, third, and fifth columns.

An assignment is an expression, so it has a value. Thus, z = 1 as an expression has the value 1. One consequence of this is that you can write multiple assignments together:

stores the value 0 in all three variables. It does this because the value of z = 0 , which is 0, is stored into y , and then the value of y = z = 0 , which is 0, is stored into x .

This is also true of assignments to lists of values, so the following is a valid expression

that is exactly equivalent to

In expressions like this, the number of values in each part of the expression need not match. For example, the expression

is equivalent to

The number of values on the left side of the expression can, however, not exceed the number of values on the right side. For example, the following will produce an error.

The symbol ~ may be used as a placeholder in the list of lvalues, indicating that the corresponding return value should be ignored and not stored anywhere:

This is cleaner and more memory efficient than using a dummy variable. The nargout value for the right-hand side expression is not affected. If the assignment is used as an expression, the return value is a comma-separated list with the ignored values dropped.

A very common programming pattern is to increment an existing variable with a given value, like this

This can be written in a clearer and more condensed form using the += operator

Similar operators also exist for subtraction ( -= ), multiplication ( *= ), and division ( /= ). An expression of the form

is evaluated as

where op can be either + , - , * , or / , as long as expr2 is a simple expression with no side effects. If expr2 also contains an assignment operator, then this expression is evaluated as

where temp is a placeholder temporary value storing the computed result of evaluating expr2 . So, the expression

You can use an assignment anywhere an expression is called for. For example, it is valid to write x != (y = 1) to set y to 1 and then test whether x equals 1. But this style tends to make programs hard to read. Except in a one-shot program, you should rewrite it to get rid of such nesting of assignments. This is never very hard.

© 1996–2018 John W. Eaton Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions. https://octave.org/doc/interpreter/Assignment-Ops.html