Variant: Difference between revisions

From NARS2000
Jump to navigationJump to search
VisualWikitext
(add cat)
Line 1: Line 1:
<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
'''Caution:''' Be careful not to confuse this symbol, which is <apll>⍠</apll>, with <apll>⌹</apll> which is [[Matrix Inverse/Divide]].
<hr /><table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<tr>
   <td>
   <td>
Line 511: Line 512:
</pre></apll>
</pre></apll>


{{Language Toolbar}}
{{Article footer|9|Variant}}
[[Category:Operators]]

Revision as of 11:15, 16 October 2019

Caution: Be careful not to confuse this symbol, which is ⍠, with ⌹ which is Matrix Inverse/Divide.

Z←f⍠B R    or    Z←L f⍠B R evaluates f R or L f R in the context described by B.
L and R are arbitrary arrays conformable with f, and B is a simple scalar, simple or heterogeneous vector, or nested vector.
f is an arbitrary function.

Introduction

The dyadic Variant operator creates a version of the function f with a set of properties bound and localized to it as specified by the array right operand. For example, ⍳⍠0 is a version of ⍳ that executes in origin-0 independent of the current value of ⎕IO.

The array right operand to the operator may take several different forms depending upon the function left operand. In the general case, for any kind of function left operand, the right operand may specify a single property in the form of Key Val, or multiple properties in the form of (Key1 Val1) (Key2 Val2)…, or if the left operand is a primitive function, a shorthand notation may be used as in Val or Val1 Val2 ….

In the general case, the keys specify a property such as Index Origin as 'IO' or Comparison Tolerance as 'CT', and the value part specifies a value appropriate to the property specified in the matching key. At the moment, the keys that may be used are 'CT', 'DT', 'FPC', 'IO', 'LR', 'PP', and 'RL' which stand for the corresponding system variable. Note that for the Variants of L×R and ⌹R and the Subsequence variants such as L⍳⍠'a' R there are no corresponding system variables as yet.

For example:

      1 2 (3+1e¯9)  3⍳⍠(('IO' 0) ('CT' 1e¯10)) 3
3
      1 2 (3+1e¯10) 3⍳⍠(('IO' 0) ('CT' 1e¯10)) 3
2
      ⍳⍠('IO' 0) 3 
0 1 2 
      ⍳⍠('IO' 1) 3 
1 2 3
      ⍳⍠('IO' 0) ⍠('IO' 1) 3 
0 1 2 
      ⍳⍠('IO' 1) ⍠('IO' 0) 3 
1 2 3

Note that in the last two examples, the lefthand (innermost) value of ⎕IO takes precedence.

Shorthand Notation

If the left operand is a primitive or derived function, the following shorthand notation may be used:

Function or
Principal Operator		 Right
Arg
Type		 Meaning
⍳R N ⎕IO←N
L⍳R N ⎕IO←N
N1 N2 ⎕IO←N1 and ⎕CT←N2
C Subsequence C ('a' for Ascending, 'd' for Descending)
N C ⎕IO←N and Subsequence C ('a' for Ascending, 'd' for Descending)
C N ⎕IO←N and Subsequence C ('a' for Ascending, 'd' for Descending)
N1 N2 C ⎕IO←N1, ⎕CT←N2, and Subsequence C ('a' for Ascending, 'd' for Descending)
N1 C N2 ⎕IO←N1, ⎕CT←N2, and Subsequence C ('a' for Ascending, 'd' for Descending)
C N1 N2 ⎕IO←N1, ⎕CT←N2, and Subsequence C ('a' for Ascending, 'd' for Descending)
L⌷R, L⍉R, ⍋R, L⍋R, ⍒R, L⍒R,
L⊃R, ⍸R, LπR, a‼R		 N ⎕IO←N
⍕R and L⍕R N ⎕PP←N
L<R, L≤R, L=R, L≠R, L≥R, L>R,

L∊R, L≡R, L≢R, L∪R, L∩R,
L⊆R, L⊇R, L§R, L~R, L⍷R,

⌊R, ⌈R, ∪R		 N ⎕CT←N
L|R, f⌻R, L f⌻R, ∘⌻R N ⎕CT←N
C ⎕LR←C
N C ⎕CT←N and ⎕LR←C
C N ⎕CT←N and ⎕LR←C
?R and L?R N ⎕IO←N
N1 N2 ⎕IO←N1 and ⎕RL←N2
C ⎕DT←C
N C ⎕IO←N and ⎕DT←C
C N ⎕IO←N and ⎕DT←C
N1 N2 C ⎕IO←N1, ⎕RL←N2, and ⎕DT←C
N1 C N2 ⎕IO←N1, ⎕RL←N2, and ⎕DT←C
C N1 N2 ⎕IO←N1, ⎕RL←N2, and ⎕DT←C
!R (Pochhammer k-symbol) N Rising (N > 0) and Falling (N < 0) factorial of length |N, stepping by 1 in the direction of N
N1 N2 Rising (N1 > 0) and Falling (N1 < 0) factorial of length |N1, stepping by |N2 in the direction of N1
⍎R N ⎕FPC←N
L÷R, L∨R, L∧R, L○R, L⊤R C ⎕LR←C
L×R C Except for Dot Product, these variants are non-trivial only when multiplying Non-commutative numbers.
The following definitions on scalar L and R extend to higher rank arrays in the usual way.

C Name Quaternion/Octonion — Non-commutative Real/Complex — Commutative
'i' Interior product ((L×R)+R×L)÷2 L×R
'e' Exterior product ((L×R)-R×L)÷2 0
'x' Cross product ¯9○<(∘⌻¯9○L)+.×>¯9○R   Quaternions only
where ¯9○R returns (R-+R)÷2, i.e. as a pure imaginary number		 0
'd' Dot product (>L)+.×>R (same)
'c' Conjugation product L×R÷L R
⌹R N where N may be 1, 2, 3, or 4. R must be a square simple Real numeric matrix. If N is 1, the result is a Complex floating point vector of the Eigenvalues of R. If N is 2, the result is a Complex floating point matrix of the Eigenvectors of R, one per column. If N is 3, the result is a two-element nested vector with a Complex vector of the Eigenvalues in the first element and a Complex matrix of the Eigenvectors in the second. If N is 4, the result is a three-element nested vector with a Complex vector of the Eigenvalues in the first element, a Complex matrix of the Eigenvectors in the second, and a Real matrix of the Schur vectors in the third. For more details see Eigenvalues and Eigenvectors.
f.g/0⍴⊂R C ⎕LR←C — this value is used only when the identity function for inner product is called so as to distinguish the Left identity element from the Right. For example, with R←3 4⍴⍳12, the expression ⊃+.×⍠'l'/0⍴⊂R produces the Left identity element (which is a 3 by 3 identity matix) and ⊃+.×⍠'r'/0⍴⊂R produces the Right identity element (which is a 4 by 4 identity matrix). The actual values in the result are dependent on the functions f and g.


Subsequences

Ascending

An Ascending subsequence of one vector in another (L⍳⍠'a' R) is a set of indices of L (barring items Not Found) such that R≡L[L⍳⍠'a' R] and ∧/2</L⍳⍠'a' R, that is the indices are monotonically increasing. This primitive is written such that it returns the smallest values that satisfy the above conditions. All datatypes are valid for the left and right arguments; the result is always an integer vector of the same length as R.

For example:

      L←2 7 1 5 7 1 2 1 7 1
      R←5 2 7 1
      L⍳⍠'a' R
4 7 9 10
      L[L⍳⍠'a' R]
5 2 7 1

If an element in R is Not Found, the corresponding value in the result is ⎕IO+⍴L. Moreover, if an element in R is Not Found, then all following elements in R are also Not Found.

Continuing the above example:

      LL←L,3
      RR←R,9 3
      LL⍳⍠'a' RR
4 7 9 10 12 12
      (LL,'?')[LL⍳⍠'a' RR]
5 2 7 1 ??

Descending

A Descending subsequence of one vector in another (L⍳⍠'d' R) is a set of indices of L (barring items Not Found) such that R≡L[L⍳⍠'d' R] and ∧/2>/L⍳⍠'d' R, that is the indices are monotonically decreasing. This primitive is written such that it returns the largest values that satisfy the above conditions. All datatypes are valid for the left and right arguments; the result is always an integer vector of the same length as R.

For example:

      L←1 2 5 7 2 1 5 7 1 2 5 5 1 2 7
      R←5 2 7 1
      L⍳⍠'d' R
12 10 8 6
      L[L⍳⍠'d' R]
5 2 7 1

If an element in R is Not Found, the corresponding value in the result is ⎕IO-1. Moreover, if an element in R is Not Found, then all following elements in R are also Not Found.

Continuing the above example:

      LL←3,L
      RR←R,9 3
      LL⍳⍠'d' RR
13 11 9 7 0 0
      ('?',LL)[1+LL⍳⍠'d' RR]
5 2 7 1 ??

Combining Variants

Dyadic Iota allows several other Variants such as setting the Index Origin and Comparison Tolerance. They may be combined into one right operand, for example, any of the following expressions

L⍳⍠(0 1E¯10 'd') R   or
L⍳⍠(0 'd' 1E¯10) R   or
L⍳⍠('d' 0 1E¯10) R

may be used to find a Descending Subsequence in origin-0 using a Comparison Tolerance of 1E¯10.

The order of the two numeric values is important: if there is only one number in the right operand, it is applied to the Index Origin; if there are two numbers, the first is applied to the Index Origin and the second to the Comparison Tolerance. The character value may appear anywhere in the right operand — however if a second character-valued Variant were defined for Dyadic Iota, then the two character values would also be order-dependent.

Identities For Subsequences

The following identities hold in either Index Origin even if there are Not Found values in the result:

(L⍳⍠'a' R)≡(1 ¯1[1]+⍴L)-(⌽L)⍳⍠'d' R
(L⍳⍠'d' R)≡(1 ¯1[1]+⍴L)-(⌽L)⍳⍠'a' R

Rising and Falling Factorials

A falling factorial is like a normal factorial except that it subtracts the step value (by default 1 unless overridden) from the original number for a fixed # of iterations. That is, !6 successively decrements 6 by 1 and multiplies the numbers 6 5 4 3 2 1 to get 720. A falling factorial starting with 6 of length (say) 3 multiplies 6 5 4 to get 120.

A rising factorial is like a falling factorial except it adds the step value (by default 1 unless overridden) instead of subtracting it. A rising factorial starting with 6 of length (say) 3 multiplies 6 7 8 to get 336.

Here are some examples of the falling factorial

      !6 
720 
      (!⍠¯6)6 ⍝ ×/6 5 4 3 2 1 
720 
      (!⍠¯5)6 ⍝ ×/6 5 4 3 2 
720 
      (!⍠¯4)6 ⍝ ×/6 5 4 3 
360 
      (!⍠¯3)6 ⍝ ×/6 5 4 
120 
      (!⍠¯2)6 ⍝ ×/6 5
30 
      (!⍠¯1)6 ⍝ ×/6 
6 
      (!⍠¯0)6 ⍝ ×/⍬ 
1

and now falling by 2

      (!⍠(¯6 2))6 ⍝ ×/6 4 2 0 ¯2 ¯4 
0 
      (!⍠(¯5 2))6 ⍝ ×/6 4 2 0 ¯2 
0 
      (!⍠(¯4 2))6 ⍝ ×/6 4 2 0 
0 
      (!⍠(¯3 2))6 ⍝ ×/6 4 2 
48 
      (!⍠(¯2 2))6 ⍝ ×/6 4 
24 
      (!⍠(¯1 2))6 ⍝ ×/6 
6 
      (!⍠(¯0 2))6 ⍝ ×/⍬ 
1

and here are some examples of the rising factorial

      (!⍠6)6 ⍝ ×/6 7 8 9 10 11 
332640 
      (!⍠5)6 ⍝ ×/6 7 8 9 10 
30240 
      (!⍠4)6 ⍝ ×/6 7 8 9 
3024 
      (!⍠3)6 ⍝ ×/6 7 8 
336 
      (!⍠2)6 ⍝ ×/6 7
42
      (!⍠1)6 ⍝ ×/6
6
      (!⍠0)6 ⍝ ×/⍬
1

and now rising by 2

      (!⍠(6 2))6 ⍝ ×/6 8 10 12 14 16 
1290240 
      (!⍠(5 2))6 ⍝ ×/6 8 10 12 14 
80640 
      (!⍠(4 2))6 ⍝ ×/6 8 10 12 
5760 
      (!⍠(3 2))6 ⍝ ×/6 8 10 
480 
      (!⍠(2 2))6 ⍝ ×/6 8 
48 
      (!⍠(1 2))6 ⍝ ×/6 
6 
      (!⍠(0 2))6 ⍝ ×/⍬ 
1

Identities For Rising and Falling Factorials

(!⍠N)R   ←→   (!⍠(N 1))R
(!⍠(N 0))R   ←→   R*N
(!⍠(N1,N2))R   ←→   (!⍠(N1,|N2))R   (the sign of N2 is ignored)

Eigenvalues and Eigenvectors

These concepts from Linear Algebra and Matrix Theory define the characteristic values and vectors of the linear transformation represented by a matrix. Every square simple Real numeric matrix has Eigenvalues and Eigenvectors. To calculate these objects, use the Variant operator with a left operand of the Domino function and a right operand of an integer scalar according to the following table:


Z←(⌹⍠1) R Z is a Complex floating point vector of the Eigenvalues of R
Z←(⌹⍠2) R Z is a Complex floating point matrix of the Eigenvectors of R, one per column
Z←(⌹⍠3) R Z is a two-element nested vector with a Complex floating point vector of the Eigenvalues in the first element and a Complex floating point matrix of the Eigenvectors in the second
Z←(⌹⍠4) R Z is a three-element nested vector with a Complex floating point vector of the Eigenvalues in the first element, a Complex floating point matrix of the Eigenvectors in the second, and a Real matrix of the Schur vectors in the third


For example, Eigenvalues and Eigenvectors can be used to calculate the factorial of a matrix: 

        M←2 2⍴1 3 2 1
        M
  1 3
  2 1
        MatFact←{(Eval Evec)←(⌹⍠3) ⍵
➥⋄ Diag←∘⌻!Eval ⍝ Factorial of Eigenvalues on diagonal
➥⋄ Evec+.×Diag+.×⌹Evec}
        MatFact M
  3.6274 8.8423
  5.8949 3.6274

Note that if we delete the Shriek function in MatFact, the result is the original matrix argument.

In turn, the function MatFact can be used to calculate the Factorial of a HyperComplex number: 

        HyperFact←{M←∘⌻⍵        ⍝ Matrix representation of a HyperComplex number
➥⋄ ⎕IO←1 ⋄ <9○1⌷[2] MatFact M  ⍝ Factorial ...
➥}
        HyperFact 1i2
  0.11229J0.32361
        !1i2
  0.11229J0.32361

where the latter expression uses the Gnu Scientific Library Complex number routines to calculate the Factorial of a Complex number.

In a similar manner, using the appropriate 4×4 matrix representation of a Quaternion, its Factorial can be calculated which is the algorithm used in the implementation: 

        HyperFact <⍳4
  0.0060975i¯0.0010787j¯0.001618k¯0.0021573
        !<⍳4
  0.0060975i¯0.0010787j¯0.001618k¯0.0021573


See Also
System Commands System Variables and Functions Operators


Keyboard
Alt+Shift ⍪ ≡ ≢ ⍒ ⍋ ⌽ ⍉ ⊖ ⍟ ⍱ ⍲ ⍠ ⌹
Alt ⋄ ¨ ¯ < ≤ ∅ ≥ > ≠ ∨ ∧ × ÷
Shift ~ ! @ # $ % ^ & * ( ) _ +
Key ` 1 2 3 4 5 6 7 8 9 0 - =
Alt+Shift ⍷ √ ⍨ ⍸ ⍥ ⍣ ⍞ ⍬ ⊣
Alt ? ⍵ ∊ ⍴ § ↑ ↓ ⍳ ○ π ← → ⊢
Shift Q W E R T Y U I O P { } |
Key q w e r t y u i o p [ ] \
Alt+Shift ∫ ∂ ⌻ ⍢ ⍙ ⍤ ⍫ ⌷
Alt ⍺ ⌈ ⌊ ∞ ∇ ∆ ∘ ‼ ⎕ ⍎ ⍕
Shift A S D F G H J K L : "
Key a s d f g h j k l ; '
Alt+Shift ⊆ ⊇ χ ⍡ ⍭ ⊙
Alt ⊂ ⊃ ∩ ∪ ⊥ ⊤ ⍦ ⍝ ⍀ ⌿
Shift Z X C V B N M < > ?
Key z x c v b n m , . /
NARS 2000 Lang
Tool
Bar 		← → + - × ÷ * ⍟ ⌹ ○ ! ? √ | ⌈ ⌊ ⊥ ⊤ ⊣ ⊢
≡ ≢ < ≤ = ≥ > ≠ ∨ ∧ ⍱ ⍲ ↑ ↓ ⊂ ⊃ ⌷ ⍋ ⍒
⍳ ∊ ⍸ ⍷ ∪ ∩ ⊆ ⊇ ~ § π .. , ⍪ ⍴ ⌽ ⊖ ⍉
/ \ ⌿ ⍀ ⊙ ¨ ⍨ ⍤ ⍡ ⍥ ⍦ . ∘ ⍠ ‼ ⌻ ∂ ∫ ⍞ ⎕ ⍎ ⍕
⋄ ⍝ ∇ ∆ ⍙ _ ⍺ ⍵ ¯ ⍬ ∞ ∅
Second Row i j k i j k l g p r v x
Retrieved from "https://wiki.nars2000.org/index.php?title=Variant&oldid=3683"