Orbital elements: Difference between revisions

{{draft task}}

 

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

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

Position : (0.787295801, 0.45454549, 0)

Speed : (-0.5477226, 0.948683274, 0)

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

Speed : (-0.5527708409604437, 0.9574270831797614, 0.0000000000000000)</pre>

 

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

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

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

 

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

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

 

var orbitalStateVectors = Fn.new { |semimajorAxis, eccentricity, inclination,

longitudeOfAscendingNode, argumentOfPeriapsis, trueAnomaly|

 

var mulAdd = Fn.new { |v1, x1, v2, x2| v1 * x1 + v2 * x2 }

var position = mulAdd.call(i, c, j, s) * r

var speed = mulAdd.call(i, rprime * c - r * s, j, rprime * s + r * c)

speed = speed * (2 / r - 1 / semimajorAxis).sqrt

return [position, speed]

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

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

 

{{out}}

Position : (0.77942284339868, 0.45000003465368, 0)

Speed : (-0.55277084096044, 0.95742708317976, 0)

</pre>

 

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