Haskell: Օր առաջին. Ֆակտորիալ

Այս կիրակի ես վերջապես որոշեցի սկսել ծանոթությունը Haskell լեզվի հետ։ Haskel-ը ֆունկցիանալ լեզու է. երբեմն ասում են, որ այն ֆունկցիոնալների մեջ ամենաֆունկցիոնալն է։ Ես, ինչ-որ տարրական պատկերացում ունենալով ֆունկցիոնալ ծրագրավորման մասին, ինձ համար սահմանեցի հետևյալ առաջին խնդիրը.

Ֆակտորիալ։ Գրել ծրագիր, որ հրամանային տողից ստանում է որևէ դրական ամբողջ թիվ, ապա հաշվարկում և արտածում է այդ թվի ֆակտորիալը։

Բայց, մինչև խնդրի լուծմանն անցնելը, ես պիտի պատրաստեմ Haskell լեզվի միջավայրը, որում աշխատեցնելու եմ իմ գրած ծրագրերը։ Կարելի է, իհարկե, օգտագործել որևէ առցանց ծառայություն, ինչպիսիք են, օրինակ, www.tutorialspoint.com-ը կամ https://repl.it-ը, բայց ես նախընտրում եմ ամեն ինչ ունենալ ձեռքի տակ՝ իմ մեքենայի վրա։

Իսկ իմ մեքենան Raspberry Pi է` Debian-ի հիման վրա կառուցված օպերացիոն համակարգով։ Haskell Platform-ի էջից գտա, թե ինչպես է պետք տեղադրել Haskell-ի կոմպիլյատորն ու ինտերպրետատորը.

$ sudo apt-get install haskell-platform

Haskel Platform-ի կոմպիլյատորի և ինտերպրետատորի հաջող տեղադրված լինելը ստուգելու համար նախ հրամանային տողից աշխատեցեմ ghci ինտերպրետատորը.

$ ghci
GHCi, version 8.4.4: http://www.haskell.org/ghc/  :? for help
Prelude>

Հրավերքի տողում Prelude ցույց է տալիս, որ ինտերպրետատորը գործարկվել է և ակտիվ է Prelude փաթեթը։ Խնդրեմ Հասկելին ցույց տալ π թվի արժեքը.

Prelude> pi
3.141592653589793

Կարծես թե աշխատում է։ Փորձեմ հենց այստեղ սահմանել ֆակտորիալը հաշվող ֆունկցիան՝ ամենապարզ մոտեցմամբ.

Prelude> factorial n = if n == 1 then 1 else n * factorial (n - 1)

Մի քանի օրինակներով համոզվեմ, որ սահմանած ֆունկցիան աշխատում է.

Prelude> factorial 1
1
Prelude> factorial 5
120
Prelude> factorial 10
3628800
Prelude> factorial 100
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Հիմա այս ֆունկցիան գրեմ մի ֆայլի մեջ, օրինակ, ex0.hs անունով, ու փորձեմ այդ ֆայլը թարգմանել Հասկելի կոմպիլյատորով։

-- Իմ առաջին ծրագիրը

factorial :: Integer -> Integer
factorial n = if n == 1 then 1 else n * factorial (n - 1)

Այստեղ ֆունկցիայի սահմանումից առաջ ավելացրել եմ նաև դրա վերնագիրը (կամ նկարագրությունը)։ Այդ նկարագրությամբ տրվում է ֆունկցիայի տիպը. :: սիմվոլից ձախ գրված է ֆունկցիայի անունը՝ factorial, իսկ աջ կողմում՝ արգումենտի ու վերադարձվող արժեքի տիպերը։ Այսինքն՝ ֆունկցիան ստանում է Integer տիպի արգումենտ և վերադարձնում է Integer տիպի արժեք։ Երկրորդ տողում հենց ֆունկցիայի սահմանումն է. = սիմվոլից ձախ ֆունկցիայի անունն ու արգումենտն է, իսկ աջ կողմում՝ մարմինը, որը տվյալ դեպքում պարզ ճյուղավորման արտահայտություն է։

Haskell Platform-ում կոմպիլյատորը ghc—ն է։ Աշխատեցնում եմ՝ մուտքին տալով ex0.hs ֆայլը.

$ ghc ex0.hs
[1 of 1] Compiling Main             ( ex0.hs, ex0.o )

ex0.hs:1:1: error:
    The IO action ‘main’ is not defined in module ‘Main’
  |
1 |
  | ^

Սխալի հաղորդագրությունն ասում է, որ Main մոդուլում սահմանված չէ main գործողությունը։ Բանից պարզվում է, որ Հասկելի կոմպիլյատորը նույնպես (ինչպես, օրինակ, Սի լեզվի կոմպիլյատորը) որպես մուտքի կետ է համարում main գործողությունը։ Հիմա ex0.hs ֆայլում ավելացնում եմ main գործողությունն այնպես, որ այն արտածի 12-ի ֆակտորիալը.

-- Իմ առաջին ծրագիրը
factorial n = if n == 1 then 1 else n * factorial (n - 1)

-- Մուտքի կետը
main =
    print (factorial 12)

Նորից փորձեմ թարգմանել։ Ի դեպ, Հասկել լզվում -- սիմվոլով սկսվում են մեկնաբանությունները։

$ ghc ex0.hs
[1 of 1] Compiling Main             ( ex0.hs, ex0.o )
Linking ex0 ...

Արդեն ամեն ինչ լավ է։ Իմ գրած ծրագիրը թարգմանվեց (compile), կապակցվեց (link), և հիմա կարող եմ աշխատեցնել ու տեսնել արդյունքը.

$ ./ex0
479001600

Բայց այս ծրագիրը կարողանում է հաշվել ու տպել միայն 12-ի ֆակտորիալը։ Իսկ ես ուզում եմ, որ այն կարողանա հաշվել հրամանային տողում տրված թվի ֆակտորիալը։ ՄԻ քիչ քչփորելուց հետո պարզեցի, որ Հասկել ծրագրում գրամանային տողի պարամետրերը կարելի է վերցնել System.Environment մոդուլի getArgs գործողությամբ։ Օրինակ, հետևյալ ծրագիրը (գրառված ex1.hs ֆայլում) արտածում է հրամանային տողում տրված պարամետրերի ցուցակը.

-- Հրամանային տողի պարամետրերի ցուցադրություն

import System.Environment

main = do
    args <- getArgs
    print args

Ահա թարգմանության ու կատարման մի քանի օրինակ.

$ ./ex1
[]
$ ./ex1 a
["a"]
$ ./ex1 a bb
["a","bb"]
$ ./ex1 a bb ccc
["a","bb","ccc"]
$ ./ex1 1 22 333
["1","22","333"]

Այստեղից երևում է, որ հրամանային տողի պարամետրերը ծրագրում երևում են տեքստային արժեքների ցուցակի տեսքով։ Ես պետք է թվի տեքստային ներկայացումից ստանամ դրա թվային արժեքը, ապա այդ արժեքի նկատմամբ կիրառեմ factorial ֆունկցիան:

Հասկելի read ֆուկցիան տեքսից «կարդում» է որևէ տիպի արժեք։ Այդ տիպը տրվում է ֆունկցիայի կանչի հետ՝ :: սիմվոլոլից հետո։ Օրինակ, «read "12" :: Int» արտահայտությունը "12" տողից կարդում է Int տիպի 12 արժեքը։ «read "12" :: Float» արտահայտությունը նույն տողից կարդում է 12.0 արժեքը՝ Float տիպի։

Այսպիսով, ես պետք է վերցնեմ հրամանային տողի պարամետրերի ցուցակի առաջին տարրը (head ֆունկցիայիով), դրա նկատմամբ կիրառեմ read ֆունկցիան՝ Integer տիպի համար, ստացված արժեքի նկատմամբ կիրառեմ factorial-ը ու տպեմ ստացված արժեքը։ Ահա այսպիսի մի արտահայտություն main ֆունկցիայում.

print (factorial (read (head args) :: Integer))

Ձևափոխված ex0.hs ծրագիրը կունենա հետևյալ վերջնական տեսքը.

import System.Environment

-- Ֆակտորիալի հաշվարկը
factorial :: Integer -> Integer
factorial n = 
    if n == 1 
    then 1
    else n * factorial (n - 1)

-- Մուտքի կետ
main :: IO ()
main = do
    args <- getArgs
    print (factorial (read (head args) :: Integer))

Լավ. տեսնենք, թե սա ինչպես է աշխատում։

$ ghc ex0.hs
[1 of 1] Compiling Main             ( ex0.hs, ex0.o )
Linking ex0 ...
$ ./ex0 2
2
$ ./ex0 12
479001600
$ ./ex0 20
2432902008176640000
$ ./ex0 40
815915283247897734345611269596115894272000000000

Լավ էլ աշխատում է։ Բայց, իհարկե, թերություններ կան։ Առաջին թերությունը տեխնիկական է. դիտարկված չէ այն դեպքը, երբ հրամանային տողում ոչինչ տրված չէ։ Օրինակ, եթե աշխատեցնեմ ծրագիրը՝ հրամանային տողում ոչինչ չտալով, ապա կստանամ հաղորդագրություն այն մասին, որ head ֆունկցիային տրված է դատարկ ցուցակ.

$ ./ex0
ex0: Prelude.head: empty list

Սա պետք է ուղղել՝ main գործողության մեջ պայման գրելով։ Այսպես.

main = do
    args <- getArgs
    if not (null args)
    then print (factorial (read (head args) :: Integer))
    else putStrLn "Ոչինչ տրված չէ։"

Հիմա եթե ծրագիրն աշխատեցնեմ դատարկ հրամանային տողով, ապա որպես պատասխան կստանամ «Ոչինչ տրված չէ։»։

Հաջորդիվ. թերևս Հասկել լեզվով գրող ոչ մի ծրագրավորող թվի ֆակտորիալը հաշվող ֆունկցիան չի գրի այնպես, ինչպես ես գրել եմ։ Վարպետ Հասկել-ծրագրավորողը պարզապես կգրի.

factorial :: Integer -> Integer
factorial n = product [1 .. n]

Եվ վերջ։ Այստեղ գրված է ֆակտորիալի բառացի սահմանումը՝ այն 1-ից n թվերի ([1 .. n]) արտադրյալն է (product):

Java: Առաջին ծրագիրը

Արդեն դարերի ավանդույթ է դարձել որևէ ծրագրավորման լեզվի հնարավորությունները ցուցադրելիս որպես առաջին ծրագրի օրինակ մատուցել ստանդարտ արտածման հոսքի վրա "Hello, World!" տեքստն արտծող ծրագիրը։ Մի կողմ թողնենք այն և որպես առաջին ծրագիր դիտարկենք տրված դրական ամբողջ թվի ֆակտորիալը հաշվող և արտածող ծրագիրը։ Այն, կարծում եմ, և՛ ավելի հետաքրքիր է, և՛ ավելի խոսուն։

Եվ այսպես. տրված n դրական ամբողջ թվի ֆակտորիալը դա 1-ից n ամբողջ թվերի արտադրյալն է։ Այն հաշվելու համար պարզապես պետք է կազմակերպել մի ցիկլ՝ կրկնություն, որն անցնում է 1..n թվերով և կուտակում է դրանց արտադրյալը։ Փսևդոկոդով գրելու դեպքում, օրինակ 12 թվի ֆակտորիալը հաշվելու համար, կունենանք ահա այսպիսի ծրագիր.

n = 12
prod = 1
WHILE n > 0 DO
  prod = prod * n
  n = n - 1
END
PRINT prod

Java ծրագրի կատարումը սկսվում է գլխավոր դասի main անունով ստատիկ մեթոդից։ Դասը սահմանվում է class ծառայողական բառով, որին հետևում է դասի անունը, ապա մեթոդների ու դաշտերի սահմանումները։ Օրինակ, Factorial անունով դասը կարող ենք սահմանել հետևյալ կերպ.

public class Factorial {
...
}

Որտեղ public բառն ասում է, որ տվյալ դասը կարող են օգտագորվծել այլ փաթեթներում (փաթեթների մասին քիչ ավելի ուշ)։
Factorial դասի համար սահմանենք main ստատիկ մեթոդը.

public class Factorial {
  public static void main(String[] args)
  {
    ...
  }
}

Նորից public ծառայողական բառն ասում է, որ main մեթոդը տեսանելի է Factorial դասից դուրս։ static բառն ասում է, որ այս մեթոդն ընդհանուր է Factorial դասի մոլոր նմուշների համար (սրանք էլ մանրամասնորեն կքննարկենք ավելոի ուշ)։ void բառն ասում է, որ main մեթոդը որևէ արժեք չի վերադարձում։ main մեթոդի արգումենտների ցուցակում գրված "String[] args" արտահայտությունը նշում է, որ այս մեթոդը սպասում է (ընդունում է, ակնկալում է) մեկ արգումենտ՝ տողերի միաչափ զանգված (վեկտոր)։ main մեթոդի կատարման ժամանակ նրա արգումենտն արժեքավորվում է հրամանային տողի պարունակությամբ (այս մասին էլ ավելի ուշ)։
Հիմա սկսենք ֆակտորիալի հաշվարկը։ Ասացինք, որ աշխատելու ենք ամբողջ թվերի հետ։ Հայտարարենք n և prod ամբողջ թվերը՝ առաջինն արժեքավորելով 12 արժեքով, իսկ երկրորդը՝ 1 արժեքով։

int n = 12, prod = 1;

Կազմակերպենք ցիկլ, որը կատարվում է քանի դեռ ճշմարիտ է n > 0 պայմանը։ Իսկ ցիկլի մարմնում հաշվարկվում է prod = prod * n արտադրյալը, և մեկով նվազեցվում է n փոփոխականի արձեքը։
Պայմանով ցիկլերը կազմակերպվում են while կառուցվածքով։ Այն կատարում է իր մարմնում գրված հրամաններն այնքան ժամանակ, քանի դեռ ճշմարիտ է կրկնման պայմանը։

while( n > 0 ) {
  prod = prod * n;
  n = n - 1;
}

Տվյալ դեպքում ցիկլն անպայման կավարտվի, քանի որ կրկնությունների ընթացքում n դրական թվի արժեքը շարունակ նվազում է։ Եվ երբ ավարտվի ցիկլը, prod փոփոխականում կուտակված կլինի 1..n թվերի արտադրյալը։
Եվ վերջապես, ինչպե՞ս արտածել հաշվարկման արդյուքները։ Java լեզվի ստանդարտ գրադարանի System դասի out դաշտի println մեթոդը ստանդարտ արտածման հոսքի վրա դուրս է բերում իր արգումենտում տրված արժեքը։ prod փոփոխականի արժեքը արտածելու համար պետք է գրել.

System.out.println(prod);

* * * Ի մի բերելով շարադրվածը կազմենք ամբողջական ծրագիրը և կատարենք այն։ Նախ՝ որևէ տեքտային խմբագրիչոով ստեղծենք Factorial.java անունով ֆայլ և նրա մեջ գրենք հետևյալը.

/*
  First program in java
*/
public class Factorial {
  public static void main(String[] args)
  {
    int n = 12, prod = 1;
    while( n > 0 ) {
      prod = prod * n;
      n = n - 1;
    }
    System.out.println(prod);
  }
}

Պահպանենք ֆայլը պրոյեկտների համար նախատեսված մի պանակում՝ նախապես այս օրինակի ֆայլերի համար ստեղծելով factorial ենթապանակը (այն ինձ մոտ home-ում ստեղծված Project/java-examples պանակում է)։ cd հրամանով փոխենք աշխատանքային պանակն այնտեղ, որտեղ պահպանված է Factorial.java ֆայլը, և, ենթադրելով, որ համակարգում արդեն տեղադրված է Java լեզվի կոմպիլյատորն (javac) ու վիրտուալ մեքենան (java), թարգմանենք մեր գրած ծրագիրը բայթ-կոդի։

$ javac Factorial.java

Եթե թարգմանության՝ կոմպիլյացիայի պրոցեսում սխալներ չեն հայտնաբերվել, ապա հենց նույն պանակում ստեղծվում է Factorial.class անունով ֆայլ։ Սա մեր ծրագիրն է՝ Java ծրագրավորման լեզվից թարգմանած Java վիրտուալ մեքենայի բայթ-կոդերի։ Այն կատարելու համար պետք է կանչել Java վիրտուալ մեքենան՝ նրա արգումենտում տալով այն դասի անունը, որում սահմանված է main մեթոդը։ Մեր դեպքում դա միակ Factorial դասն է։

$ java Factorial

Տերմինալին արտածվում է 479001600, որը, կարող ենք ստուգել և համոզվել, հենց 12 թվի ֆակտորիալն է։ * * * Սա առաջին ծրագիրն էր՝ գրված Java ծրագրավորման լեզվով։ Այս պահին դեռ ամեն ինչ չէ, որ պարզ ու հասկանալի է։ Մենք կարողացանք ծանոթանալ պարզագույն Java ծրագրի կառուցվածքին։ Տեսանք, թե ինչպես պետք է թարգմանել ու կատարել ծրագիրը հրամանային տողից։ Չնայած, որ ստացանք աշխատող ծրագիր, բայց բազմաթիվ հարցեր, թե՛ աշխատանքի տեխնիկայի, թե՛ խնդրի լուծման հետ կապված, դեռ մնում են չպարզաբանված։ Այս բլոգի հաջորդ գրառման մեջ ես կփորձեմ ընդգծել այս առաջին օրինակի թերություններն ու բացթողումները և առաջարկել դրանց լուծումները։