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

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

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

კუთხური სიჩქარე

გახსოვთ ეს ყველაფერი?
location = location + velocity
velocity = velocity + acceleration
და ის ყველაფერი, რასაც თითქმის მთელი ბოლო 2 სექცია დავუთმეთ? შეგვიძლია, ზუსტად იგივე ლოგიკა გამოვიყენოთ მბრუნავ ობიექტზე.
angle = angle + angular velocity
angular velocity = angular velocity + angular acceleration
სინამდვილეში, ზედა მაგალითი უფრო ადვილია, ვიდრე ის, რითაც დავიწყეთ, რადგან კუთხე სკალარული სიდიდეა — ცალკეული რიცხვი და არა - ვექტორი!
წინა გამოწვევაში მიღებული პასუხის გამოყენებით, ვთქვათ, გვინდოდა მბრუნავი ჯოხის მობრუნება ProcessingJS-ში რაღაც კუთხით. ამგვარი კოდი გვექნებოდა:
translate(width/2, height/2);
rotate(angle);
line(-50, 0, 50, 0);
ellipse(50, 0, 8, 8);
ellipse(-50, 0, 8, 8);
მოძრაობის წესების დამატების შემდეგ გვაქვს ქვემოთ მოცემული პროგრამა. მბრუნავი ჯოხი ჩნდება ეკრანზე მობრუნების გარეშე და შემდეგ ბრუნავს უფრო და უფრო ჩქარა, რადგან მობრუნების კუთხე ჩქარდება:
ეს იდეა შეგვიძლია, გამოვიყენოთ ჩვენს Mover ობიექტში. მაგალითად, შეგვიძლია, კუთხურ მოძრაობასთან დაკავშირებული თვისებები დავამატოთ ჩვენს Mover კონსტრუქტორს.
var Mover = function(m, x, y) {
    this.position = new PVector(x, y);
    this.mass = m;

    this.angle = 0;
    this.aVelocity = 0;
    this.aAcceleration = 0;

    this.velocity = new PVector(random(-1, 1), random(-1, 1));
    this.acceleration = new PVector(0, 0);
};
და update()-ში განვაახლებთ ადგილმდებარეობასაც და კუთხესაც ერთისა და იმავე ალგორითმის გამოყენებით!
Mover.prototype.update = function () {

    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);

    this.aVelocity += this.aAcceleration;
    this.angle += this.aVelocity;

    this.acceleration.mult(0);
};
რა თქმა უნდა, ამ ყველაფერს აზრი არ ექნება, თუ ობიექტს არ მოვაბრუნებთ მის ეკრანზე გამოჩენისას.
Mover.prototype.display = function () {
    stroke(0, 0, 0);
    fill(175, 175, 175, 200);
    rectMode(CENTER);

    // pushMatrix და popMatrix გვჭირდება, რათა ფიგურის მობრუნებამ
    //  გავლენა არ იქონიოს დანარჩენ სამყაროზე
    pushMatrix();
    // დავაყენოთ ათვლის სათავე ფიგურის ადგილმდებარეობაზე
    translate(this.location.x, this.location.y);
    // კუთხური მობრუნება
    rotate(this.angle);
    rect(0, 0, this.mass*16, this.mass*16);
    popMatrix();
};
თუ ზემოთ მოცემულს კოდს გავუშვებთ, ახალს ვერაფერს ვნახავთ. ეს იმიტომ, რომ კუთხური აჩქარება (this.aAcceleration = 0;) ინიციალიზებულია 0-ად. იმისთვის, რომ ობიექტმა ბრუნვა დაიწყოს, მას აჩქარება უნდა მივცეთ! ცხადია, შეგვეძლო, ხელით ჩაგვეწერა სხვადასხვა რიცხვი:
this.aAcceleration = 0{,}01;
აი, როგორ გამოიყურება პროგრამა ზემოთ მოცემული ლოგიკით, ცენტრალური მიმზიდველის მიხედვით გამოთვლილი ძალით:
ეს კარგი დასაწყისია, მაგრამ შეგვიძლია, უფრო საინტერესო შედეგი მივიღოთ, თუკი გარემოში არსებული ძალების მიხედვით დინამიკურად მივანიჭებთ კუთხურ აჩქარებას, რადგან, ძირითადად, ობიექტები თავისით არ ბრუნავენ! ახლა შეგვიძლია, ძალიან შორს წასვლა ვცადოთ კუთხური აჩქარების ფიზიკის მოდელირებით ძალის მომენტისა და ინერციის მომენტის წესების გამოყენებით. ამ დონის სიმულაცია ჩვენი კურსის ფარგლებს მიღმაა, მაგრამ ჩვენც მალე გავართულებთ.
ჯერჯერობით სწრაფი და მახინჯი ამოხსნა გამოდგება. შეგვიძლია, აზრიანი შედეგები მივიღოთ კუთხური აჩქარების გამოთვლით ობიექტის აჩქარების ვექტორის ფუნქციად. აი, ერთი მაგალითი:
this.aAcceleration = this.acceleration.x;
დიახ, ეს სრულიად შემთხვევითია, მაგრამ რაღაცას აკეთებს. თუ ობიექტი ჩქარდება მარჯვნივ, მისი კუთხური ბრუნვა ჩქარდება საათის ისრის მიმართულებით; მარცხნივ აჩქარება შედეგად გვაძლევს საათის ისრის საწინააღმდეგო მიმართულებით მობრუნებას. რა თქმა უნდა, ამ შემთხვევაში მნიშვნელოვანია სკალირებაზე ფიქრი. აჩქარების ვექტორის x კომპონენტი შეიძლება, ძალიან დიდი იყოს და შედეგად მოგვცეს ობიექტის არარეალური მობრუნება. ამიტომ შეიძლება, გამოგვადგეს x კომპონენტის რაიმე რიცხვზე გაყოფა ან კუთხური სიჩქარისათვის დიაპაზონის დაწესება. აი, სრული update() მეთოდი ამ ყველაფრის დამატებით.
Mover.prototype.update = function () {
    this.velocity.add(this.acceleration);
    this.position.add(this.velocity);

    // გამოთვალეთ კუთხური აჩქარება ჰორიზონტალური აჩქარების მიხედვით
    //  და გაყავით, რათა ისეთივე ძლიერი არ იყოს
    this.aAcceleration = this.acceleration.x / 10{,}0;
    this.aVelocity += this.aAcceleration;

    // სიჩქარის გასაკონტროლებლად გამოიყენეთ შეზღუდვა
    this.aVelocity = constrain(this.aVelocity, -0{,}1, 0{,}1);
    this.angle += this.aVelocity;

    this.acceleration.mult(0);
};
აი, როგორ გამოიყურება პროგრამა ამ ცვლილებების შემდეგ:

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

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

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