If you're seeing this message, it means we're having trouble loading external resources on our website.

თუ ვებფილტრს იყენებთ, დარწმუნდით, რომ *.kastatic.org და *.kasandbox.org დომენები არ არის დაბლოკილი.

ძირითადი მასალა

შემთხვევითი სიარული

სანამ ვექტორის სირთულეებსა და ფიზიკაზე დაფუძნებულ მოძრაობას ჩავუღრმავდებით, მოდით, ვიფიქროთ, რას ნიშნავს რაღაცის გადაადგილება ეკრანზე. დავიწყოთ მოძრაობის ერთ-ერთი ყველაზე ცნობილი და უმარტივესი სიმულაციით - შემთხვევითი ხეტიალით.
წარმოიდგინეთ, რომ ჰორიზონტალურად დაჭიმულ ბაგირზე დგახართ. ყოველ ათ წამში აგდებთ მონეტას. თუ საფასური დაჯდება, ნაბიჯს დგამთ წინ. ბორჯღალის მოსვლის შემთხვევაში, ნაბიჯს დგამთ უკან. ეს არის შემთხვევითი ხეტიალის მაგალითი — მარშრუტი, რომელიც განსაზღვრულია შემთხვევითად მიღებული ნაბიჯების მიმდევრობით. თუ ამ ბაგირიდან გადმოხვალთ იატაკზე, შემთხვევით ხეტიალს შეძლებთ ორ განზომილებაში იმავე მონეტის ორჯერ აგდებით შემდეგნაირად:
აგდება 1აგდება 2შედეგი
საფასურისაფასურინაბიჯი წინ.
საფასურიბორჯღალინაბიჯი მარჯვნივ.
ბორჯღალისაფასურინაბიჯი მარცხნივ.
ბორჯღალიბორჯღალინაბიჯი უკან.
დიახ, ეს შეიძლება, მარტივ ალგორითმს ჰგავდეს. მიუხედავად ამისა, შემთხვევითი ხეტიალის გამოყენება შესაძლებელია რეალური სამყაროს მოვლენების მოდელირებისთვის, დაწყებული აირად სხეულში მოლეკულების გადაადგილებით, დამთავრებული აზარტული მოთამაშის მიერ სამორინეში გატარებული დღით. ჩვენ ვიწყებთ ამ თემას შემთხვევითი ხეტიალის შესწავლით სამი კონკრეტული მიზნისთვის.

შემთხვევითად მოხეტიალე ობიექტი

მოდით, ჯერ მოკლედ მიმოვიხილოთ ობიექტზე ორიენტირებული პროგრამირება (ოოპ) Walker (მოხეტიალე) ობიექტის შექმნით. ეს იქნება მხოლოდ სწრაფი მიმოხილვა. თუ ობიექტზე ორიენტირებული პროგრამირების გამოცდილება არ გაქვთ, უნდა გაიაროთ სექცია ობიექტზე ორიენტირებული JavaScript-ის შესახებ.
JavaScript-ში ობიექტი არის მონაცემთა ტიპი, რომელსაც მიმაგრებული აქვს თვისებებიც და ფუნქციონალობაც მისი პროტოტიპის საშუალებით. ჩვენ გვინდა ისეთი Walker ობიექტის შექმნა, რომელიც თვალყურს ადევნებს თავის მონაცემებს (სად არსებობს ის ეკრანზე) და აქვს უნარი, შეასრულოს კონკრეტული ქმედებები (როგორიცაა თავისი თავის დახატვა ან ნაბიჯის გადადგმა).
Walker-ების ნიმუშების შესაქმელად უნდა განვსაზღვროთ Walker ობიექტი. ამ ობიექტს გამოვიყენებთ ზოგადი თვისებებისა და ფუნქციონალობის შესაქმნელად, ხოლო თითოეული Walker ნიმუში ამის კონკრეტული მაგალითი იქნება.
დავიწყოთ Walker ობიექტის ტიპის განსაზღვრით. Walker-ს მხოლოდ 2 მონაცემი სჭირდება — რიცხვი, რომელიც აღწერს მის x-მდებარეობას, და მეორე რიცხვი, რომელიც აღწერს მის y-მდებარეობას. ამ რიცხვებს მნიშვნელობებს მივანიჭებთ მის კონსტრუქტორ ფუნქციაში. მათ დავაყენებთ სამუშაო სივრცის შუა წერტილში.
var Walker = function() {
    this.x = width/2;
    this.y = height/2;
};
მისი x-ისა და y-ისათვის თვალყურის დევნების გარდა, ჩვენს Walker ობიექტს აგრეთვე ექნება მეთოდები, რომელთა გამოძახებაც შეგვიძლია მასზე. პირველი იქნება მეთოდი, რომელიც ობიექტს საშუალებას აძლევს, გამოაჩინოს საკუთარი თავი ეკრანზე შავ წერტილად. გავიხსენოთ, რომ JavaScript-ში ობიექტებს მეთოდებს ვამატებთ ობიექტის პროტოტიპზე მათი მიმაგრებით.
Walker.prototype.display = function() {
    stroke(0, 0, 0);
    point(this.x, this.y);
};
მეორე მეთოდი ეუბნება Walker ობიექტს, რომ ნაბიჯი გადადგას. აი, აქ იწყება საინტერესო ნაწილი. გახსოვთ, იატაკი, რომელზეც შემთხვევით ნაბიჯებს ვდგამდით? ახლა შეგვიძლია ჩვენი სამუშაო სივრცის გამოყენება იმავე დატვირთვით. არის ოთხი შესაძლო ნაბიჯი. მარჯვნივ გადადგმული ნაბიჯის სიმულაცია შეიძლება x-ის გაზრდით ( x++); მარცხნივ გადადგმული ნაბიჯის — x-ის შემცირებით (x--); წინ გადადგმული ნაბიჯის — ერთი პიქსელით დაბლა ჩასვლა (y++); და უკან გადადგმული ნაბიჯი არის პიქსელით მაღლა ასვლა (y--). როგორ ავირჩიოთ ამ ოთხი ვარიანტიდან რომელიმე? ცოტა ხნის წინ ვთქვით, რომ შეგვიძლია 2 მონეტის აგდება. მიუხედავად ამისა, როდესაც ProcessingJS-ში გვინდა, ვარიანტების სიიდან შემთხვევითად ავირჩიოთ რომელიმე, შეგვიძლია, ავირჩიოთ შემთხვევითი რიცხვი random()-ის გამოყენებით.
Walker.prototype.walk = function() {
    var choice = floor(random(4));
};
ზემოთ მოცემული კოდი ირჩევს შემთხვევით მცურავმძიმიან რიცხვს 0-იდან 4-მდე და გადაჰყავს ის მთელ რიცხვში floor()-ის გამოყენებით, შესაბამისად, შედეგად ვიღებთ 0-ს, 1-ს, 2-ს ან 3-ს.. ფორმალურად რომ ვთქვათ, უდიდესი რიცხვი არასოდეს იქნება 4,0, ის იქნება 3,999999999 (იმდენი ცხრიანით, რამდენი ადგილიც გვაქვს მძიმის შემდეგ); ვინაიდან floor() აბრუნებს უახლოეს მთელ რიცხვს, რომელიც ნაკლებია ან ტოლია მოცემულ რიცხვზე. უდიდესი შედეგი, რომლის მიღებაც შეგვიძლია, არის 3. ამის შემდეგ ვდგამთ შესაბამის ნაბიჯს (მარცხნივ, მარჯვნივ, ზემოთ ან ქვემოთ), გააჩნია, რომელი შემთხვევითი რიცხვი მივიღეთ.
Walker.prototype.walk = function() {
    var choice = floor(random(4));
    if (choice === 0) {
        this.x++;
    } else if (choice === 1) {
        this.x--;
    } else if (choice === 2) {
        this.y++;
    } else {
        this.y--;
    } 
};
ახლა, როცა კლასი დაწერილი გვაქვს, დროა, კონკრეტული Walker ობიექტი შევქმნათ ჩვენს პროგრამაში. დავუშვათ, რომ გვინდა ერთი შემთხვევითი ხეტიალის მოდელირება. ვაცხადებთ და ინიციალიზაციას ვუკეთებთ Walker ტიპის ერთ გლობალურ ცვლადს კონსტრუქტორი ფუნქციის გამოძახებით new ოპერატორით.
var w = new Walker();
ახლა, იმისთვის, რომ მოხეტიალეს რაიმე გავაკეთებინოთ, განვსაზღვრავთ draw() ფუნქციას და ვეუბნებით მოხეტიალეს, გადადგას ნაბიჯი და დახატოს საკუთარი თავი მის ყოველ გამოძახებაზე:
draw = function() {
    w.walk();
    w.display();
};
ვინაიდან დახატვის ფუნქციაში background()-ს არ ვიძახებთ, ჩვენი შემთხვევითი ხეტიალის ნაკვალევის ნახვა შეგვიძლია ჩვენს სამუშაო სივრცეზე:

„შემთხვევითი მოხეტიალის“ გაუმჯობესება

შემთხვევითი მოხეტიალე შეგვიძლია, რამდენიმენაირად გავაუმჯობესოთ. ჩვენს შემთხვევაში, ამ მოხეტიალეს აქვს ნაბიჯის გადადგმის მხოლოდ 4 ვარიანტი - ზემოთ, ქვემოთ, მარცხნივ და მარჯვნივ. მაგრამ ფანჯარაში ყოველ პიქსელს ჰყავს 8 მეზობელი, ხოლო მე-9 ვარიანტი არის იგივე პიქსელზე დარჩენა.
„კოდის ბუნების“ სურათი
ფიგურა I.1
იმ Walker ობიექტის იმპლემენტაციისათვის, რომელსაც შეუძლია ნებისმიერ მეზობელ პიქსელზე გადასვლა (ან იმავეზე დარჩენა), შეგვიძლია, ავირჩიოთ რიცხვი 0-სა 8-ს შორის (9 შესაძლო ვარიანტი). მიუხედავად ამისა, კოდის დაწერის უფრო ეფექტური გზა უფრო მარტივია: ავირჩიოთ 3 შესაძლო ნაბიჯი x ღერძზე (-1, 0, an 1) და 3 შესაძლო ნაბიჯი y ღერძზე.
Walker.prototype.walk = function() {
  var stepx = floor(random(3))-1;
  var stepy = floor(random(3))-1;
  this.x += stepx;
  this.y += stepy;
};
კიდევ უფრო შორს რომ წავიდეთ, შეგვიძლია, ათწილადები გამოვიყენოთ x-ისა და y-ისათვის და გადავადგილდეთ ნებისმიერი შემთხვევითი მნიშვნელობით -1-სა და 1-ს შორის, თუ ჩვენს გარემოს ნამდვილად შეუძლია „2,2-სა“ და „2,4-ს“ შორის სხვაობის გამოჩენა:
Walker.prototype.walk = function() {
  var stepx = random(-1, 1);
  var stepy = random(-1, 1);
  this.x += stepx;
  this.y += stepy;
};
ყველა ამ ვარიანტს „ტრადიციულ“ შემთხვევით ხეტიალზე აქვს ერთი საერთო რამ: დროის ყოველ მომენტში იმის ალბათობა, რომ Walker ობიექტი აირჩევს რომელიმე კონკრეტულ ნაბიჯს, ტოლია იმის ალბათობისა, რომ Walker აირჩევს ნებისმიერ სხვა კონკრეტულ ნაბიჯს. სხვა სიტყვებით რომ ვთქვათ, თუ გვაქვს ოთხი შესაძლო ნაბიჯი, Walker-ის მიერ თითოეული ნაბიჯის არჩევას გააჩნია 4-იდან 1 (იგივე 25%) შანსი. 9 შესაძლო ნაბიჯის შემთხვევაში გვექნება 9-იდან 1 (იგივე 11,1%) შანსი.
აი, ასე მუშაობს random() ფუნქცია. მისი შემთხვევითი რიცხვების გენერატორი აწარმოებს რიცხვების „თანაბარ" განაწილებას. ამ განაწილების დატესტვა შეგვიძლია პროგრამით, რომელიც ითვლის შემთხვევითი რიცხვის ყოველ არჩევას და მას მართკუთხედის სიმაღლედ გამოსახავს გრაფიკზე.
არის თუ არა ყველა მართკუთხედი ტოლი სიმაღლის რამდენიმეწუთიანი გაშვების შემდეგ? სავარაუდოდ, არა. ჩვენი შერჩევის ზომა (ჩვენ მიერ არჩეული შემთხვევითი რიცხვების რაოდენობა) საკმაოდ მცირეა და ზოგჯერ გვხვდება შეუსაბამობები, რომლებშიც ზოგიერთი რიცხვები უფრო ხშირადაა ამორჩეული. შემთხვევითი რიცხვების კარგი გენერატორით ეს შემთხვევები დროთა განმავლობაში აღმოიფხვრება.
შემთხვევითი რიცხვები, რომელთაც ვიღებთ random() ფუნქციიდან, ნამდვილად შემთხვევითი არ არის; ამიტომ მათ ვიცნობთ „ფსევდოშემთხვევითი“ რიცხვების სახელით. ეს რიცხვები არის შედეგი მათემატიკური ფუნქციისა, რომელიც შემთხვევითობის სიმულაციას აკეთებს. ეს ფუნქცია დროთა განმავლობაში კანონზომიერებას გამოიჩენს, მაგრამ დროის ეს პერიოდი ჩვენთვის იმდენად დიდია, რომ ეს ისეთივე კარგია, როგორიც ნამდვილი შემთხვევითობა!
შემდეგ სექციაში ვილაპარაკებთ სხვადასხვა გზაზე, რომელთა საშუალებითაც შეგვიძლია, შევქმნათ მოხეტიალეები, რომელთაც გააჩნიათ კონკრეტული მიმართულებით ხეტიალის „მიდრეკილება". სანამ ამაზე გადახვიდოდეთ, გამოწვევა გელით!

ეს „ბუნებრივი სიმულაციების" კურსი ეფუძნება დანიელ შიფმენის წიგნს "კოდის ბუნებას", ის გამოყენებულია ლიცენზიით Creative Commons Attribution-NonCommercial 3,0 Unported License.

გსურთ, შეუერთდეთ დისკუსიას?

პოსტები ჯერ არ არის.
გესმით ინგლისური? დააწკაპუნეთ აქ და გაეცანით განხილვას ხანის აკადემიის ინგლისურენოვან გვერდზე.