Vorlesung 2: Eindimensionale Felder (Arrays)

Eindimensionale Felder (Vektoren, Arrays) sind in zahlreichen Situationen hilfreich, z.B. bei der graphischen Darstellung von Funktionswerten, bei der Speicherung von Tabellen mit Zahlenwerten, bei der Auswertung mathematischer Ausdruecke, usw.. In dieser Vorlesung beschaeftigen wir uns mit der Erzeugung eindimensionaler Felder. Ausserdem lernen wir Funktionen kennen, die bei der Bearbeitung eindimensionaler Felder nuetzlich sind.

Contents

clear all
format short

Eckige Klammern

Angabe einer Liste von Zahlen in eckigen Klammern:

v = [ 1 2 3 4 5]

v =

     1     2     3     4     5

oder

v = [1.3 -3.4 1.32e2 sqrt(2) 4^5 1/2]

v =

   1.0e+03 *

    0.0013   -0.0034    0.1320    0.0014    1.0240    0.0005

Man kann die einzelnen Komponenten durch ein Komma trennen, wie in

v = [1.3, -3.4, 1.32e2, sqrt(2), 4^5, 1/2]

v =

   1.0e+03 *

    0.0013   -0.0034    0.1320    0.0014    1.0240    0.0005

Die Kommaschreibweise ist weniger Fehleranfaellig. Betrachte dazu das folgende Beispiel. Verwendet man

v = [1.3, -3.4]

v =

    1.3000   -3.4000

statt

v = [1.3 -3.4]

v =

    1.3000   -3.4000

so ist dies weniger Fehleranfaellig gegenueber Fehlern der Form

v = [1.3 - 3.4]

v =

   -2.1000

Der Doppelpunkt-Operator

Oft moechte man Felder erzeugen, die einem bestimmten Muster folgen. Ein einfaches Muster ist ein Feld mit Werten mit gleichem Abstand.

help colon
%
% Beispielsweise erzeugt man ein Feld mit den natuerlichen Zahlen
% 1,2,3,...,10, durch die Anweisung

 :  Colon.
    J:K  is the same as [J, J+1, ..., K].
    J:K  is empty if J > K.
    J:D:K  is the same as [J, J+D, ..., J+m*D] where m = fix((K-J)/D).
    J:D:K  is empty if D == 0, if D > 0 and J > K, or if D < 0 and J < K.
 
    COLON(J,K) is the same as J:K and COLON(J,D,K) is the same as J:D:K.
 
    The colon notation can be used to pick out selected rows, columns
    and elements of vectors, matrices, and arrays.  A(:) is all the
    elements of A, regarded as a single column. On the left side of an
    assignment statement, A(:) fills A, preserving its shape from before.
    A(:,J) is the J-th column of A.  A(J:K) is [A(J),A(J+1),...,A(K)].
    A(:,J:K) is [A(:,J),A(:,J+1),...,A(:,K)] and so on.
 
    The colon notation can be used with a cell array to produce a comma-
    separated list.  C{:} is the same as C{1},C{2},...,C{end}.  The comma
    separated list syntax is valid inside () for function calls, [] for
    concatenation and function return arguments, and inside {} to produce
    a cell array.  Expressions such as S(:).name produce the comma separated
    list S(1).name,S(2).name,...,S(end).name for the structure S.
 
    For the use of the colon in the FOR statement, See FOR.
    For the use of the colon in a comma separated list, See VARARGIN.

    Overloaded methods:
       sym/colon

    Reference page in Help browser
       doc colon

v = 1:10

v =

     1     2     3     4     5     6     7     8     9    10

Falls wir eine andere Schrittweite als 1 verwenden moechten, dann schreiben wir beispielsweise

v = 1:2:20

v =

     1     3     5     7     9    11    13    15    17    19

Die Schrittweite kann auch negativ sein

v = 50:-5:0

v =

    50    45    40    35    30    25    20    15    10     5     0

weitere Beispiele:

v = 0:3:10

v =

     0     3     6     9

v = 10:15:20

v =

    10

Im folgenden Beispiel ist v ein leeres Feld

v = 0:-1:10

v =

   Empty matrix: 1-by-0

In den obigen Beispielen haetten wir auch eckige Klammern verwenden koennen, also beispielsweise

v = [0:3:10]

v =

     0     3     6     9

Der 'linspace' Befehl

Auch mit linspace kann man Felder mit Eintraegen gleichen Abstandes erzeugen. Man spezifiziert einen Start- und einen Endwert sowie die Anzahl der Eintraege.

help linspace

 LINSPACE Linearly spaced vector.
    LINSPACE(X1, X2) generates a row vector of 100 linearly
    equally spaced points between X1 and X2.
 
    LINSPACE(X1, X2, N) generates N points between X1 and X2.
    For N = 1, LINSPACE returns X2.
 
    Class support for inputs X1,X2:
       float: double, single
 
    See also LOGSPACE, COLON.

    Reference page in Help browser
       doc linspace

v = linspace(1,10,10)

v =

     1     2     3     4     5     6     7     8     9    10

v = linspace(-3,5,9)

v =

    -3    -2    -1     0     1     2     3     4     5

v = linspace(-3,5,17)

v =

  Columns 1 through 7

   -3.0000   -2.5000   -2.0000   -1.5000   -1.0000   -0.5000         0

  Columns 8 through 14

    0.5000    1.0000    1.5000    2.0000    2.5000    3.0000    3.5000

  Columns 15 through 17

    4.0000    4.5000    5.0000

Vorteil von linspace: Das Feld hat den spezifizierten Start und Endwert. Vergleiche die folgenden beiden Anweisungen.

1.)

v = 0:0.3333:1

v =

         0    0.3333    0.6666    0.9999

2.)

v = linspace(0,1,4)

v =

         0    0.3333    0.6667    1.0000

Zeilen- und spaltenweise Anordnung von Feldern

row_array = [1,2,3,4]

row_array =

     1     2     3     4

column_array = [1;2;3;4]

column_array =

     1
     2
     3
     4

whos row_array column_array

  Name              Size            Bytes  Class     Attributes

  column_array      4x1                32  double              
  row_array         1x4                32  double              

row_array: 1 Zeile, 4 Spalten column_array: 4 Zeilen, 1 Spalte

row_array'

ans =

     1
     2
     3
     4

column_array'

ans =

     1     2     3     4

v=(0:5)'

v =

     0
     1
     2
     3
     4
     5

Unter Verwendung des Transponiert-Operators ' (Apostrophe) kann man einen Zeilenvektor in einen Spaltenvektor ueberfuehren, und umgekehrt. Insbesondere koennen wir ein mit linspace erzeugtes Feld als Spalte darstellen.

v=linspace(0,5,6)'

v =

     0
     1
     2
     3
     4
     5

Indizierung von Feldern

Der Vektor v=(0:5) hat 6 Komponenten mit Indizes 1,2,..,6. Man kann auf einzelne Komponenten von v zugreifen, z.B.

v(3)

ans =

     2

Man kann auch auf mehrere Eintraege zugreigen. Dazu definieren wir uns zunaechst eine Indexmenge.

index_set = [1,3,5];
v(index_set)

ans =

     0
     2
     4

Eine groessere Index-Menge kann man mit dem Doppelpunkt-Operator erzeugen.

v = linspace(-1,1,11);
index_set = 1:2:11;
v(index_set)

ans =

   -1.0000   -0.6000   -0.2000    0.2000    0.6000    1.0000

oder

v(1:2:11)

ans =

   -1.0000   -0.6000   -0.2000    0.2000    0.6000    1.0000

Man kann die Komponenten des Vektors v auch in umgekehrter Reihenfolge bestiimmen.

w = v(11:-1:1)

w =

  Columns 1 through 7

    1.0000    0.8000    0.6000    0.4000    0.2000         0   -0.2000

  Columns 8 through 11

   -0.4000   -0.6000   -0.8000   -1.0000

Desweiteren koennen wir die Komponenten in beliebiger Ordnung bestimmen und sogar doppelt auf Komponenten des Feldes zugreifen.

w = v([5 7 2 9 9 3 2 2])

w =

  Columns 1 through 7

   -0.2000    0.2000   -0.8000    0.6000    0.6000   -0.6000   -0.8000

  Column 8

   -0.8000

Der erste Eintrag eines Feldes hat immer den Index 1. Ein Zugriff auf eine nicht existierende Komponente erzeugt eine Fehlermeldung. v(0) v(12)

Verwendung von length und end

In den flgenden Anweisungen lernen wir Moeglichkeiten kennen, wie wir auf die letzten 3 Komponenten eines Vektors zugreifen koennen.

n = length(v);
v([n-2 n-1 n])

ans =

    0.6000    0.8000    1.0000

v(end)
v([end-2 end-1 end])

ans =

     1


ans =

    0.6000    0.8000    1.0000

oder

v(end-2:end)

ans =

    0.6000    0.8000    1.0000

Durch die Verwendung des Doppelpunktes aendert sich das Feld von einem Zeilen- zu einem Spaltenvektor

v(:)

ans =

   -1.0000
   -0.8000
   -0.6000
   -0.4000
   -0.2000
         0
    0.2000
    0.4000
    0.6000
    0.8000
    1.0000

Zusammengesetzte Felder

Zeilenvektoren

u = -5:2;
v = 21:27;
w1 = [u v]

w1 =

  Columns 1 through 13

    -5    -4    -3    -2    -1     0     1     2    21    22    23    24    25

  Columns 14 through 15

    26    27

w2 = [v u]

w2 =

  Columns 1 through 13

    21    22    23    24    25    26    27    -5    -4    -3    -2    -1     0

  Columns 14 through 15

     1     2

Spaltenvektoren

x = [1;1;1;1];
y = [2;2;2;2];
z = [x;y]

z =

     1
     1
     1
     1
     2
     2
     2
     2

A = [x y]

A =

     1     2
     1     2
     1     2
     1     2

Weitere Funktionen

Zahlreiche Matlab Funktionen erlauben einfache Berechnungen ohne Verwendung von Programmierschleifen. Bsp: min, max, sum, prod, mean, sort Sie koennen sich wieder mit der help oder doc Anweisung ueber diese Funktionen informieren.

clear all;
v = 1:10;

min(v)

ans =

     1

max(v)

ans =

    10

sum(v)

ans =

    55

prod(v)

ans =

     3628800

Vektoren aus Nullen, Einsen, Zufallszahlen

v = zeros(1,5)

v =

     0     0     0     0     0

w = ones(1,5)

w =

     1     1     1     1     1

Vektor der Form (7,7,7,7,7):

v = 7 + zeros(1,5)

v =

     7     7     7     7     7

u = 7*ones(1,5)

u =

     7     7     7     7     7

'ones' und 'zeros' kann auch zur Erzeugung von Matrizen verwendet werden.

w = ones(3,5)

w =

     1     1     1     1     1
     1     1     1     1     1
     1     1     1     1     1

help rand

 RAND Uniformly distributed pseudorandom numbers.
    R = RAND(N) returns an N-by-N matrix containing pseudorandom values drawn
    from the standard uniform distribution on the open interval(0,1).  RAND(M,N)
    or RAND([M,N]) returns an M-by-N matrix.  RAND(M,N,P,...) or
    RAND([M,N,P,...]) returns an M-by-N-by-P-by-... array.  RAND returns a
    scalar.  RAND(SIZE(A)) returns an array the same size as A.
 
    Note: The size inputs M, N, P, ... should be nonnegative integers.
    Negative integers are treated as 0.
 
    R = RAND(..., CLASSNAME) returns an array of uniform values of the 
    specified class. CLASSNAME can be 'double' or 'single'.
 
    R = RAND(..., 'like', Y) returns an array of uniform values of the 
    same class as Y.
 
    The sequence of numbers produced by RAND is determined by the settings of
    the uniform random number generator that underlies RAND, RANDI, and RANDN.
    Control that shared random number generator using RNG.
 
    Examples:
 
       Example 1: Generate values from the uniform distribution on the
       interval [a, b].
          r = a + (b-a).*rand(100,1);
 
       Example 2: Use the RANDI function, instead of RAND, to generate
       integer values from the uniform distribution on the set 1:100.
          r = randi(100,1,5);
 
       Example 3: Reset the random number generator used by RAND, RANDI, and
       RANDN to its default startup settings, so that RAND produces the same
       random numbers as if you restarted MATLAB.
          rng('default')
          rand(1,5)
 
       Example 4: Save the settings for the random number generator used by
       RAND, RANDI, and RANDN, generate 5 values from RAND, restore the
       settings, and repeat those values.
          s = rng
          u1 = rand(1,5)
          rng(s);
          u2 = rand(1,5) % contains exactly the same values as u1
 
       Example 5: Reinitialize the random number generator used by RAND,
       RANDI, and RANDN with a seed based on the current time.  RAND will
       return different values each time you do this.  NOTE: It is usually
       not necessary to do this more than once per MATLAB session.
          rng('shuffle');
          rand(1,5)
 
    See <a href="matlab:helpview([docroot '\techdoc\math\math.map'],'update_random_number_generator')">Updating Your Random Number Generator Syntax</a> to use RNG to replace
    RAND with the 'seed', 'state', or 'twister' inputs.
 
    See also RANDI, RANDN, RNG, RANDSTREAM, RANDSTREAM/RAND,
             SPRAND, SPRANDN, RANDPERM.

    Overloaded methods:
       RandStream/rand

    Reference page in Help browser
       doc rand

format short e
x = rand(1,10)

x =

  Columns 1 through 6

   3.5166e-01   8.3083e-01   5.8526e-01   5.4972e-01   9.1719e-01   2.8584e-01

  Columns 7 through 10

   7.5720e-01   7.5373e-01   3.8045e-01   5.6782e-01

Unter Verwendung von 'sort' koennen wir die Eintraege eines Feldes sortieren.

x = rand(10,1)

x =

   7.5854e-02
   5.3950e-02
   5.3080e-01
   7.7917e-01
   9.3401e-01
   1.2991e-01
   5.6882e-01
   4.6939e-01
   1.1902e-02
   3.3712e-01

x_sorted = sort(x)

x_sorted =

   1.1902e-02
   5.3950e-02
   7.5854e-02
   1.2991e-01
   3.3712e-01
   4.6939e-01
   5.3080e-01
   5.6882e-01
   7.7917e-01
   9.3401e-01

Arithmetrische Operationen fuer Vektoren: +, -

clear all;
u = [1,2,3,4,5];
v = [5,6,7,8,9];
w = u+v

w =

     6     8    10    12    14

Multiplikation mit einer skalaren Groesse:

x = linspace(0,1,11);
y = 2*x

y =

  Columns 1 through 6

            0   2.0000e-01   4.0000e-01   6.0000e-01   8.0000e-01   1.0000e+00

  Columns 7 through 11

   1.2000e+00   1.4000e+00   1.6000e+00   1.8000e+00   2.0000e+00

z = cos(pi*x)

z =

  Columns 1 through 6

   1.0000e+00   9.5106e-01   8.0902e-01   5.8779e-01   3.0902e-01   6.1232e-17

  Columns 7 through 11

  -3.0902e-01  -5.8779e-01  -8.0902e-01  -9.5106e-01  -1.0000e+00

w = log(exp(3*x+1))

w =

  Columns 1 through 6

   1.0000e+00   1.3000e+00   1.6000e+00   1.9000e+00   2.2000e+00   2.5000e+00

  Columns 7 through 11

   2.8000e+00   3.1000e+00   3.4000e+00   3.7000e+00   4.0000e+00

u = x+y-4*z

u =

  Columns 1 through 6

  -4.0000e+00  -3.5042e+00  -2.6361e+00  -1.4511e+00  -3.6068e-02   1.5000e+00

  Columns 7 through 11

   3.0361e+00   4.4511e+00   5.6361e+00   6.5042e+00   7.0000e+00

Wir koenne nun auch einfache Funktionen zeichnen.

x = linspace(0,2*pi,200);
y = sin(x);
plot(x,y)

Der Punkt-Operator: Elementweise Operationen

Beachte die folgenden Fehlermeldungen: y = x*x 1/x y = x^2 Matlab erwartet, dass die Dimensionen in einem fuer die lineare Algebra korrekten Sinn gewaehlt sind.

Moechte man die entsprechenden Operationen elementweise durchfuehren, so verwendet man .*, ./ oder .^

x = 0:4

x =

     0     1     2     3     4

y = x.*x

y =

     0     1     4     9    16

y = x.^2

y =

     0     1     4     9    16

y = 1./x

y =

          Inf   1.0000e+00   5.0000e-01   3.3333e-01   2.5000e-01

Auswertung von Funktionen

clear all
f = @(x) x.^3+3;
x = linspace(-1,1,100);
plot(x,f(x))

Regeln fuer die Verwendung des Punkt-Operators:

Hinweise fuer die Verwendung von .*, ./, .^ fuer elementweise Operationen

Published with MATLAB® R2014a