Comment GNU Octave de la matrice de travail de la division? Obtenir un comportement inattendu.

Dans GNU Octave, Comment matrice de travail de la division?

Au lieu de faire

1./[1;1]

J'ai accidentellement fait

1/[1;1]

À ma grande surprise, cela donne:

[0.5, 0.5]

La transversale de cas:

1/[1,1]

donne attendus:

error: operator /: nonconformant arguments (op1 is 1x1, op2 is 1x2)

Quelqu'un peut m'expliquer l' [0.5, 0.5] résultat?

OriginalL'auteur eyaler | 2012-09-04

5

c'est une réponse que j'ai obtenu à partir d'Alan Boulton à la coursera machine learning cours forum de discussion:

L'essentiel de l'idée, c'est que x /y est définie de façon très générale, de sorte qu'il peut traiter avec des matrices. Conceptuellement, l'opérateur /est d'essayer de le retourner x∗y−1 (ou x * inv(y) dans l'Octave de parler), comme dans l'exemple suivant:
```
octave:1> eye(2)/[1 2;3 4]
ans =
  -2.00000   1.00000
   1.50000  -0.50000

octave:2> inv([1 2;3 4])
ans =
  -2.00000   1.00000
   1.50000  -0.50000
```
La trickiness qui se passe lorsque y est un vecteur colonne, auquel cas l'inv(y) n'est pas défini, donc pinv(a), la psuedoinverse de y, est utilisé.
```
octave:1> pinv([1;2])
ans =
   0.20000   0.40000

octave:2> 1/[1;2]
ans =
   0.20000   0.40000
```
Le vecteur y doit être compatible avec x, donc x * pinv(y) est bien définie. Donc c'est ok si y est un vecteur ligne, à condition que x est compatible. Voir la suite de l'Octave de session à des fins d'illustration:
```
octave:18> pinv([1 2])
ans =
   0.20000
   0.40000

octave:19> 1/[1 2]
error: operator /: nonconformant arguments (op1 is 1x1, op2 is 1x2)
octave:19> eye(2)/[1 2]
ans =
   0.20000
   0.40000

octave:20> eye(2)/[1;2]
error: operator /: nonconformant arguments (op1 is 2x2, op2 is 2x1)
octave:20> 1/[1;2]
ans =
   0.20000   0.40000
```
OriginalL'auteur eyaler
3

Condier exemple suivant,
```
>> A = [5 10];

>> B = [2 2];
```
Si vous voulez de l'élément de sage division, utiliser Un ./B avec la matrice de taille de ces deux éléments, l'égalité des je.e Si A est de taille m∗n B doit être de taille m∗n
```
>> A ./B
ans =

    2.5000   5.0000
```
Si vous voulez de la matrice par la matrice de la division, l'utilisation A /B avec la matrice de la taille de l'élément A m∗n et B telles que q∗n ou m∗n. L'opérateur /est d'essayer de le retourner x∗y−1 (j'.e x * pinv(a) dans l'octave de format).
```
>> A / B
ans =  3.7500
```
qui est la même que
```
>> A * pinv(B)
ans =  3.7500
```
pinv() fonction OCTAVE/MATLAB renvoie de Moore-Penrose de pseudo-inverse de la matrice, alors que l'inv() renvoie l'inverse de la matrice.
Si vous êtes confus au sujet de ce à utiliser, l'utiliser pinv()
Si vous souhaitez plus de précisions sur Quelle est la différence entre pinv et inv?

OriginalL'auteur Akash
2

Matrice de division de l'Octave expliqué:

Une description formelle de l'Octave de la Matrice de la Division à partir d'ici

http://www.gnu.org/software/octave/doc/interpreter/Arithmetic-Ops.html
```
x / y
    Right division. This is conceptually equivalent to the expression
    (inverse (y') * x')'

    But it is computed without forming the inverse of y'.

    If the system is not square, or if the coefficient matrix is 
    singular, a minimum norm solution is computed. 
```
Ce que cela signifie, c'est que ces deux doit être la même:
```
[3 4]/[4 5; 6 7]
ans =
   1.50000  -0.50000

(inverse([4 5; 6 7]') * [3 4]')'
ans =
   1.50000  -0.50000
```
Tout d'abord, comprendre que l'Octave de la matrice de la division n'est pas commutative, tout comme la matrice de la Multiplication n'est pas commutative.

Cela signifie que A /B n'est pas égal à B /A
```
1/[1;1]
ans =
   0.50000   0.50000

[1;1]/1
ans =
   1
   1
```
Un divisé par une matrice avec une seule valeur, qui est l'un:
```
1/[1]
ans = 1
```
Un divisé par une matrice avec une seule valeur de trois est 0.33333:
```
1/[3]
ans = .33333
```
Un divisé par un (1x2) de la matrice:
```
1/[1;1]
ans =
   0.50000   0.50000

Equivalent:

([1/2;1/2] * 1)'
ans =
   0.50000   0.50000
```
Avis ci-dessus, comme les instructions dit, nous prenons la norme du vecteur. Donc, vous voyez comment le [1;1] a été transformé en [1/2; 1/2]. Le '2' vient de la longueur du vecteur, le 1 est livré à partir du vecteur. Nous allons faire un autre:

Un divisé par un (1x3) de la matrice:
```
1/[1;1;1]
ans = 
    0.33333   0.33333   0.33333   
```
Équivalent:
```
 ([1/3;1/3;1/3] * 1)'
 ans =
    0.33333   0.33333   0.33333
```
Ce que si l'un des éléments sont négatifs...
```
1/[1;1;-1]
ans =
    0.33333   0.33333  -0.33333
```
Équivalent:
```
([1/3;1/3;-1/3] * 1)'
ans =
   0.33333   0.33333  -0.33333
```
Alors maintenant, vous avez une idée générale de ce que l'Octave est en train de faire lorsque vous n'avez pas à fournir une matrice carrée. Pour comprendre ce que l'Octave de la matrice section ne quand vous passez une matrice carrée vous devez comprendre ce que la fonction inverse est en train de faire.

J'ai été à la normalisation de vos vecteurs par contre, si vous voulez octave faire vous pouvez ajouter des packages pour le faire, je pense que le paquet suivant permettra de faire ce que j'ai fait avec le vecteur de normalisation:

http://octave.sourceforge.net/geometry/function/normalizeVector.html

Alors maintenant, vous pouvez convertir la division en un équivalent de multiplication. Lisez cet article sur comment la matrice de multiplication de travaux, et vous pouvez revenir en arrière et comprendre ce qui se passe sous le capot d'une matrice de division.

http://www.purplemath.com/modules/mtrxmult2.htm

et le cas: 1/[1,1]?

OriginalL'auteur Eric Leschinski

Vous devez vous connecter pour publier un commentaire.

Matrice de division de l'Octave expliqué: