This is octave.info, produced by makeinfo version 5.2 from octave.texi.

START-INFO-DIR-ENTRY
* Octave: (octave).           Interactive language for numerical computations.

END-INFO-DIR-ENTRY

   Copyright (C) 1996-2013 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.


File: octave.info,  Node: Operator Index,  Prev: Function Index,  Up: Top

Operator Index
**************

 [index ]
* Menu:

* !:                                     Element-by-element Boolean Operators.
                                                              (line  37)
* ! <1>:                                 Element-by-element Boolean Operators.
                                                              (line  79)
* ! <2>:                                 Operator Overloading.
                                                              (line  10)
* !=:                                    Comparison Ops.      (line  39)
* != <1>:                                Comparison Ops.      (line  98)
* != <2>:                                Operator Overloading.
                                                              (line  10)
* ":                                     String Objects.      (line   6)
* " <1>:                                 Strings.             (line   6)
* &:                                     Element-by-element Boolean Operators.
                                                              (line  28)
* & <1>:                                 Element-by-element Boolean Operators.
                                                              (line  65)
* & <2>:                                 Operator Overloading.
                                                              (line  10)
* &&:                                    Short-circuit Boolean Operators.
                                                              (line  14)
* ':                                     String Objects.      (line   6)
* ' <1>:                                 Strings.             (line   6)
* ' <2>:                                 Arithmetic Ops.      (line  93)
* ' <3>:                                 Arithmetic Ops.      (line 122)
* ' <4>:                                 Operator Overloading.
                                                              (line  10)
* (:                                     Index Expressions.   (line   6)
* ):                                     Index Expressions.   (line   6)
* *:                                     Arithmetic Ops.      (line  28)
* * <1>:                                 Arithmetic Ops.      (line 166)
* * <2>:                                 Operator Overloading.
                                                              (line  10)
* **:                                    Arithmetic Ops.      (line  66)
* ** <1>:                                Arithmetic Ops.      (line 150)
* *=:                                    Assignment Ops.      (line 135)
* +:                                     Arithmetic Ops.      (line  11)
* + <1>:                                 Arithmetic Ops.      (line  90)
* + <2>:                                 Arithmetic Ops.      (line 183)
* + <3>:                                 Arithmetic Ops.      (line 243)
* + <4>:                                 Operator Overloading.
                                                              (line  10)
* ++:                                    Increment Ops.       (line  26)
* ++ <1>:                                Increment Ops.       (line  36)
* +=:                                    Assignment Ops.      (line 125)
* ,:                                     Matrices.            (line   6)
* -:                                     Arithmetic Ops.      (line  19)
* - <1>:                                 Arithmetic Ops.      (line  87)
* - <2>:                                 Arithmetic Ops.      (line 137)
* - <3>:                                 Arithmetic Ops.      (line 238)
* - <4>:                                 Operator Overloading.
                                                              (line  10)
* '--':                                  Increment Ops.       (line  31)
* '--' <1>:                              Increment Ops.       (line  40)
* -=:                                    Assignment Ops.      (line 135)
* .:                                     Basic Usage and Examples.
                                                              (line  15)
* .':                                    Arithmetic Ops.      (line 100)
* .' <1>:                                Arithmetic Ops.      (line 231)
* .' <2>:                                Operator Overloading.
                                                              (line  10)
* .*:                                    Arithmetic Ops.      (line  33)
* .* <1>:                                Arithmetic Ops.      (line 217)
* .* <2>:                                Operator Overloading.
                                                              (line  10)
* .**:                                   Arithmetic Ops.      (line  78)
* .** <1>:                               Arithmetic Ops.      (line 196)
* .+:                                    Arithmetic Ops.      (line  16)
* ./:                                    Arithmetic Ops.      (line  48)
* ./ <1>:                                Arithmetic Ops.      (line 209)
* ./ <2>:                                Operator Overloading.
                                                              (line  10)
* .\:                                    Arithmetic Ops.      (line  61)
* .\ <1>:                                Arithmetic Ops.      (line 129)
* .\ <2>:                                Operator Overloading.
                                                              (line  10)
* .^:                                    Arithmetic Ops.      (line  78)
* .^ <1>:                                Arithmetic Ops.      (line 196)
* .^ <2>:                                Operator Overloading.
                                                              (line  10)
* /:                                     Arithmetic Ops.      (line  38)
* / <1>:                                 Arithmetic Ops.      (line 158)
* / <2>:                                 Operator Overloading.
                                                              (line  10)
* /=:                                    Assignment Ops.      (line 135)
* ::                                     Ranges.              (line   6)
* : <1>:                                 Index Expressions.   (line   6)
* : <2>:                                 Operator Overloading.
                                                              (line  10)
* ;:                                     Matrices.            (line   6)
* <:                                     Comparison Ops.      (line  23)
* < <1>:                                 Comparison Ops.      (line  92)
* < <2>:                                 Operator Overloading.
                                                              (line  10)
* < <3>:                                 Operator Overloading.
                                                              (line  10)
* <=:                                    Comparison Ops.      (line  26)
* <= <1>:                                Comparison Ops.      (line  86)
* <= <2>:                                Operator Overloading.
                                                              (line  10)
* =:                                     Assignment Ops.      (line   6)
* ==:                                    Comparison Ops.      (line  29)
* == <1>:                                Comparison Ops.      (line  53)
* == <2>:                                Operator Overloading.
                                                              (line  10)
* >:                                     Comparison Ops.      (line  35)
* > <1>:                                 Comparison Ops.      (line  68)
* > <2>:                                 Operator Overloading.
                                                              (line  10)
* >=:                                    Comparison Ops.      (line  32)
* >= <1>:                                Comparison Ops.      (line  62)
* >= <2>:                                Operator Overloading.
                                                              (line  10)
* [:                                     Matrices.            (line   6)
* \:                                     Arithmetic Ops.      (line  51)
* \ <1>:                                 Arithmetic Ops.      (line 142)
* \ <2>:                                 Operator Overloading.
                                                              (line  10)
* ]:                                     Matrices.            (line   6)
* ^:                                     Arithmetic Ops.      (line  66)
* ^ <1>:                                 Arithmetic Ops.      (line 150)
* ^ <2>:                                 Operator Overloading.
                                                              (line  10)
* {:                                     Basic Usage of Cell Arrays.
                                                              (line   6)
* |:                                     Element-by-element Boolean Operators.
                                                              (line  32)
* | <1>:                                 Element-by-element Boolean Operators.
                                                              (line  86)
* | <2>:                                 Operator Overloading.
                                                              (line  10)
* ||:                                    Short-circuit Boolean Operators.
                                                              (line  28)
* }:                                     Basic Usage of Cell Arrays.
                                                              (line   6)
* ~:                                     Element-by-element Boolean Operators.
                                                              (line  37)
* ~ <1>:                                 Element-by-element Boolean Operators.
                                                              (line  79)
* ~=:                                    Comparison Ops.      (line  39)
* ~= <1>:                                Comparison Ops.      (line  98)
* ~= <2>:                                Operator Overloading.
                                                              (line  10)