Suora toiminto - Direct function

Suora toiminto ( dfn , lausutaan "Dee hauskaa") on vaihtoehtoinen tapa määrittää funktion ja operaattori (a korkeamman asteen funktiota ) on ohjelmointikieli APL . Suoraa operaattoria voidaan kutsua myös dopiksi (lausutaan "dee op"). John Scholes keksi ne vuonna 1996. Ne ovat ainutlaatuinen yhdistelmä matriisiohjelmointia , korkeamman asteen toimintoja ja toiminnallisia ohjelmointeja , ja ne ovat merkittävä erotus 21. vuosisadan alun APL: lle verrattuna aiempiin versioihin.

Dfn on sekvenssi mahdollisesti suojattava lausekkeita (tai vain suojusta) välillä {ja }, jotka on erotettu ⋄tai uusia-linjat, jolloin ⍺merkitsee vasemmalle argumentti ja ⍵oikealle, ja ∇merkitsee rekursio (toiminto itse-referenssi). Esimerkiksi funktio PTtestaa, onko kukin rivi ⍵on Pythagoralaisen tripletti (testaamalla, onko neliösumma on yhtä suuri kuin kaksi kertaa neliön maksimi).

   PT← {(+/⍵*2)=2×(⌈/⍵)*2}
   PT 3 4 5
1
   x
 4  5  3
 3 11  6
 5 13 12
17 16  8
11 12  4
17 15  8
   PT x
1 0 1 0 0 1

Kertoma toiminto kuin dfn:

   fact← {0=⍵:1 ⋄ ⍵×∇ ⍵-1}
   fact 5
120
   fact¨ ⍳10    ⍝ fact applied to each element of 0 to 9
1 1 2 6 24 120 720 5040 40320 362880

Kuvaus

Dfns -säännöt on tiivistetty seuraavalla "viitekortilla":

`{⍺ function ⍵}`	`{⍺⍺ operator ⍵⍵}`	`:` vartija
`⍺` vasen argumentti	`⍺⍺` vasen operandi	`::` virhesuoja
`⍵` oikea argumentti	`⍵⍵` oikea operandi	`⍺←` vasen oletus argumentti
`∇` itseviittaus	`∇∇` itseviittaus	`s←` ujo tulos

Dfn on mahdollisesti suojattujen lausekkeiden sekvenssi (tai vain vartija) rivien välillä {ja }, erotettuna ⋄tai uusilla riveillä.

expression
guard: expression
guard:

Lausekkeet ja/tai suojukset arvioidaan järjestyksessä. Vartijan on arvioitava 0 tai 1; siihen liittyvä lauseke arvioidaan, jos arvo on 1. A dfn päättyy ensimmäisen suojaamattoman lausekkeen jälkeen, joka ei pääty tehtävään , tai ensimmäisen suojatun lausekkeen jälkeen, jonka vartija arvioi arvoksi 1, tai jos lausekkeita ei enää ole. Dfn: n tulos on viimeksi arvioidun lausekkeen tulos. Jos viimeksi arvioitu lauseke päättyy tehtävään, tulos on "ujo" - sitä ei näytetä automaattisesti istunnossa.

Dfn: ssä annetut nimet ovat oletusarvoisesti paikallisia , ja niillä on sanallinen laajuus .

⍺merkitsee vasenta funktion argumenttia ja ⍵oikeaa; ⍺⍺tarkoittaa vasenta operandia ja ⍵⍵oikeaa. Jos ⍵⍵määritelmässä esiintyy, dfn on dyadinen operaattori ; jos vain ⍺⍺tapahtuu, mutta ei ⍵⍵, niin se on monadinen operaattori; jos kumpikaan ⍺⍺tai ⍵⍵tapahtuu, dfn on funktio.

Erityistä syntaksia käytetään antamaan oletusarvo vasemmanpuoleiselle argumentille, jos dfn kutsutaan monadisesti eli soitetaan ilman vasenta argumenttia. Sitä ei arvioida muuten. ⍺←expression⍺←expression

∇tarkoittaa funktion rekursiota tai itseviittausta ja ∇∇operaattorin itseviittausta. Tällainen merkintä mahdollistaa nimettömän rekursion .

Virhe ansastusta on kautta virhe-vartijoita, . Kun virhe luodaan, järjestelmä etsii dynaamisesti kutsutoimintojen kautta virhettä vastaavaa virhesuojaa. Jos sellainen löydetään, suoritusympäristö puretaan tilaan juuri ennen virhesuojaimen suorittamista ja siihen liittyvä virhesuojelulauseke arvioidaan dfn: n tuloksena. errnums::expression

Lisää kuvauksia, selityksiä ja opetusohjelmia dfns -tiedostoista on saatavilla viitattuissa artikkeleissa.

Esimerkkejä

Tässä olevat esimerkit kuvaavat dfns: n eri näkökohtia. Muita esimerkkejä on viitattuissa artikkeleissa.

Oletusvasen argumentti

Toiminto lisää ja ( $i$ tai $\sqrt$ $-1$ ) kertaa . {⍺+0j1×⍵}⍺0j1⍵

   3 {⍺+0j1×⍵} 4
3J4
   ∘.{⍺+0j1×⍵}⍨ ¯2+⍳5
¯2J¯2 ¯2J¯1 ¯2 ¯2J1 ¯2J2
¯1J¯2 ¯1J¯1 ¯1 ¯1J1 ¯1J2
 0J¯2  0J¯1  0  0J1  0J2
 1J¯2  1J¯1  1  1J1  1J2
 2J¯2  2J¯1  2  2J1  2J2

Tämän toiminnon merkitys voidaan nähdä seuraavasti:

Monimutkaiset luvut voidaan rakentaa reaalilukujen järjestettyinä pareina, samalla tavalla kuin kokonaislukuja voidaan rakentaa järjestettyinä luonnollisien numeroiden pareiksi ja järkeviä numeroita kokonaislukujen pariksi. Monimutkaisilla numeroilla on sama rooli kuin kokonaisluvuilla ja rationaaliluvuilla.{⍺+0j1×⍵}-÷

Lisäksi funktion monadinen määritelmä on hyödyllinen monadisen ⇔ ( negatiivin ) ja monadisen ⇔ ( vastavuoroisen ) vastaavan funktion määrittämisen yhteydessä, mikä tapahtuu määrittämällä oletusarvo 0 : jos , niin ⇔ ⇔ . -⍵0-⍵÷⍵1÷⍵⍺j←{⍺←0 ⋄ ⍺+0j1×⍵}j ⍵0 j ⍵0+0j1×⍵

   j←{⍺←0 ⋄ ⍺+0j1×⍵}

   3 j 4 ¯5.6 7.89
3J4 3J¯5.6 3J7.89

   j 4 ¯5.6 7.89
0J4 0J¯5.6 0J7.89

   sin← 1∘○
   cos← 2∘○
   Euler← {(*j ⍵) = (cos ⍵) j (sin ⍵)}

   Euler (¯0.5+?10⍴0) j (¯0.5+?10⍴0)
1 1 1 1 1 1 1 1 1 1

Viimeinen lauseke kuvaa Eulerin kaavaa kymmenestä satunnaisluvusta, joiden välissä on todellisia ja kuvitteellisia osia . ${\ displaystyle \ left (-0,5,0,5 \ right)}$

Yksittäinen rekursio

Cantor -sarjan kolmiosainen rakenne alkaa aikavälillä [0,1] ja kussakin vaiheessa poistaa keskimmäisen kolmanneksen jokaisesta jäljellä olevasta alivälistä:

${\ displaystyle {\ biggl [} 0,1 {\ biggr]} \ to}$

${\ displaystyle \ left [0, {\ frac {1} {3}} \ right] \ cup \ left [{\ frac {2} {3}}, 1 \ right] \ to}$

${\ displaystyle \ left [0, {\ frac {1} {9}} \ right] \ cup \ left [{\ frac {2} {9}}, {\ frac {1} {3}} \ right] \ cup \ vasen [{\ frac {2} {3}}, {\ frac {7} {9}} \ oikea] \ cup \ vasen [{\ frac {8} {9}}, 1 \ oikea] \ \ cdots}$

Cantor -järjestys ⍵määritellään dfn:

   Cantor← {0=⍵:,1 ⋄ ,1 0 1 ∘.∧ ∇ ⍵-1}

   Cantor 0
1
   Cantor 1
1 0 1
   Cantor 2
1 0 1 0 0 0 1 0 1
   Cantor 3
1 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 1

Cantor 0 - Cantor 6 on kuvattu mustina palkeina:

Funktio laskee bittivektorin, jonka pituus on niin, että bitti (for ja ) on 1, jos ja vain jos on alkuluku . sieve ⍵⍵i0≤ii<⍵i

sieve←{
  4≥⍵:⍵⍴0 0 1 1
  r←⌊0.5*⍨n←⍵
  p←2 3 5 7 11 13 17 19 23 29 31 37 41 43
  p←(1+(n≤×⍀p)⍳1)↑p
  b← 0@1 ⊃ {(m⍴⍵)>m⍴⍺↑1 ⊣ m←n⌊⍺×≢⍵}⌿ ⊖1,p
  {r<q←b⍳1:b⊣b[⍵]←1 ⋄ b[q,q×⍸b↑⍨⌈n÷q]←0 ⋄ ∇ ⍵,q}p
}

   10 10 ⍴ sieve 100
0 0 1 1 0 1 0 1 0 0
0 1 0 1 0 0 0 1 0 1
0 0 0 1 0 0 0 0 0 1
0 1 0 0 0 0 0 1 0 0
0 1 0 1 0 0 0 1 0 0
0 0 0 1 0 0 0 0 0 1
0 1 0 0 0 0 0 1 0 0
0 1 0 1 0 0 0 0 0 1
0 0 0 1 0 0 0 0 0 1
0 0 0 0 0 0 0 1 0 0

   b←sieve 1e9
   ≢b
1000000000
   (10*⍳10) (+⌿↑)⍤0 1 ⊢b
0 4 25 168 1229 9592 78498 664579 5761455 50847534

Viimeinen sekvenssi, alkukertojen määrä pienempi kuin 10, on OEIS : n ensimmäinen osa : A006880 . Viimeinen numero, 50847534, on alukkeiden määrä alle . Sitä kutsutaan Bertelsenin numeroksi, jota MathWorld kuvasi muistoksi "virheelliseksi nimeksi, joka on virheellisesti annettu virheellisen arvon " perusteella. ${\ displaystyle 10^{9}}$ ${\ displaystyle \ pi (10^{9}) = 50847478}$

sievekäyttää kahta eri menetelmää komposiittien merkitsemiseen 0 -arvoilla, molemmat käyttäen paikallisia anonyymejä dfns -tiedostoja: Ensimmäinen käyttää Eratosthenes -seulaa 1 -alkamaskin ja alukkeiden etuliitteen 2 3 ... 43 avulla insert -operaattorin avulla ⌿( oikea taitto ). (Etuliitteen pituus saadaan vertaamalla primorial -funktiota .) Toinen löytää pienimmän uuden alkutuloksen, joka on jäljellä ( ): ssa, ja asettaa itselleen 0 -bittisen ja bittien ajoittain numerot jäljellä olevilla 1 bitillä ( ): n ensimmäisessä segmentissä . Tämä toinen dfn käyttää hännän rekursiota. ×⍀pqbq←b⍳1qqb⍸b↑⍨⌈n÷q

Hännän rekursio

Yleensä tekijäfunktio määritellään rekursiivisesti (kuten yllä ), mutta se voidaan koodata hyödyntämään hännän rekursiota käyttämällä akun vasen -argumenttia:

fac←{⍺←1 ⋄ ⍵=0:⍺ ⋄ (⍺×⍵) ∇ ⍵-1}

Samoin tekijä neliön monimutkainen matriisi Gaussin eliminointia voidaan laskea hännän rekursio:

det←{                ⍝ determinant of a square complex matrix
  ⍺←1                ⍝ product of co-factor coefficients so far
  0=≢⍵:⍺             ⍝ result for 0-by-0
  (i j)←(⍴⍵)⊤⊃⍒|,⍵   ⍝ row and column index of the maximal element
  k←⍳≢⍵
  (⍺×⍵[i;j]×¯1*i+j) ∇ ⍵[k~i;k~j] - ⍵[k~i;j] ∘.× ⍵[i;k~j]÷⍵[i;j]
}

Useita rekursioita

Osio ei-negatiivinen kokonaisluku, on vektori positiivisia kokonaislukuja niin, että silloin, kun tilaa ei ole merkittävä. Esimerkiksi ja ovat osioita 4, ja ja ja niitä pidetään samoina osioina. ${\ displaystyle n}$ ${\ displaystyle v}$ n = +⌿v ${\ displaystyle v}$ 2 22 1 12 1 11 2 11 1 2

Osion toiminto laskee osioiden määrä. Toiminto kiinnostaa lukuteoriaa , jota ovat tutkineet Euler , Hardy , Ramanujan , Erdős ja muut. Toistumissuhde ${\ displaystyle P (n)}$

{\ displaystyle P (n) = \ summa _ {k = 1}^{n} (-1)^{k+1} [P (n-{\ frac {1} {2}} k (3k-1) ))+P (n-{\ frac {1} {2}} k (3k+1))]}

johdettu Eulerin viisikulmaisesta lukulauseesta . Dfn -muodossa kirjoitettu:

   pn  ← {1≥⍵:0≤⍵ ⋄ -⌿+⌿∇¨rec ⍵}
   rec ← {⍵ - (÷∘2 (×⍤1) ¯1 1 ∘.+ 3∘×) 1+⍳⌈0.5*⍨⍵×2÷3}

   pn 10
42
   pn¨ ⍳13    ⍝ OEIS A000041
1 1 2 3 5 7 11 15 22 30 42 56 77

Perusteella askel todetaan, että , tuloksena toiminto on , 1 jos ⍵ on 0 tai 1 ja 0 muutoin. Rekursiivinen vaihe on erittäin moninkertainen rekursiivinen. Seurauksena on esimerkiksi, että toimintoa sovelletaan kaikkiin elementteihin , jotka ovat: 1≥⍵:0≤⍵1≥⍵0≤⍵pn 200rec 200

   rec 200
199 195 188 178 165 149 130 108 83 55 24 ¯10
198 193 185 174 160 143 123 100 74 45 13 ¯22

ja sen laskeminen vaatii maailmankaikkeuden ikää kauemmin ( funktio kutsuu itseään). Laskenta-aikaa voidaan lyhentää muistiinpanolla , joka on tässä toteutettu suorana operaattorina (korkeamman asteen toiminto) : pn 200 ${\ displaystyle 7,57 \ kertaa 10^{47}}$ M

M←{
  f←⍺⍺
  i←2+'⋄'⍳⍨t←2↓,⎕cr 'f'
  ⍎'{T←(1+⍵)⍴¯1 ⋄ ',(i↑t),'¯1≢T[⍵]:⊃T[⍵] ⋄ ⊃T[⍵]←⊂',(i↓t),'⍵}⍵'
}

   pn M 200
3.973E12
   0 ⍕ pn M 200  ⍝ format to 0 decimal places
 3972999029388

Tämä arvo vastaa Hardyn ja Ramanujanin vuonna 1918 laskemaa arvoa . pn M 200

Muistio operaattori Mmäärittää muunnos sen operandin funktio ⍺⍺käyttää välimuistiin T ja sitten arvioi sen. Operandin pnkanssa variantti on:

{T←(1+⍵)⍴¯1 ⋄ {1≥⍵:0≤⍵ ⋄ ¯1≢T[⍵]:⊃T[⍵] ⋄ ⊃T[⍵]←⊂-⌿+⌿∇¨rec ⍵}⍵}

Suora operaattori (dop)

Pikavalinta matriisissa ⍵toimii valitsemalla "pivot" satunnaisesti sen tärkeimpien solujen joukosta ja sitten kataenimalla lajitellut pääsolut , jotka ovat ehdottomasti pivotia edellä, tärkeimmät solut, jotka ovat yhtä suuret kuin pivot, ja lajitellut pääsolut, jotka seuraavat tarkasti niveltä, kuten määritetään vertailutoiminnolla ⍺⍺. Suora operaattori (dop) Q:

   Q←{1≥≢⍵:⍵ ⋄ (∇ ⍵⌿⍨0>s)⍪(⍵⌿⍨0=s)⍪∇ ⍵⌿⍨0<s←⍵ ⍺⍺ ⍵⌷⍨?≢⍵}

   ⍝ precedes            ⍝ follows            ⍝ equals
   2 (×-) 8              8 (×-) 2             8 (×-) 8
¯1                    1                    0

   x← 2 19 3 8 3 6 9 4 19 7 0 10 15 14

   (×-) Q x
0 2 3 3 4 6 7 8 9 10 14 15 19 19

Q3on muunnos, joka catenates kolme osaa suljettu toiminnan ⊂sijasta osien sinänsä . Kussakin rekursiivisessa vaiheessa syntyvät kolme osaa näkyvät lopputuloksen rakenteessa. Kun Q3samasta argumentista johdettu funktio käytetään useita kertoja, saadaan erilaisia tuloksia, koska pivotit valitaan sattumanvaraisesti. Tulosten järjestyksessä läpikäynti tuottaa saman lajiteltu taulukon.

   Q3←{1≥≢⍵:⍵ ⋄ (⊂∇ ⍵⌿⍨0>s)⍪(⊂⍵⌿⍨0=s)⍪⊂∇ ⍵⌿⍨0<s←⍵ ⍺⍺ ⍵⌷⍨?≢⍵}

   (×-) Q3 x
┌────────────────────────────────────────────┬─────┬┐
│┌──────────────┬─┬─────────────────────────┐│19 19││
││┌──────┬───┬─┐│6│┌──────┬─┬──────────────┐││     ││
│││┌┬─┬─┐│3 3│4││ ││┌┬─┬─┐│9│┌┬──┬────────┐│││     ││
│││││0│2││   │ ││ ││││7│8││ │││10│┌──┬──┬┐││││     ││
│││└┴─┴─┘│   │ ││ ││└┴─┴─┘│ │││  ││14│15││││││     ││
││└──────┴───┴─┘│ ││      │ │││  │└──┴──┴┘││││     ││
││              │ ││      │ │└┴──┴────────┘│││     ││
││              │ │└──────┴─┴──────────────┘││     ││
│└──────────────┴─┴─────────────────────────┘│     ││
└────────────────────────────────────────────┴─────┴┘
   (×-) Q3 x
┌───────────────────────────┬─┬─────────────────────────────┐
│┌┬─┬──────────────────────┐│7│┌────────────────────┬─────┬┐│
│││0│┌┬─┬─────────────────┐││ ││┌──────┬──┬────────┐│19 19│││
│││ │││2│┌────────────┬─┬┐│││ │││┌┬─┬─┐│10│┌──┬──┬┐││     │││
│││ │││ ││┌───────┬─┬┐│6│││││ │││││8│9││  ││14│15││││     │││
│││ │││ │││┌┬───┬┐│4│││ │││││ │││└┴─┴─┘│  │└──┴──┴┘││     │││
│││ │││ │││││3 3│││ │││ │││││ ││└──────┴──┴────────┘│     │││
│││ │││ │││└┴───┴┘│ │││ │││││ │└────────────────────┴─────┴┘│
│││ │││ ││└───────┴─┴┘│ │││││ │                             │
│││ │││ │└────────────┴─┴┘│││ │                             │
│││ │└┴─┴─────────────────┘││ │                             │
│└┴─┴──────────────────────┘│ │                             │
└───────────────────────────┴─┴─────────────────────────────┘

Yllä oleva muotoilu ei ole uusi; katso esimerkiksi kuva 3.7 klassisesta Tietokonealgoritmien suunnittelu ja analyysi . Kuitenkin toisin kuin pidin ALGOL -ohjelma kuvassa 3.7, Qon suoritettava ja lajittelussa käytetty ositilaus on operandi, yllä olevat esimerkit. (×-)

Dfns operaattoreiden ja junien kanssa

Dfns, erityisesti anonyymi dfns, toimivat hyvin operaattoreiden ja junien kanssa. Seuraava katkelma ratkaisee "Ohjelmointihelmet" -tehtävän: kun löydät englanninkielisen sanakirjan, joka on tässä merkkimatriisina a, etsi kaikki anagrammit.

   a            {⍵[⍋⍵]}⍤1 ⊢a        ({⍵[⍋⍵]}⍤1 {⊂⍵}⌸ ⊢) a
pats         apst                ┌────┬────┬────┐
spat         apst                │pats│teas│star│
teas         aest                │spat│sate│    │
sate         aest                │taps│etas│    │
taps         apst                │past│seat│    │
etas         aest                │    │eats│    │
past         apst                │    │tase│    │
seat         aest                │    │east│    │
eats         aest                │    │seta│    │
tase         aest                └────┴────┴────┘
star         arst
east         aest
seta         aest

Algoritmi toimii lajittelemalla rivit erikseen ( ), ja nämä Lajiteltujen rivien käytetään avaimet ( "allekirjoitus" in Ohjelmointi Pearls kuvaus) on keskeinen operaattori ryhmitellä matriisin rivit. Oikealla oleva ilmaisu on juna , syntaktinen muoto, jota APL käyttää hiljaisen ohjelmoinnin saavuttamiseen . Tässä se on eristetty kolmen funktion sarja siten, että ⇔ , josta oikealla oleva lauseke vastaa . {⍵[⍋⍵]}⍤1 ⊢a⌸(f g h) ⍵(f ⍵) g (h ⍵)({⍵[⍋⍵]}⍤1 ⊢a) {⊂⍵}⌸ a

Lexical soveltamisala

Kun sisempi (sisäkkäisiä) dfn viittaa nimen, se haetaan etsii ulospäin läpi sulkee dfns pikemminkin kuin pitkin kutsupino . Tämän järjestelmän sanotaan käyttävän leksistä laajuutta APL: n tavanomaisen dynaamisen laajuuden sijasta . Ero tulee ilmeiseksi vain, jos kutsutaan toiminto, joka on määritetty ulkoisella tasolla. Tavallisempia sisäpuheluita varten kaksi järjestelmää ovat erottamattomia.

Esimerkiksi seuraavassa funktiossa whichmuuttuja tymääritellään sekä whichitsessään että sisäisessä funktiossa f1. Kun f1soitetaan ulospäin f2ja f2viitataan siihen ty, se löytää ulkoisen (arvolla 'lexical') sen sijaan, että se määritellään f1(arvolla 'dynamic'):

which←{
  ty←'lexical'
  f1←{ty←'dynamic' ⋄ f2 ⍵}
  f2←{ty,⍵}
  f1 ⍵
}

   which ' scope'
lexical scope

Virhesuoja

Seuraava toiminto havainnollistaa virhesuojainten käyttöä:

plus←{
  tx←'catch all' ⋄  0::tx
  tx←'domain'    ⋄ 11::tx
  tx←'length'    ⋄  5::tx
  ⍺+⍵
}      
   2 plus 3              ⍝ no errors
5
   2 3 4 5 plus 'three'  ⍝ argument lengths don't match
length
   2 3 4 5 plus 'four'   ⍝ can't add characters
domain
   2 3 plus 3 4⍴5        ⍝ can't add vector to matrix
catch all

APL: ssä virhe numero 5 on "pituusvirhe"; virhe numero 11 on "verkkotunnusvirhe"; ja virheen numero 0 on "saalis kaikki" virheille 1-999.

Esimerkki osoittaa paikallisen ympäristön purkautumisen ennen virhesuojaimen lausekkeen arviointia. Paikallinen nimi txon määritetty kuvaamaan sen seuraavan virhesuojauksen tehtävää. Kun tapahtuu virhe, ympäristö puretaan niin, että se paljastaa txstaattisesti oikean arvon.

Dfns versus tradfns

Koska suorat funktiot ovat dfns, perinteisellä tavalla määriteltyjä APL -toimintoja kutsutaan tradfnsiksi, lausutuksi "trad funs". Tässä dfns: ää ja tradfnsia verrataan funktion perusteella sieve: Vasemmalla on dfn (kuten edellä on määritelty ); keskellä on tradfn käyttäen valvonta rakenteita ; Oikealla on tradfn käyttäen GOTOt ( →) ja linja etiketit .

sieve←{
  4≥⍵:⍵⍴0 0 1 1
  r←⌊0.5*⍨n←⍵
  p←2 3 5 7 11 13 17 19 23 29 31 37 41 43
  p←(1+(n≤×⍀p)⍳1)↑p
  b← 0@1 ⊃ {(m⍴⍵)>m⍴⍺↑1 ⊣ m←n⌊⍺×≢⍵}⌿ ⊖1,p
  {r<q←b⍳1:b⊣b[⍵]←1 ⋄ b[q,q×⍸b↑⍨⌈n÷q]←0 ⋄ ∇ ⍵,q}p
}

∇ b←sieve1 n;i;m;p;q;r
  :If 4≥n ⋄ b←n⍴0 0 1 1 ⋄ :Return ⋄ :EndIf
  r←⌊0.5*⍨n
  p←2 3 5 7 11 13 17 19 23 29 31 37 41 43
  p←(1+(n≤×⍀p)⍳1)↑p
  b←1
  :For q :In p ⋄ b←(m⍴b)>m⍴q↑1 ⊣ m←n⌊q×≢b ⋄ :EndFor
  b[1]←0
  :While r≥q←b⍳1 ⋄ b[q,q×⍸b↑⍨⌈n÷q]←0 ⋄ p⍪←q ⋄ :EndWhile
  b[p]←1
∇

∇ b←sieve2 n;i;m;p;q;r
  →L10 ⍴⍨ 4<n ⋄ b←n⍴0 0 1 1 ⋄ →0
 L10:
  r←⌊0.5*⍨n
  p←2 3 5 7 11 13 17 19 23 29 31 37 41 43
  p←(1+(n≤×\p)⍳1)↑p
  i←0 ⋄ b←1
 L20:
  b←(m⍴b)>m⍴p[i]↑1 ⊣ m←n⌊p[i]×≢b
  →L20 ⍴⍨ (≢p)>i←1+i
  b[1]←0
 L30:
  →L40 ⍴⍨ r<q←b⍳1 ⋄ b[q,q×⍸b↑⍨⌈n÷q]←0 ⋄ p⍪←q ⋄ →L30
 L40:
  b[p]←1
∇

Dfn voi olla anonyymi ; tradfn on nimettävä.
Dfn nimetään tehtävän ( ←) avulla; tradfn nimetään upottamalla nimi funktion esitykseen ja soveltamalla ⎕fx(järjestelmän funktiota) kyseiseen esitykseen.
Dfn on operandina kätevämpi kuin tradfn (katso edelliset kohdat: tradfn on nimettävä; tradfn nimetään upottamalla ...).
Nimet annetaan joka dfn ovat paikallista oletusarvoisesti; Tradfn: ssä määritetyt nimet ovat yleisiä, ellei paikallisten luettelossa ole mainittu.
Dfn: n paikallisilla on leksuaalinen laajuus ; paikalliset joka tradfn on dynaaminen laajuus , näkyy kutsutaan toimintoja ellei varjostama mukaan niiden paikallisten lista.
Dfn: n argumentit on nimetty ⍺ja dopin ⍵operandit on nimetty ⍺⍺ja ⍵⍵; tradfn: n argumentteilla ja operandeilla voi olla mikä tahansa nimi, joka on määritetty sen eturivillä.
Dfn: n tulos (jos sellainen on) on nimetön; tradfn: n tulos (jos sellainen on) nimetään sen otsikossa.
Oletusarvo ⍺: lle on määritetty siistimmin kuin tradfn: n vasen argumentti.
Rekursio on dfn suoritetaan kutsuvan ∇tai ∇∇tai sen nimi; rekursio Tradfn: ssä suoritetaan vetoamalla sen nimeen.
Virtauksen ohjaus dfn: ssä suoritetaan vartijoilla ja toimintokutsuilla; että tradfn: ssä on valvontarakenteita ja →(goto) - ja rivitarroja .
Lausekkeen arvioiminen dfn: ssä, joka ei pääty tehtävään, palauttaa dfn: n; rivin arviointi tradfnissa, joka ei pääty tehtävään tai gotoon, näyttää rivin tuloksen.
Dfn palaa arvioidessaan lauseketta, joka ei pääty tehtävään, arvioidessaan suojattua lauseketta tai viimeisen lausekkeen jälkeen; tradfn palaa →(goto) riville 0 tai olemattomalle riville tai ohjausrakenteen arvioinnissa tai viimeisen rivin jälkeen.:Return
Yksinkertaisempi virtauksen ohjaus dfn: ssä helpottaa hännän rekursion havaitsemista ja toteuttamista kuin tradfn: ssä.
Dfn voi kutsua tradfn: n ja päinvastoin ; dfn voidaan määrittää tradfn: ssä ja päinvastoin .

Historia

Kenneth E. Iverson , APL: n keksijä, oli tyytymätön tapaan, jolla käyttäjäfunktiot (tradfns) määriteltiin. Vuonna 1974 hän kehitti "muodollisen funktion määritelmän" tai "suoran määritelmän" käytettäväksi näyttelyssä. Suorassa määritelmässä on kaksi tai neljä osaa, jotka on erotettu kaksoispisteillä:

name : expression
name : expression0 : proposition : expression1

Suorassa määritelmässä ⍺tarkoittaa vasenta argumenttia ja ⍵oikeaa argumenttia. Ensinnäkin tulos expressionon funktion tulos; toisessa tapauksessa funktion tulos on, expression0jos se propositionarvioi arvoksi 0 tai expression1jos se arvioi arvoksi 1. Suoran määritelmän sisältämät tehtävät ovat dynaamisesti paikallisia . Esimerkkejä suoran määrittelyn käytöstä löytyy vuoden 1979 Turing Award -luennosta sekä kirjoista ja hakemusasiakirjoista.

Suora määrittely oli liian rajoitettua käytettäväksi suuremmissa järjestelmissä. Useat tekijät kehittelivät ideoita edelleen useissa teoksissa, mutta tulokset olivat hankalia. Näistä Bundan "vaihtoehtoinen APL -funktion määritelmä" vuonna 1987 oli lähimpänä nykyisiä tiloja, mutta siinä on puutteita ristiriidoissa olemassa olevien symbolien kanssa ja virheiden käsittelyssä, mikä olisi aiheuttanut käytännön vaikeuksia, eikä sitä koskaan toteutettu. Eri ehdotusten tärkeimmät tisleet olivat, että (a) määritettävä toiminto on anonyymi, ja myöhemmin nimetyt (tarvittaessa) suoritetaan toimeksiannolla; b) toiminto on merkitty symbolilla ja mahdollistaa siten anonyymin rekursion .

Vuonna 1996 John Scholes Dyalog Limitedistä keksi suoria toimintoja (dfns). Ideat syntyivät vuonna 1989, kun hän luki The Computer Journalin erikoisnumeron toiminnallisesta ohjelmoinnista. Sitten hän opiskeli toiminnallista ohjelmointia ja tuli voimakkaasti motivoituneeksi ("sairas halusta", kuten Yeats ) tuomaan nämä ideat APL: ään. Hän toimi aluksi salaa, koska hän oli huolissaan siitä, että muutokset saatettiin pitää liian radikaaleina ja tarpeettomina kielen monimutkaisina. muut tarkkailijat sanovat, että hän toimi salaa, koska Dyalogin kollegat eivät olleet niin ihastuneita ja luulivat hänen tuhlaavan aikansa ja aiheuttavan ongelmia ihmisille. Dfns esiteltiin ensimmäisen kerran Dyalog Vendor Forumissa APL '96 -konferenssissa ja julkaistiin Dyalog APL: ssä vuoden 1997 alussa. Hyväksyminen ja tunnustaminen tulivat hitaasti. Vielä vuonna 2008 Dyalogissa 25 , julkaisussa, joka juhlii Dyalog Limitedin 25 -vuotisjuhlaa, dfns: t mainittiin tuskin (mainittiin kahdesti "dynaamisina toimintoina" ja ilman tarkennuksia). Vuodesta 2019 lähtien dfns on otettu käyttöön Dyalog APL-, NARS2000- ja ngn/apl -sovelluksissa. Niillä on myös keskeinen rooli pyrkimyksissä hyödyntää grafiikkaprosessorin (GPU) laskentataitoja .

Viitteet

Ulkoiset linkit

Virallinen sivusto , Dyalog

Languages

In other projects