computing_on_data.txt

octave:5> A = [1 2; 3 4; 5 6]
A =

   1   2
   3   4
   5   6

octave:6> B = [10 11; 12 13; 14 15]
B =

   10   11
   12   13
   14   15

octave:7> C = [1 2 3; 4 5 6]
C =

   1   2   3
   4   5   6

octave:8> A * C
ans =

    9   12   15
   19   26   33
   29   40   51

octave:9> B * C
ans =

    54    75    96
    64    89   114
    74   103   132

octave:10> A .* B
ans =

   10   22
   36   52
   70   90

octave:11> V = [1; 2; 3]
V =

   1
   2
   3

octave:12> V + 1
ans =

   2
   3
   4

octave:13> V' #transpose
ans =

   1   2   3

octave:14> (V+1)'
ans =

   2   3   4

octave:15> x = (V+1)'
x =

   2   3   4

octave:16> max (x)
ans =  4
octave:17> [val, ind] = max (x)
val =  4
ind =  3
octave:18> A
A =

   1   2
   3   4
   5   6

octave:19> max (A) #returns the column with the max value
ans =

   5   6

octave:20> x
x =

   2   3   4

octave:21> x <  3
ans =

  1  0  0

octave:22> find (x<3)
ans =  1
octave:23> A
A =

   1   2
   3   4
   5   6

octave:24> [r, c] = find(A>=7)
r = [](0x1)
c = [](0x1)
octave:25> [r, c] = find(A>=3)
r =

   2
   3
   2
   3

c =

   1
   1
   2
   2

octave:26> D = rand(3,1)
D =

   0.037138
   0.040905
   0.339827

octave:27> D = rand(1,1)
D =  0.63497
octave:28> D = rand(1,0)
D = [](1x0)
octave:29> D = rand(1,3)
D =

   0.39812   0.37656   0.65296

octave:30> floor(D)
ans =

   0   0   0

octave:31> ceil(D)
ans =

   1   1   1

octave:32> max (2,1)
ans =  2
octave:33> max (rand(2), rand(2))
ans =

   0.51577   0.71198
   0.19302   0.56167

octave:34> rand(2)
ans =

   0.941753   0.428214
   0.084452   0.279988

octave:35> #that was the max of two random matrices of 2x2 dimensions each
octave:35> A = magic(3)
A =

   8   1   6
   3   5   7
   4   9   2

octave:36> max(A, [], 1)
ans =

   8   9   7

octave:37> max(A, [], 2) #will return the max of each row
ans =

   8
   7
   9

octave:38> max(A, [], 3)
ans =

   8   1   6
   3   5   7
   4   9   2

octave:39> max(A, [], 4)
ans =

   8   1   6
   3   5   7
   4   9   2

octave:40> A = magic (9)
A =

   47   58   69   80    1   12   23   34   45
   57   68   79    9   11   22   33   44   46
   67   78    8   10   21   32   43   54   56
   77    7   18   20   31   42   53   55   66
    6   17   19   30   41   52   63   65   76
   16   27   29   40   51   62   64   75    5
   26   28   39   50   61   72   74    4   15
   36   38   49   60   71   73    3   14   25
   37   48   59   70   81    2   13   24   35

octave:41> sum(A,1)
ans =

   369   369   369   369   369   369   369   369   369

octave:42> help sum
'sum' is a built-in function from the file libinterp/corefcn/data.cc

 -- sum (X)
 -- sum (X, DIM)
 -- sum (..., "native")
 -- sum (..., "double")
 -- sum (..., "extra")
     Sum of elements along dimension DIM.

     If DIM is omitted, it defaults to the first non-singleton
     dimension.

     The optional "type" input determines the class of the variable used
     for calculations.  By default, operations on floating point inputs
     (double or single) are performed in their native data type, while
     operations on integer, logical, and character data types are
     performed using doubles.  If the argument "native" is given, then
     the operation is performed in the same type as the original
     argument.

     For example:

          sum ([true, true])
             => 2
          sum ([true, true], "native")
             => true

     If "double" is given the sum is performed in double precision even
     for single precision inputs.

     For double precision inputs, the "extra" option will use a more
     accurate algorithm than straightforward summation.  For single
     precision inputs, "extra" is the same as "double".  For all other
     data type "extra" has no effect.

     See also: cumsum, sumsq, prod.

Additional help for built-in functions and operators is
available in the online version of the manual.  Use the command
'doc <topic>' to search the manual index.

Help and information about Octave is also available on the WWW
at https://www.octave.org and via the [email protected]
mailing list.
octave:43> A
A =

   47   58   69   80    1   12   23   34   45
   57   68   79    9   11   22   33   44   46
   67   78    8   10   21   32   43   54   56
   77    7   18   20   31   42   53   55   66
    6   17   19   30   41   52   63   65   76
   16   27   29   40   51   62   64   75    5
   26   28   39   50   61   72   74    4   15
   36   38   49   60   71   73    3   14   25
   37   48   59   70   81    2   13   24   35

octave:44> sum(A)
ans =

   369   369   369   369   369   369   369   369   369

octave:45> B = [1 2; 3 4; 5 6]
B =

   1   2
   3   4
   5   6

octave:46> sum(B)
ans =

    9   12

octave:47> sum(B,1)
ans =

    9   12

octave:48> sum(B,2)
ans =

    3
    7
   11