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

კომპიუტერული პროგრამირება

კურსი: კომპიუტერული პროგრამირება > თემა 5

გაკვეთილი 4: ვექტორები

რა არის ვექტორი

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

სიტყვა „ვექტორი“ შეიძლება, ბევრ რამეს ნიშნავდეს. „ვექტორი“ არის 1980-იან წლებში კალიფორნიაში შექმნილი როკ-ჯგუფის სახელი. ის არის Kellogg’s Canada-ს მიერ წარმოებული საკვები პროდუქტის სახელი. ეპიდემიოლოგიაში ვექტორი გამოიყენება იმ ორგანიზმის აღსაწერად, რომელსაც პარაზიტის მატარებელი ერთი მასპინძლიდან მეორეში გადააქვს ინფექცია. პროგრამირების ენაში „C++“ ვექტორი (std::vector) არის ფორმის დინამიურად შეცვლადი მასივის მონაცემთა სტრუქტურის იმპლემენტაცია. ეს ყველა განსაზღვრება საინტერესოა, მაგრამ ჩვენ ეს არ გვაინტერესებს. ჩვენთვის საინტერესოა ევკლიდური ვექტორი (მას ეს სახელი ბერძენი მათემატიკოსის, ევკლიდეს, პატივსაცემად ჰქვია; აგრეთვე უწოდებენ „გეომეტრიული ვექტორს“). როდესაც ამ კურსის ფარგლებში დაინახავთ სიტყვა „ვექტორს“, შეგიძლიათ, ის ევკლიდურ ვექტორად მიიჩნიოთ, რომელიც განსაზღვრულია, როგორც ობიექტი, რომელსაც აქვს სიგრძე და მიმართულება.

ვექტორს, ძირითადად, ხატავენ ისრის სახით; მიმართულება არის იგივე, საითაც ისარია მიმართული, სიგრძე კი თვითონ ამ ისრის სიგრძეა.

ზემოთ მოცემულ ილუსტრაციაში ვექტორი დახატულია, როგორც ისარი A წერტილიდან B წერტილისკენ, და ასრულებს იმის ინსტრუქციის მოვალეობას, თუ როგორ უნდა მივიდეთ A-დან B-მდე.

რატომ ვიყენებთ ვექტორებს?

სანამ ვექტორების დეტალებში ჩავიდოდეთ, შევხედოთ მარტივ პროგრამას, რომელიც გვაჩვენებს, რატომ უნდა ვფიქრობდეთ ვექტორებზე პირველ ყოვლისა. თუ JS-ის შესავლის კურსი გაიარეთ აქ, ხანის აკადემიაზე, მაშინ, ალბათ, ისწავლიდით, როგორ უნდა დაწეროთ ბურთის ხტუნვის მარტივი პროგრამა.

ზემოთ მოცემულ მაგალითში გვაქვს ძალიან მარტივი სამყარო — ცარიელი სამუშაო სივრცე წრიული ფიგურით („ბურთით“), რომელიც მოძრაობს. ამ ბურთს გააჩნია თვისებები, რომლებიც ცვლადებად არის წარმოდგენილი კოდში.

ადგილმდებარეობა	სიჩქარე
x და y	xSpeed და ySpeed

უფრო რთულ პროგრამაში გაცილებით მეტი ცვლადის წარმოდგენა შეგვეძლებოდა:

აჩქარება	სამიზნე პოზიცია	ქარი	ხახუნი
xacceleration და yacceleration	xtarget და ytarget	xwind და ywind	xfriction და yfriction

უფრო და უფრო ცხადი ხდება, რომ ყოველ ცნებას ამ სამყაროში (ქარი, ადგილმდებარეობა, აჩქარება და ა.შ.) დასჭირდება 2 ცვლადი. და ეს არის მხოლოდ 2-განზომილებიანი სამყარო. 3-განზომილებიან სამყაროში დაგვჭირდება x, y, z, xSpeed, ySpeed, zSpeedდა ა.შ.

უკეთესი არ იქნებოდა, გაგვემარტივებინა ჩვენი კოდი და გამოგვეყენებინა ნაკლები ცვლადი?

ნაცვლად შემდეგისა:

var x = 5;
var y = 10;
var xSpeed;
var ySpeed;

შეგვეძლო, უბრალოდ, გვქონოდა 2 ცვლადი, სადაც თითოეული არის ვექტორის მსგავსი ობიექტი ინფორმაციის 2 განზომილებით:

var position;
var speed;

ვექტორების გამოყენების ამ პირველი ნაბიჯის გადადგმა ახალს ვერაფერს გაგვაკეთებინებს. მხოლოდ ვექტორის მსგავსი ობიექტების გამოყენება თქვენი ცვლადებისათვის ჯადოსნურად ვერ გააკეთებინებს თქვენს პროგრამას ფიზიკის სიმულაციას. თუმცა, ეს გაამარტივებს თქვენს კოდს და შემოგვთავაზებს ფუნქციების სიმრავლეს ხშირი მათემატიკური ოპერაციებისათვის, რომლებიც გამუდმებით გვხვდება მოძრაობის დაპროგრამებისას.

ვექტორების შესავალში ჩვენ 2 განზომილებაში ვიცხოვრებთ. ეს ყველა მაგალითი მარტივად განზოგადდება სამ განოზმილებაზე (და ობიექტი, რომელსაც გამოვიყენებთ — PVector — საშუალებას გვაძლევს, ვიმუშაოთ სამ განზომილებაში). მიუხედავად ამისა, უფრო ადვილია, დავიწყოთ ორი განზომილებით.

პროგრამირება `PVector`-ით

ვექტორების წარმოდგენის ერთ-ერთი გზაა სხვაობა ორ წერტილს შორის. წარმოიდგინეთ, როგორ ახსნიდით ერთი წერტილიდან მეორემდე მისვლას.

აი, რამდენიმე ვექტორი და შესაძლებელი გადატანები:

| (-15, 3) | გადადგით 15 ნაბიჯი დასავლეთის მიმართულებით; შებრუნდით და გადადგით სამი ნაბიჯი ჩრდილოეთით. | | (3, 4) | გადადგით სამი ნაბიჯი აღმოსავლეთით; შებრუნდით და გადადგით 4 ნაბიჯი ჩრდილოეთით. | | (2, -1) | გადადგით ორი ნაბიჯი აღმოსავლეთითt; შებრუნდით და გადადგით 1 ნაბიჯი სამხრეთით. |

ეს, ალბათ, ადრე უკვე გააკეთეთ, როცა მოძრაობას აპროგრამებდით. ანიმაციის თითოეული კადრისთვის (მაგალითად, ერთი გადაყოლა ProcessingJS-ის draw()-ს ციკლზე), თქვენ თითოეულ ობიექტს უხსნით, რომ გადაადგილდეს პიქსელების გარკვეული რაოდენობით ჰორიზონტალურად და პიქსელების გარკვეული რაოდენობით ვერტიკალურად.

თითოეული კადრისთვის:

ახალი ადგილმდებარეობა = მიმდინარე ადგილმდებარეობაზე გამოყენებული სიჩქარე

თუ სიჩქარე არის ვექტორი (სხვაობა 2 წერტილს შორის), რა არის ადგილმდებარეობა? ისიც ვექტორია? ტექნიკურად, შეგვიძლია, ვთქვათ, რომ ადგილმდებარეობა არ არის ვექტორი, რადგან ის არ აღწერს, როგორ გადავიდეთ ერთი წერტილიდან მეორეზე — ის, უბრალოდ, აღწერს ერთადერთ წერტილს სივრცეში.

ადგილმდებარეობის განსაზღვრის მეორე ვარიანტი არის იმ გზის აღება, რომელიც ათვლის სათავიდან უნდა გავიაროთ, რათა მივაღწიოთ მოცემულ ადგილმდებარეობას. ეს ნიშნავს, რომ შეიძლება, ადგილმდებარეობა იყოს ვექტორი, რომელიც წარმოადგენს სხვაობას ადგილმდებარეობასა და სათავეს შორის.

გავარკვიოთ, რა მონაცემები გვაქვს ადგილმდებარეობისა და სიჩქარის უკან. მხტუნავი ბურთის მაგალითში ჩვენ გვქონდა შემდეგი:

ადგილმდებარეობა	სიჩქარე
x და y	xSpeed და ySpeed

აღვნიშნოთ, რომ ორივესთვის ვინახავთ ერთნაირ მონაცემებს - ორი მცურავმძიმიანი რიცხვი, x და a y. თუ ჩვენით დავწერდით ვექტორის კლასს, დავიწყებდით ძალიან მარტივად:

var Vector = function(x, y) {
    this.x = x;
    this.y = y;
};

სინამდვილეში PVector, უბრალოდ, არის მოსახერხებელი გზა მხოლოდ 2 ცვლადის შესანახად (ან სამის, როგორც ამას ვნახავთ 3-განზომილებიან მაგალითებში).

ამიტომ ეს …

var x = 100;
var y = 100;
var xSpeed = 1;
var ySpeed = 3{,}3;

ხდება …

var position = new PVector(100,100);
var velocity = new PVector(1,3{,}3);

ახლა, როცა გვაქვს ორი ვექტორის ობიექტი (ადგილმდებარეობა და სიჩქარე), მზად ვართ, იმპლემენტაცია გავუკეთოთ მოძრაობის ალგორითმს — ადგილმდებარეობა = ადგილმდებარეობა + სიჩქარე:

x = x + xSpeed;
y = y + ySpeed;

იდეალურ სამყაროში ზემოთ მოცემულ კოდს შემდეგნაირად გადავწერდით:

position = position + velocity;

მიუხედავად ამისა, JavaScript-ში შეკრების ოპერატორი + გადადებულია მხოლოდ პრიმიტიული მნიშვნელობებისათვის (რიცხვები, სტრინგები). პროგრამირების ზოგიერთ ენაში ოპერატორები შეიძლება, „გადაიტვირთონ", მაგრამ არა JavaScript-ში. ჩვენდა სასიკეთოდ, PVector ობიექტი მოიცავს მეთოდებს ხშირად გამოყენებული მათემატიკური ოპერაციებისათვის, როგორიცაა add().

ვექტორების შეკრება

სანამ გავაგრძელებდეთ PVector ობიექტსა და მის add() მეთოდზე დაკვირვებას, მოდით, გამოვცადოთ ვექტორების შეკრება ნოტაციის გამოყენებით, რომელიც მათემატიკისა და ფიზიკის წიგნებში გვხვდება.

ვექტორები ძირითადად იწერება ან მუქად, ან თავზე ისრით. ამ გაკვეთილების მიზნებისთვის ვექტორის სკალარისგან განსასხვავებლად (სკალარი მიუთითებს ერთ მნიშვნელობას, როგორიცაა მთელი რიცხვი ან მცურავ მძიმიანი რიცხვი) გამოვიყენებთ ისრიან აღნიშვნას:

ვექტორი: u, with, vector, on top
სკალარი: x

ვთქვათ, მაქვს შემდეგი ვექტორები:

თითოეულ ვექტორს გააჩნია 2 კომპონენტი, x და y. 2 ვექტორის შესაკრებად, უბრალოდ, ვკრებთ x-ებს და y-ებს.

სხვა სიტყვებით:

w, with, vector, on top, equals, u, with, vector, on top, plus, v, with, vector, on top

შეიძლება, ჩაიწეროს, როგორც:

\text{w}_x = \text{u}_x + \text{v}_x\\ \text{w}_y = \text{u}_y + \text{v}_y

შემდეგ, როდესაც u-სა და v-ს ვანაცვლებთ ფიგურა 1,6-ში მოცემული მათი მნიშვნელობებით, ვიღებთ:

\text{w}_x = 5 + 3\\ \text{w}_y = 2 + 4

რაც ნიშნავს, რომ:

\text{w}_x = 8\\ \text{w}_y = 6

ბოლოს, ამას ვწერთ ვექტორის სახით:

w, with, vector, on top, equals, left parenthesis, 8, comma, 6, right parenthesis

ახლა, როცა გვესმის, როგორ შევკრიბოთ ორი ვექტორი, შეგვიძლია, დავაკვირდეთ, როგორ არის შეკრება იმპლემენტირებული თვითონ PVector ობიექტში. დავწეროთ მეთოდი სახელად add(), რომელიც იღებს სხვა PVector ობიექტს მის არგუმენტად და, უბრალოდ, კრებს შესაბამის x და y კომპონენტებს.

var Vector = function(x, y) {
    this.x = x;
    this.y = y;
};

Vector.prototype.add = function(v) {
  this.y = this.y + v.y;
  this.x = this.x + v.x;
};

ახლა, როცა ვხედავთ, როგორ იწერება PVector-ში add(), შეგვიძლია, დავუბრუნდეთ ჩვენი მხტუნავი ბურთის მაგალითს თავისი პოზიციას + სიჩქარის ალგორითმით და განვახორციელოთ ვექტორული შეკრების იმპლემენტაცია:

position.add(velocity);

ახლა მზად ვართ, გადავწეროთ მხტუნავი ბურთის მაგალითი PVector ობიექტის გამოყენებით! გადახედეთ კოდს, და ჩაინიშნეთ განსხვავებები წინა იმპლემენტაციისგან.

უნდა აღვნიშნოთ ვექტორებით პროგრამირების ზედა გადასვლის მნიშვნელოვანი ასპექტი. მიუხედავად იმისა, რომ ვიყენებთ PVector ობიექტებს ორი მნიშვნელობის აღსაწერად — მდებარეობის x-ისა და y-ის და სიჩქარის x-ისა და y-ის — მაინც ხშირად გვჭირდება, რომ მივმართოთ თითოეული PVector-ის x-სა და y კომპონენტებს ინდივიდუალურად. როდესაც ობიექტს ვხატავთ ProcessingJS-ში, მის კოდს ასე ვერ დავწერთ:

ellipse(position, 16, 16);

ellipse() ფუნქცია არ იღებს PVector-ს არგუმენტად. ელიფსის დახატვა შესაძლებელია მხოლოდ 2 სკალარული მნიშვნელობით, x კოორდინატითა და y კოორდინატით. ასე რომ, უნდა შევიდეთ PVector ობიექტში და მისგან მივიღოთ x და y კომპონენტები ობიექტზე ორიენტირებული წერტილის ნოტაციის გამოყენებით:

ellipse(position.x, position.y, 16, 16);

იმავე პრობლემას ვაწყდებით, როდესაც ვამოწმებთ, გავიდა თუ არა წრე ფანჯრის ბოლოში, და გვჭირდება ორივე ვექტორის ცალკეულ კომპონენტებზე წვდომა: position (მდებარეობა) და velocity (სიჩქარე).

if ((position.x > width) || (position.x < 0)) {
  velocity.x = velocity.x * -1;
}

ახლა შეიძლება, ცოტათი გულდაწყვეტილი იყოთ. ვექტორებზე გადასვლამ ჩვენი კოდი თითქოს უფრო გაართულა საწყის კოდთან შედარებით. ეს სრულიად საფუძვლიანი კრიტიკაა, მაგრამ მნიშვნელოვანია, გავიაზროთ, რომ სრულად არ გამოგვიყენებია ვექტორებით დაპროგრამების სიძლიერე. მარტივ მხტუნავ ბურთზე შეხედვა და მარტოოდენ ვექტორების შეკრების იმპლემენტაცია მხოლოდ პირველი ნაბიჯია.

რაც უფრო მეტად მივუახლოვდებით რამდენიმე ობიექტისა და რამდენიმე ძალის მქონე უფრო რთულ სამყაროს (რომელსაც მალე გაგაცნობთ), PVector-ის უპირატესობები მით უფრო მეტად ცხადი გახდება. განაგრძეთ!

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

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

შესვლა

დავალაგოთ:

პოსტები ჯერ არ არის.

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