बिल्ली कहाँ जाएगी? (कक्षीय यांत्रिकी)

Question

एक लगभग विशाल बिल्ली को अंतरिक्ष में गिरा दिया जाता है (चिंता मत करो, अंतरिक्ष सूट और सब कुछ के साथ) (x, y, z)वेग के साथ बिंदु पर (vx, vy, vz)। बिंदु पर एक निश्चित, असीम रूप से घना ग्रह है (0 की मात्रा के साथ) (0, 0, 0)और यह rत्वरण के साथ दूरी पर वस्तुओं को आकर्षित करता है 1/r^2। न्यूटोनियन गुरुत्वाकर्षण के अनुसार, वस्तु समय के बाद कहां जाती है t?

इस मामले में लगभग बड़े पैमाने पर मतलब है कि आप के मूल्य का उत्पादन कर रहे हैं lim (mass --> 0) <position of cat>। द्रव्यमान ग्रह के गुरुत्वाकर्षण से प्रभावित होता है, लेकिन ग्रह बिल्ली के गुरुत्वाकर्षण से प्रभावित नहीं होता है। दूसरे शब्दों में, केंद्रीय निकाय तय हो गया है।

यह कुछ हद तक कोड गोल्फ के समान है : अंतरिक्ष यान का भाग्य क्या है? [फ्लोटिंग पॉइंट संस्करण] , लेकिन यह अलग है क्योंकि यह सटीकता को माप रहा है।

आप एक सिमुलेशन के आधार पर एक समाधान लागू कर सकते हैं, जो 3 सेकंड से कम समय में चलना चाहिए, या आप एक प्रोग्राम लागू कर सकते हैं जो सटीक मूल्य देता है (3 सेकंड से कम समय में भी चलना चाहिए)। नीचे स्कोरिंग विवरण देखें। यदि आप एक सिमुलेशन लागू करते हैं, तो यह सटीक होना जरूरी नहीं है, लेकिन अशुद्धि के कारण आपका स्कोर कम होगा।

इनपुट : x y z vx vy vz tजरूरी नहीं कि x, y, z निर्देशांक, x, y और z दिशाओं और समय में क्रमशः वेग का प्रतिनिधित्व करने वाले पूर्णांक हों। यह गारंटी है कि बिल्ली की गति उस ऊंचाई पर भागने के वेग से कड़ाई से कम है। एक फ़ंक्शन के मापदंडों सहित इनपुट कहीं से भी लिया जा सकता है। कार्यक्रम को मेरे लैपटॉप पर तीन सेकंड से कम समय में चलना चाहिए t < 2^30, जिसका अर्थ है, यदि आप एक सिमुलेशन चला रहे हैं, तो आपको अपने टाइमस्टेप को तदनुसार समायोजित करना होगा। यदि आप हर टेस्ट केस के लिए 3 सेकंड की सीमा पर टकराने की योजना बना रहे हैं, तो सुनिश्चित करें कि एक ट्यून करने योग्य पैरामीटर है जो इसे स्पीड गेन के लिए अधिक सटीक / कम सटीक बना सकता है, ताकि मैं इसे अपने कंप्यूटर पर तीन सेकंड में चला सकूं।

आउटपुट : x y zसमय के बाद की स्थिति t।

चूंकि दो-शरीर की समस्या को पूरी तरह से हल किया जा सकता है, इसलिए एक सही, सही उत्तर प्राप्त करना संभव है।

स्कोरिंग : किसी भी परीक्षण के मामले में, त्रुटि को आपके आउटपुट और "सही" आउटपुट के बीच की दूरी के रूप में परिभाषित किया गया है। सही आउटपुट को परिभाषित किया जाता है कि टेस्ट केस स्निपेट उत्पन्न करता है। यदि त्रुटि से कम है 10^(-8), तो त्रुटि को शून्य तक गोल किया जाता है। आपका स्कोर 100 (या अधिक) यादृच्छिक परीक्षण मामलों पर औसत त्रुटि है। यदि आप एक सटीक उत्तर लिखते हैं, तो आपको 0 का स्कोर प्राप्त करना चाहिए; सबसे कम स्कोर जीतता है, और कोड की लंबाई से संबंध टूट जाएगा।

परीक्षण के मामले :

1 0 0 0 -1 0 1000000000 --> 0.83789 -0.54584 0

इस मामले में, कक्षा 2 * पी के साथ पूरी तरह से गोलाकार है, इसलिए 159154943 बार चक्कर लगाने के बाद, बिल्ली लगभग (0.83789, -0.54584) पर समाप्त होती है। यह एक ऐसा परीक्षण मामला नहीं है जिस पर आपके कोड का परीक्षण किया जाएगा; यदि आप बिलकुल सटीक उत्तर प्रस्तुत करते हैं, हालाँकि, आप इस पर परीक्षण करना चाहते हैं।

नीचे दिया गया स्निपेट यादृच्छिक अतिरिक्त परीक्षण मामलों को उत्पन्न करता है और सबमिशन का न्याय करने के लिए उपयोग किया जाएगा; मुझे बताएं कि क्या इसके साथ कोई बग है:

var generateTestCase = function() {
  var periapsis = Math.random() * 10 + 0.5;
  var circularVelocity = Math.sqrt(1 / periapsis);
  var escapeVelocity = Math.sqrt(2) * circularVelocity;
  var v = Math.random() * (escapeVelocity - circularVelocity) + circularVelocity;
  var a = 1 / (2 / periapsis - v * v);
  var ecc = (a - periapsis) * (2 / periapsis - v * v);
  var semiLatus = a * (1 - ecc * ecc);
  var angM = Math.sqrt(semiLatus);
  var period = 2 * Math.PI * a * Math.sqrt(a);
  var getCoordAfterTime = function(t) {
    var meanAnomaly = t / (a * Math.sqrt(a));

    function E(e, M, n) {
      var result = M;
      for (var k = 1; k <= n; ++k) result = M + e * Math.sin(result);
      return result;
    }
    var eAnomaly = E(ecc, meanAnomaly, 10000);
    var radius = a * (1 - ecc * Math.cos(eAnomaly));
    var theta = Math.acos((semiLatus / radius - 1) / ecc);
    if (t > period / 2) theta = -theta;
    return {
      r: radius,
      t: theta,
      x: radius * Math.cos(theta),
      y: radius * Math.sin(theta)
    };
  }
  var t1 = Math.random() * period;
  var p1 = getCoordAfterTime(t1);
  var v1 = Math.sqrt(2 / p1.r - 1 / a);
  var velocityAngle1 = Math.acos(angM / p1.r / v1);
  var horizontal = Math.atan(-p1.x / p1.y);
  if (t1 < period / 2) {
    velocityAngle1 *= -1;
    horizontal += Math.PI;
  }
  var vx = v1 * Math.cos(horizontal + velocityAngle1);
  var vy = v1 * Math.sin(horizontal + velocityAngle1);
  var t2 = Math.random() * period;
  var p2 = getCoordAfterTime(t2);
  var v2 = Math.sqrt(2 / p2.r - 1 / a);
  var dummyPeriods = Math.floor(Math.random() * 100) * period + period;
  var rotate = function(x, y, z, th1, th2, th3) {
    var x1 = x * Math.cos(th1) - y * Math.sin(th1);
    var y1 = x * Math.sin(th1) + y * Math.cos(th1);
    var z1 = z;
    var x2 = x1 * Math.cos(th2) + z1 * Math.sin(th2);
    var y2 = y1;
    var z2 = -x1 * Math.sin(th2) + z1 * Math.cos(th2);
    var x3 = x2;
    var y3 = y2 * Math.cos(th3) - z2 * Math.sin(th3);
    var z3 = y2 * Math.sin(th3) + z2 * Math.cos(th3);
    return [x3, y3, z3];
  }
  var th1 = Math.random() * Math.PI * 2,
    th2 = Math.random() * 2 * Math.PI,
    th3 = Math.random() * 2 * Math.PI;
  var input = rotate(p1.x, p1.y, 0, th1, th2, th3)
    .concat(rotate(vx, vy, 0, th1, th2, th3))
    .concat([t2 - t1 + dummyPeriods]);
  var output = rotate(p2.x, p2.y, 0, th1, th2, th3);
  return input.join(" ") + " --> " + output.join(" ");
}
var $ = function(x) {
  return document.querySelector(x);
}
$("#onetestcase").onclick = function() {
  $("#result1").innerHTML = generateTestCase();
}
$("#huntestcases").onclick = function() {
  var result = [];
  for (var i = 0; i < 100; ++i) result.push(generateTestCase());
  $("#result100").innerHTML = result.join("\n");
}

<div>
  <button id="onetestcase">Generate</button>
  <pre id="result1"></pre>
</div>
<div>
  <button id="huntestcases">Generate 100 test cases</button>
  <pre id="result100"></pre>
</div>

Comments

क्या tसेकंड में समय दिया जाता है? यदि ऐसा है, तो वेग प्रति सेकंड इकाइयों में दिया जाएगा, या कुछ छोटा होगा?

— आर। कप

@R। कप यह कोई फर्क नहीं पड़ता। tइकाई समय में दिया जाता है, जो कुछ भी है और वेग उसी इकाई का उपयोग करेगा। चाहे वह सेकंड या घंटों में हो, जवाब एक ही होगा।

— 193 में soktinpk

nearly massless catखैर, बिल्ली का सटीक द्रव्यमान क्या होगा? क्या हमें सिर्फ 0इस बिल्ली के द्रव्यमान के लिए एक मूल्य के रूप में उपयोग करना चाहिए ?

— आर। काप

@R। कप हं। लेकिन यह अभी भी गुरुत्वाकर्षण से प्रभावित है (आमतौर पर, न्यूटन ने गुरुत्वाकर्षण से प्रभावित होने वाले द्रव्यमान के साथ वस्तुओं पर विचार नहीं किया)। तो हमें इसे मनमाने ढंग से छोटा द्रव्यमान मान लेना चाहिए, और आपका उत्तर वास्तव में स्थिति है क्योंकि बिल्ली का द्रव्यमान शून्य हो जाता है। मुख्य बिंदु यह है कि ग्रह खुद बिल्ली से बिल्कुल प्रभावित नहीं होता है।

— soktinpk

@soktinpk यह स्पष्ट रूप से कहना आसान हो सकता है कि केंद्रीय निकाय तय हो गया है।

— माल्टीसेन

Answer 1

पायथन 3.5 + न्यूमपी, सटीक, 186 बाइट्स

from math import*
def o(r,v,t):
 d=(r@r)**.5;W=2/d-v@v;U=W**1.5;b=[0,t*U+9]
 while 1:
  a=sum(b)/2;x=1-cos(a);y=sin(a)/U;k=r@v*x/W+d*y*W
  if a in b:return k*v-r*x/W/d+r
  b[k+a/U-y>t]=a

यह एक सटीक समाधान है, जिसका उपयोग मैंने जेस्पर गॉरेन्सनहिस पर आधारित एक सूत्र का उपयोग करके किया है , "केप्लर समस्या के समरूपता", 2015 । यह ट्रांसेंडेंटल समीकरण Ax + B cos x + C sin x = D को हल करने के लिए एक द्विआधारी खोज का उपयोग करता है, जिसका कोई बंद-रूप समाधान नहीं है।

फ़ंक्शन को उम्मीद है कि स्थिति और वेग को NumPy सरणियों के रूप में पारित किया जाएगा:

>>> from numpy import array
>>> o(array([1,0,0]),array([0,-1,0]),1000000000)
array([ 0.83788718, -0.54584345,  0.        ])
>>> o(array([-1.1740058273269156,8.413493259550673,0.41996042044140003]),array([0.150014367067652,-0.09438816345868332,0.37294941703455975]),7999.348650387233)
array([-4.45269544,  6.93224929, -9.27292488])

Comments

क्या करता @है?

— आर। काप

यह पायथन 3.5 में एक नया ऑपरेटर है जो numpy.dot(डॉट उत्पाद / मैट्रिक्स गुणन) के लिए NumPy ओवरलोड करता है । PEP 465 देखें।

— एंडर्स कासोर्ग

यह बहुत अच्छा है कि इसे गढ़ा जाता है, लेकिन यह कोड-चुनौती है, क्या आप इसे थोड़ा स्पष्ट कर सकते हैं, मेरे पास पायथन में कुछ खरोंच थे, और विसंगति, थीटा, विलक्षणता, अवधि, आदि की गणना कर सकते हैं, लेकिन यह निर्धारित करने पर अटक गया है थीटा के संकेत और xy संदर्भ विमान से 3 डी अंतरिक्ष के रोटेशन का निर्धारण। फिर भी, यह वास्तव में महान सामान है

— मील

@ मीलों के बाद से संबंध कोड की लंबाई से टूट गए हैं, यह समझ में आता है कि यह गोल्फ होना है।

— मेगो

यह सच है, जैसा कि मैं एक सटीक समाधान पर भी काम कर रहा था, क्योंकि परीक्षण के मामले में जनरेटर केवल अण्डाकार कक्षाएँ बनाता है

— मील

Answer 2

जावास्क्रिप्ट

यह केवल गेंद को लुढ़काने के लिए है, क्योंकि कोई भी उत्तर पोस्ट नहीं करता है। यहाँ एक बहुत ही सरल, सरल तरीका है जिसे बहुत सुधार किया जा सकता है:

function simulate(x, y, z, vx, vy, vz, t) {
  var loops = 1884955; // tune this parameter
  var timestep = t / loops;
  for (var i = 0; i < t; i += timestep) {
    var distanceSq = x*x + y*y + z*z; // distance squared from origin
    var distance = Math.sqrt(distanceSq);
    var forceMag = 1/distanceSq; // get the force of gravity
    var forceX = -x / distance * forceMag;
    var forceY = -y / distance * forceMag;
    var forceZ = -z / distance * forceMag;
    vx += forceX * timestep;
    vy += forceY * timestep;
    vz += forceZ * timestep;
    x += vx * timestep;
    y += vy * timestep;
    z += vz * timestep;
  }
  return [x, y, z];
}

परिक्षण:

simulate(1, 0, 0, 0, -1, 0, Math.PI*2) --> [0.9999999999889703, -0.0000033332840909716455, 0]

अरे, यह बहुत अच्छा है। इसमें लगभग 3.333 * 10 ^ (- 6) की त्रुटि है जो इसे गोल करने के लिए पर्याप्त नहीं है ... यह करीब है।

सिर्फ मनोरंजन के लिए:

console.log(simulate(1, 0, 0, 0, -1, 0, 1000000000))
--> [-530516643639.4616, -1000000000.0066016, 0]

ओह अच्छा; तो यह सबसे अच्छा नहीं है।

और जनरेटर से एक यादृच्छिक परीक्षण मामले पर:

simulate(-1.1740058273269156,8.413493259550673,0.41996042044140003,0.150014367067652,-0.09438816345868332,0.37294941703455975,7999.348650387233)
-->    [-4.528366392498373, 6.780385554803544, -9.547824236472668]
Actual:[-4.452695438880813, 6.932249293597744, -9.272924876103785]

केवल 0.32305 की त्रुटि के साथ!

वेरलेट इंटीग्रेशन या कुछ फैंसी एल्गोरिदम जैसे कुछ का उपयोग करके इसे बहुत सुधार किया जा सकता है। वास्तव में, उन एल्गोरिदम को सिमुलेशन होने के बावजूद भी पूर्ण स्कोर मिल सकता है।