brahe 1.4.1

Brahe is a modern satellite dynamics library for research and engineering applications designed to be easy-to-learn, high-performance, and quick-to-deploy. The north-star of the development is enabling users to solve meaningful problems and answer questions quickly, easily, and correctly.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

"""
Python (Brahe) attitude conversion benchmarks.
"""

import numpy as np

import brahe

from benchmarks.comparative.implementations.python.base import (
    ensure_eop,
    time_iterations,
)
from benchmarks.comparative.results import TaskResult


def quaternion_to_rotation_matrix(params: dict, iterations: int) -> TaskResult:
    """Benchmark quaternion to rotation matrix conversion using brahe."""
    ensure_eop()
    quaternions = params["quaternions"]

    def run():
        results = []
        for q in quaternions:
            quat = brahe.Quaternion(q[0], q[1], q[2], q[3])
            rm = quat.to_rotation_matrix()
            mat = rm.to_matrix()
            # Flatten 3x3 to row-major list
            results.append([mat[r][c] for r in range(3) for c in range(3)])
        return results

    times, results = time_iterations(run, iterations)

    return TaskResult(
        task_name="attitude.quaternion_to_rotation_matrix",
        language="python",
        library="brahe",
        iterations=iterations,
        times_seconds=times,
        results=results,
        metadata={
            "library": "brahe",
            "language": "python",
            "version": getattr(brahe, "__version__", "unknown"),
        },
    )


def rotation_matrix_to_quaternion(params: dict, iterations: int) -> TaskResult:
    """Benchmark rotation matrix to quaternion conversion using brahe."""
    ensure_eop()
    matrices = params["matrices"]

    def run():
        results = []
        for mat in matrices:
            np_mat = np.array(mat)
            rm = brahe.RotationMatrix.from_matrix(np_mat)
            q = rm.to_quaternion()
            v = q.to_vector(True)  # scalar_first=True -> [w, x, y, z]
            results.append(v.tolist())
        return results

    times, results = time_iterations(run, iterations)

    return TaskResult(
        task_name="attitude.rotation_matrix_to_quaternion",
        language="python",
        library="brahe",
        iterations=iterations,
        times_seconds=times,
        results=results,
        metadata={
            "library": "brahe",
            "language": "python",
            "version": getattr(brahe, "__version__", "unknown"),
        },
    )


def quaternion_to_euler_angle(params: dict, iterations: int) -> TaskResult:
    """Benchmark quaternion to Euler angle (ZYX) conversion using brahe."""
    ensure_eop()
    quaternions = params["quaternions"]

    def run():
        results = []
        for q in quaternions:
            quat = brahe.Quaternion(q[0], q[1], q[2], q[3])
            ea = quat.to_euler_angle(brahe.EulerAngleOrder.ZYX)
            results.append([ea.phi, ea.theta, ea.psi])
        return results

    times, results = time_iterations(run, iterations)

    return TaskResult(
        task_name="attitude.quaternion_to_euler_angle",
        language="python",
        library="brahe",
        iterations=iterations,
        times_seconds=times,
        results=results,
        metadata={
            "library": "brahe",
            "language": "python",
            "version": getattr(brahe, "__version__", "unknown"),
        },
    )


def euler_angle_to_quaternion(params: dict, iterations: int) -> TaskResult:
    """Benchmark Euler angle (ZYX) to quaternion conversion using brahe."""
    ensure_eop()
    angles = params["angles"]

    def run():
        results = []
        for phi, theta, psi in angles:
            ea = brahe.EulerAngle(
                brahe.EulerAngleOrder.ZYX,
                phi,
                theta,
                psi,
                brahe.AngleFormat.RADIANS,
            )
            q = ea.to_quaternion()
            v = q.to_vector(True)  # [w, x, y, z]
            results.append(v.tolist())
        return results

    times, results = time_iterations(run, iterations)

    return TaskResult(
        task_name="attitude.euler_angle_to_quaternion",
        language="python",
        library="brahe",
        iterations=iterations,
        times_seconds=times,
        results=results,
        metadata={
            "library": "brahe",
            "language": "python",
            "version": getattr(brahe, "__version__", "unknown"),
        },
    )