Orbital elements: Difference between revisions

{{draft task}}

 

&nbsp;<big> r = L/(1 + e cos(angle)) </big>

TODO: pick an example from a reputable source, and bring the algorithm description onto this site. (Restating those pages in concise a fashion comprehensible to the coders and readers of this site will be a good exercise.)

<br><br>

 

=={{header|C}}==

{{trans|Kotlin}}

#include <math.h>

 

printf("Speed : %s\n", buffer);

return 0;

 

{{output}}

Speed : (-0.55277084096044382, 0.95742708317976177, 0)

</pre>

 

=={{header|D}}==

{{trans|Kotlin}}

import std.stdio;

import std.typecons;

writeln("Position : ", res[0]);

writeln("Speed : ", res[1]);

{{out}}

<pre>Position : (0.7794228433986798, 0.4500000346536842, 0.0000000000000000)

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Println("Position :", position)

fmt.Println("Speed :", speed)

 

{{out}}

Speed : (-0.5527708409604438, 0.9574270831797618, 0)

</pre>

 

=={{header|Java}}==

{{trans|Kotlin}}

private static class Vector {

private double x, y, z;

System.out.printf("Speed : %s\n", ps[1]);

}

 

{{out}}

<pre>Position : (0.7794228433986797, 0.4500000346536842, 0.0000000000000000)

Speed : (-0.5527708409604438, 0.9574270831797618, 0.0000000000000000)</pre>

 

=={{header|Kotlin}}==

{{trans|Sidef}}

 

class Vector(val x: Double, val y: Double, val z: Double) {

println("Position : $position")

println("Speed : $speed")

{{out}}

<pre>Position : (0.7794228433986797, 0.45000003465368416, 0.0)

Speed : (-0.5527708409604438, 0.9574270831797618, 0.0)</pre>

 

=={{header|ooRexx}}==

{{trans|Java}}

Numeric Digits 16

ps = orbitalStateVectors(1.0, 0.1, 0.0, 355.0 / (113.0 * 6.0), 0.0, 0.0)

Say "Position :" ps~x~tostring

Say "Speed :" ps~y~tostring

pi=rxCalcpi(16)

Say "Position :" ps~x~tostring

Say "Speed :" ps~y~tostring

Return res

 

 

{{out}}

<pre>Position : (0.7794228433986798,0.4500000346536842,0)

Speed : (-0.5527708409604436,0.9574270831797613,0)

Position : (0.2377712839822067,0.8609602616977158,0.1105090235720755)

Speed : (-1.061933017480060,0.2758500205692495,0.1357470248655981)</pre>

 

=={{header|Perl}}==

use warnings;

use Math::Vector::Real;

0, # argument of periapsis

0 # true-anomaly

{{out}}

<pre>$VAR1 = {

};</pre>

 

=={{header|Phix}}==

{{trans|Python}}

{{out}}

<pre>

Speed :{-0.5477225997,0.9486832737,0}

</pre>

 

=={{header|Python}}==

 

class Vector:

ps = orbitalStateVectors(1.0, 0.1, 0.0, 355.0 / (113.0 * 6.0), 0.0, 0.0)

print "Position :", ps[0]

{{out}}

<pre>Position : (0.787295801413, 0.454545489549, 0.0)

Speed : (-0.547722599684, 0.948683273698, 0.0)</pre>

 

=={{header|REXX}}==

{{trans|Java}}

Vectors are represented by strings: 'x/y/z'

Numeric Digits 16

Parse Value orbitalStateVectors(1.0,0.1,0.0,355.0/(113.0*6.0),0.0,0.0),

End

Numeric Digits prec

{{out}}

<pre>Position : (0.7794228433986798,0.4500000346536842,0)

 

===version 2===

numeric digits length( pi() ) - length(.) /*limited to pi len, but show 1/3 digs.*/

call orbV 1, .1, 0, 355/113/6, 0, 0 /*orbital elements taken from: Java */

say ' true anomaly:' fmt(anomaly)

i= 1 0 0; j= 0 1 0; k= 0 0 1 /*define the I, J, K vectors.*/

parse value rot(j, k, inclination) with j '~' /*rotate the inclination. */

parse value rot(i, j, periapsis) with i '~' j /*rotate the argument of periapsis*/

speed= mulV( divV( speed, absV(speed) ), sqrt(2 / r - 1 / semiMaj) )

say ' position:' show( mulV( MA(i, c, j, s), r) )

/*──────────────────────────────────────────────────────────────────────────────────────*/

absV: procedure; parse arg x y z; return sqrt(x**2 + y**2 + z**2)

rot: procedure; parse arg i,j,$; return MA(i,cos($),j,sin($))'~'MA(i, -sin($), j, cos($))

r2r: return arg(1) // (pi() * 2) /*normalize radians ──► a unit circle*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

cos: procedure; arg x; x= r2r(x); if x=0 then return 1; a= abs(x); Hpi= pi * .5

if a=Hpi | a=Hpi*3 then return 0; if a=pi / 3 then return .5

/*──────────────────────────────────────────────────────────────────────────────────────*/

sin: procedure; arg x; x= r2r(x); numeric fuzz min(5, max(1, digits() - 3) )

/*──────────────────────────────────────────────────────────────────────────────────────*/

sqrt: procedure; arg x; if x=0 then return 0; d= digits(); numeric form; m.= 9; h= d+6

numeric digits; parse value format(x,2,1,,0) 'E0' with g 'E' _ .; g= g *.5'e'_ % 2

do j=0 while h>9; m.j= h; h= h % 2 + 1; end

{{out|output|text=&nbsp; when using the default internal inputs:}}

<pre>

 

=={{header|Scala}}==

 

object OrbitalElements extends App {

}

 

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/ac17jh2/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/2NQNgj4OQkazxZNvSzcexQ Scastie (remote JVM)].

 

=={{header|Sidef}}==

{{trans|Perl}}

semimajor_axis,

eccentricity,

true_anomaly

) {

 

func muladd(v1, x1, v2, x2) {

}

 

var r = l/(1 + eccentricity*c)

var rprime = (s * r**2 / l)

 

var speed = muladd(i, rprime*c - r*s, j, rprime*s + r*c)

 

struct Result { position, speed }

}

 

)

 

{{out}}

 

=={{header|zkl}}==

{{trans|Perl}}

longitude_of_ascending_node, argument_of_periapsis, true_anomaly){

i,j,k:=T(1.0, 0.0, 0.0), T(0.0, 1.0, 0.0), T(0.0, 0.0, 1.0);

return(position,speed);

1.0, # semimajor axis

0.1, # eccentricity

0.0, # argument of periapsis

0.0 # true-anomaly

{{out}}

<pre>L(L(0.779423,0.45,0),L(-0.552771,0.957427,0))</pre>