Orbital elements: Difference between revisions

{{trans|Python}}

 

R v1 * x1 + v2 * x2

 

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

print(‘Position : ’ps[0])

 

{{out}}

=={{header|Ada}}==

{{Trans|Kotlin}}

with Ada.Numerics.Generic_Real_Arrays;

with Ada.Numerics.Generic_Elementary_Functions;

Put ("Position : "); Put (State.Position); New_Line;

Put ("Speed : "); Put (State.Speed); New_Line;

{{out}}

<pre>

=={{header|ALGOL W}}==

{{Trans|C}} (which is a translation of Kotlin which is a translation of ...).

% compute orbital elements %

% 3-element vector %

write( "Speed : " ); writeOnVector( speed )

end

{{out}}

<pre>

=={{header|C}}==

{{trans|Kotlin}}

#include <math.h>

 

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

return 0;

 

{{output}}

=={{header|C sharp|C#}}==

{{trans|D}}

 

namespace OrbitalElements {

}

}

{{out}}

<pre>Position : (0.77942284339868, 0.450000034653684, 0)

=={{header|C++}}==

{{trans|C#}}

#include <tuple>

 

 

return 0;

{{out}}

<pre>Position : (0.779423, 0.45, 0)

=={{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}}

 

=={{header|J}}==

NB. x: axis (0, 1 or 2), y: angle in radians

R=: {{ ((2 1,:1 2) o.(,-)y*_1^2|x)(,&.>/~0 1 2-.x)} =i.3 }}

speed=. (%:(2%ra)-%a)*norm(rp,ra,0) X ijk

position,:speed

 

The true anomaly, argument of Periapsis, Longitude of the ascending node and inclination are all angles. And we use the dot product of their rotation matrices (in that order) to find the orientation of the orbit and the object's position in that orbit. Here, <code>R</code> finds the rotation matrix for a given angle around a given axis. Here's an example of what R gives us for a sixty degree angle:

 

┌────────────────────┬────────────────────┬────────────────────┐

│1 0 0│ 0.5 0 _0.866025│ 0.5 0.866025 0│

│0 0.5 0.866025│ 0 1 0│_0.866025 0.5 0│

│0 _0.866025 0.5│0.866025 0 0.5│ 0 0 1│

 

0.779423 0.45 0

 

=={{header|Java}}==

{{trans|Kotlin}}

private static class Vector {

private double x, y, z;

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

}

 

{{out}}

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

def addVectors: transpose | map(add);

 

| divide(abs)

| multiply( ((2 / $r) - (1 / semimajorAxis))|sqrt) as $speed

'''The Task'''

| "Position : \(.[0])",

{{out}}

<pre>

=={{header|Julia}}==

{{trans|Kotlin}}

import Base.abs, Base.print

 

 

testorbitalmath()

<pre>

Position : (0.7794228433986797, 0.45000003465368416, 0.0)

=={{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)

=={{header|Nim}}==

{{trans|Kotlin}}

 

type Vector = tuple[x, y, z: float]

trueAnomaly = 0.0)

echo "Position: ", position

 

{{out}}

=={{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)

Return res

 

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use Math::Vector::Real;

0, # argument of periapsis

0 # true-anomaly

{{out}}

<pre>$VAR1 = {

=={{header|Phix}}==

{{trans|Python}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">vabs</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">v</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">orbitalStateVectors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1.0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">355.0</span> <span style="color: #0000FF;">/</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">113.0</span> <span style="color: #0000FF;">*</span> <span style="color: #000000;">6.0</span><span style="color: #0000FF;">),</span> <span style="color: #000000;">0.0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0.0</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

This implementation uses the CLP/R library of swi-prolog, but doesn't have to. This removes the need for a vector divide and has limited capability to reverse the functionality (eg: given the position/speed find some orbital elements).

 

 

v3_add(v(X1,Y1,Z1),v(X2,Y2,Z2),v(X,Y,Z)) :-

find_l(Ecc, SemiMajor, L) :-

dif(Ecc,1.0),

{{out}}

<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)

(formerly Perl 6)

We'll use the [https://github.com/grondilu/clifford Clifford geometric algebra library] but only for the vector operations.

Real :$semimajor-axis where * >= 0,

Real :$eccentricity where * >= 0,

longitude-of-ascending-node => pi/6,

argument-of-periapsis => pi/4,

{{out}}

<pre>{position => 0.237771283982207*e0+0.860960261697716*e1+0.110509023572076*e2, speed => -1.06193301748006*e0+0.27585002056925*e1+0.135747024865598*e2}</pre>

{{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===

Re-coding of REXX version 1, &nbsp; but with greater decimal digits precision.

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 */

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,

say "Position : #{r.position}"

say "Speed : #{r.speed}\n"

{{out}}

<pre>

{{trans|Kotlin}}

 

 

public struct Vector {

)

 

 

{{out}}

=={{header|Wren}}==

{{trans|Kotlin}}

construct new(x, y, z) {

_x = x

var ps = orbitalStateVectors.call(1, 0.1, 0, 355 / (113 * 6), 0, 0)

System.print("Position : %(ps[0])")

 

{{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>