| Server IP : 35.80.110.71 / Your IP : 216.73.216.221 Web Server : Apache/2.4.58 (Ubuntu) System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64 User : ubuntu ( 1000) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/sympy/physics/vector/__pycache__/ |
Upload File : |
�
M�Zd�� � � � d dl mZmZmZmZmZmZmZmZ m
Z
d dl m Z d dl
mZ d dlmZmZ d dlmZ d dlmZ ddgZ G d � de � Z G d
� d� Zd � Zy )
� ) �diff�expand�sin�cos�sympify�eye�zeros�ImmutableMatrix�
MatrixBase)�Symbol)�trigsimp)�Vector�
_check_vector)� translate)�warn�
CoordinateSym�ReferenceFramec �D � � e Zd ZdZ� fd�Zed� � Zd� Zd� Zd� Z � xZ
S )r a�
A coordinate symbol/base scalar associated wrt a Reference Frame.
Ideally, users should not instantiate this class. Instances of
this class must only be accessed through the corresponding frame
as 'frame[index]'.
CoordinateSyms having the same frame and index parameters are equal
(even though they may be instantiated separately).
Parameters
==========
name : string
The display name of the CoordinateSym
frame : ReferenceFrame
The reference frame this base scalar belongs to
index : 0, 1 or 2
The index of the dimension denoted by this coordinate variable
Examples
========
>>> from sympy.physics.vector import ReferenceFrame, CoordinateSym
>>> A = ReferenceFrame('A')
>>> A[1]
A_y
>>> type(A[0])
<class 'sympy.physics.vector.frame.CoordinateSym'>
>>> a_y = CoordinateSym('a_y', A, 1)
>>> a_y == A[1]
True
c � �� i }t �| � || � t �| � | |fi |��}t |� |t dd� vr t d� �||f|_ |S )Nr � zInvalid index specified)�super� _sanitize�__xnew__� _check_frame�range�
ValueError�_id)�cls�name�frame�index� assumptions�obj� __class__s ��</usr/lib/python3/dist-packages/sympy/physics/vector/frame.py�__new__zCoordinateSym.__new__3 sa �� � � �
���+�s�+��g� �s�D�8�K�8���U�� ��a�� � #� � 6�7� 7��%�.����
� c � � | j d S )Nr )r ��selfs r% r zCoordinateSym.frame? s � ��x�x��{�r' c �X � t |t � r|j | j k( ryy)NTF)�
isinstancer r �r* �others r% �__eq__zCoordinateSym.__eq__C s$ � � �e�]� +��y�y�D�H�H�$��r' c � � | |k( S �N� r- s r% �__ne__zCoordinateSym.__ne__K s � ��5�=� � r' c �v � | j d j � | j d fj � S )Nr � )r �__hash__r) s r% r6 zCoordinateSym.__hash__N s/ � ����� �$�$�&����� �4�=�=�?�?r' ) �__name__�
__module__� __qualname__�__doc__r& �propertyr r/ r3 r6 �
__classcell__)r$ s @r% r r
s2 �� �#�J
� �� ���!�@r' c �� � e Zd ZdZdZd d�Zd� Zd� Zd� ZeZ d� Z
d � Z d
� Z d � Z
d � Zd
� Zd� Zd� Zd� Zd� Zd� Zd� Zd� Zd� Zd d�Z d d�Zd� Zd� Ze d� � Z e d� � Z e d � � Z d � Z y)!r a� A reference frame in classical mechanics.
ReferenceFrame is a class used to represent a reference frame in classical
mechanics. It has a standard basis of three unit vectors in the frame's
x, y, and z directions.
It also can have a rotation relative to a parent frame; this rotation is
defined by a direction cosine matrix relating this frame's basis vectors to
the parent frame's basis vectors. It can also have an angular velocity
vector, defined in another frame.
r Nc � � t |t � s t d� �|��3t |t t f� s t d� �t |� dk7 r t
d� �|D ] }t |t � r�t d� � |dz |d z d z |dz |d
z d z |dz |d z d z g| _ |j � d z |d z |j � d z |d
z |j � d z |d z g| _ d
|j � �d|d �d�d
|j � �d|d
�d�d
|j � �d|d �d�g| _
|| _ n�|dz |dz |dz g| _ |j � dz |j � dz |j � dz g| _ d|j � z d|j � z d|j � z g| _
g d�| _ |�ct |t t f� s t d� �t |� dk7 r t
d� �|D ] }t |t � r�t d� � || _
|| _ i | _
i | _ i | _ i | _ i | _ | j | j | j" g| _ d| _ t) t+ g d�� | fg� | _ t) t+ g d �� | fg� | _ t) t+ g d �� | fg� | _ |�]t |t t f� s t d � �t |� dk7 r t
d � �|D ] }t |t � r�t d � � n|dz |dz |dz g}t3 |d | d� t3 |d
| d
� t3 |d | d � f| _ t6 xj8 d
z
c_ t6 j8 | _ y)!aS ReferenceFrame initialization method.
A ReferenceFrame has a set of orthonormal basis vectors, along with
orientations relative to other ReferenceFrames and angular velocities
relative to other ReferenceFrames.
Parameters
==========
indices : tuple of str
Enables the reference frame's basis unit vectors to be accessed by
Python's square bracket indexing notation using the provided three
indice strings and alters the printing of the unit vectors to
reflect this choice.
latexs : tuple of str
Alters the LaTeX printing of the reference frame's basis unit
vectors to the provided three valid LaTeX strings.
Examples
========
>>> from sympy.physics.vector import ReferenceFrame, vlatex
>>> N = ReferenceFrame('N')
>>> N.x
N.x
>>> O = ReferenceFrame('O', indices=('1', '2', '3'))
>>> O.x
O['1']
>>> O['1']
O['1']
>>> P = ReferenceFrame('P', latexs=('A1', 'A2', 'A3'))
>>> vlatex(P.x)
'A1'
``symbols()`` can be used to create multiple Reference Frames in one
step, for example:
>>> from sympy.physics.vector import ReferenceFrame
>>> from sympy import symbols
>>> A, B, C = symbols('A B C', cls=ReferenceFrame)
>>> D, E = symbols('D E', cls=ReferenceFrame, indices=('1', '2', '3'))
>>> A[0]
A_x
>>> D.x
D['1']
>>> E.y
E['2']
>>> type(A) == type(D)
True
zNeed to supply a valid nameNz Supply the indices as a listr zSupply 3 indiceszIndices must be stringsz['r z']r5 � �_z
\mathbf{\hat{z}_{z}}z.xz.yz.z�_x�_y�_zz\mathbf{\hat{%s}_x}z\mathbf{\hat{%s}_y}z\mathbf{\hat{%s}_z})�x�y�zz Latex entries must be strings�r5 r r �r r5 r �r r r5 z)Supply the variable names as a list/tuplezSupply 3 variable namesz Variable names must be strings) r, �str� TypeError�tuple�list�lenr �str_vecs�lower� pretty_vecs�
latex_vecs�indicesr � _var_dict� _dcm_dict�
_dcm_cache�
_ang_vel_dict�
_ang_acc_dict�_dlist�_curr �MatrixrA rB rC r �varlistr �_countr! )r* r rS �latexs� variables�is r% �__init__zReferenceFrame.__init__a s� � �j �$��$�� 9�:� :� � � �g��t�}�5� � >�?�?��7�|�q� � �!3�4�4� �
?��!�!�S�)�#�$=�>�>�
?� #�U�l�W�Q�Z� 7�%� ?� "�U�l�W�Q�Z� 7�%� ?� "�U�l�W�Q�Z� 7�%� ?� B�D�M� "&��� ��!3�g�a�j�!@�!%��� ��!3�g�a�j�!@�!%��� ��!3�g�a�j�!@� C�D� � >B�Z�Z�\�=D�Q�Z�!I�=A�Z�Z�\�=D�Q�Z�!I�=A�Z�Z�\�=D�Q�Z�!I� K�D�O� #�D�L� #�T�k�T�D�[�D�4�K� I�D�M� $�
�
� �t� 3� $�
�
� �t� 3� $�
�
� �t� 3� 5�D� � !7���� � E� 6���� � E� 6���� � E� H�D�O� +�D�L� � � �f�u�d�m�4� � >�?�?��6�{�a� � �!3�4�4��
E��!�!�S�)�#�$C�D�D�
E� %�D�O��� ����
��� ��� ��� ����~�~�t�'9�'9�4�;M�;M�N�� ��� ��6�)�,�d�3�4�5����6�)�,�d�3�4�5����6�)�,�d�3�4�5��� � � �i�%�� �7� � K�L�L��9�~��"� �!:�;�;� �
F��!�!�S�)�#�$D�E�E�
F� ���d�T�k�4�$�;�?�I�%�i��l�D�!�<�%�i��l�D�!�<�%�i��l�D�!�<�>�� � � � ��"� �#�*�*��
r' c �* � t |t � s |dk r| j | S t d� �| j d |k( r | j
S | j d |k( r | j S | j d |k( r | j S t d� �)z�
Returns basis vector for the provided index, if the index is a string.
If the index is a number, returns the coordinate variable correspon-
-ding to that index.
r zInvalid index providedr r5 r? zNot a defined index)r, rJ r\ r rS rD rE rF )r* �inds r% � __getitem__zReferenceFrame.__getitem__� s� � � �#�s�#��Q�w��|�|�C�(�(� �!9�:�:� �<�<��?�c� !��6�6�M� �<�<��?�c� !��6�6�M� �<�<��?�c� !��6�6�M� � 2�3� 3r' c �Z � t | j | j | j g� S r1 )�iterrD rE rF r) s r% �__iter__zReferenceFrame.__iter__� s � ��T�V�V�T�V�V�T�V�V�,�-�-r' c � � | j S )z Returns the name of the frame. )r r) s r% �__str__zReferenceFrame.__str__� s � ��y�y�r' c � � dddd�}||j � vr t d� �| gg}g g}||k7 rZ|dd }|D ]J }|d j | j � }|D ]# }||vs�||gz } | |vs�|j | � �% �L ||k7 r�Z|D ] } | d |k7 s� |j | � � |j t �� t
|� d k7 r|d S d
}
t |
j || | j |j � � �) a� Returns an inclusive list of reference frames that connect this
reference frame to the provided reference frame.
Parameters
==========
other : ReferenceFrame
The other reference frame to look for a connecting relationship to.
num : integer
``0``, ``1``, and ``2`` will look for orientation, angular
velocity, and angular acceleration relationships between the two
frames, respectively.
Returns
=======
list
Inclusive list of reference frames that connect this reference
frame to the other reference frame.
Examples
========
>>> from sympy.physics.vector import ReferenceFrame
>>> A = ReferenceFrame('A')
>>> B = ReferenceFrame('B')
>>> C = ReferenceFrame('C')
>>> D = ReferenceFrame('D')
>>> B.orient_axis(A, A.x, 1.0)
>>> C.orient_axis(B, B.x, 1.0)
>>> D.orient_axis(C, C.x, 1.0)
>>> D._dict_list(A, 0)
[D, C, B, A]
Raises
======
ValueError
When no path is found between the two reference frames or ``num``
is an incorrect value.
� orientationzangular velocityzangular acceleration)r r5 r? z$Valid values for num are 0, 1, or 2.N���)�keyr z.No connecting {} path found between {} and {}.) �keysr rY �append�remove�sortrN �formatr ) r* r. �num� connect_type�possible_connecting_paths�oldlist�
frame_list�frames_adjacent_to_last�adjacent_frame�connecting_path�msgs r% �
_dict_listzReferenceFrame._dict_list sQ � �T )�-�1�3� � �l�'�'�)� )� � C�D� D�&*�V�H�!��$��'�7�2�/��2�G� 7�
N�
�*4�R�.�*?�*?��*D�*I�*I�*K�'�&=� N�N�%�Z�7�*4��7G�*G��*�2K�K� 5� <� <�_� M� N�
N� (�7�2� '� B�O� �r�"�e�+�)�0�0� �A� B� "�&�&�3�&�/� �(� )�Q� .�,�Q�/� /�>������L��$5�t�y�y�%�*�*�M�N�Nr' c �N � ddl m} |j | � }|j |j � }||j
z }t
t |d � d�� }t
t |d � d�� }t
t |d � d�� }t t |||g� |fg� S )z4Angular velocity from time differentiating the DCM. r ��dynamicsymbols� T)� recursiver? r )
� sympy.physics.vector.functionsr �dcmr �_t�Tr
r r r[ ) r* �
otherframer �dcm2diff�diffed� angvelmat�w1�w2�w3s r% � _w_diff_dcmzReferenceFrame._w_diff_dcmJ s� � �A� �>�>�$�'��� � �~� 0� 0�1���X�Z�Z�'� �
�f�Y�q�\�*�d�
;��
�f�Y�q�\�*�d�
;��
�f�Y�q�\�*�d�
;�����B��|�,�j�9�:�;�;r' c �� � t |� |t j f| j v r | j |t j f S | j |� t |j � z }i }t | � D ]K \ }}t j r!t || d�� || j | < �7|| || j | < �M || j |t j f< |S )a4
Returns a dictionary which expresses the coordinate variables
of this frame in terms of the variables of otherframe.
If Vector.simp is True, returns a simplified version of the mapped
values. Else, returns them without simplification.
Simplification of the expressions may take time.
Parameters
==========
otherframe : ReferenceFrame
The other frame to map the variables to
Examples
========
>>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
>>> A = ReferenceFrame('A')
>>> q = dynamicsymbols('q')
>>> B = A.orientnew('B', 'Axis', [q, A.z])
>>> A.variable_map(B)
{A_x: B_x*cos(q(t)) - B_y*sin(q(t)), A_y: B_x*sin(q(t)) + B_y*cos(q(t)), A_z: B_z}
�fu)�method) r r �simprT r� r[ r\ � enumerater
)r* r� � vars_matrix�mappingr` rD s r% � variable_mapzReferenceFrame.variable_mapU s� � �8 �Z� � �� � � $���� 6��>�>�:�v�{�{�";�<� <� �(�(�:�.��
�8J�8J�1K�K�K��G�!�$��
>���1��;�;�/7� �A��?C�0E�G�D�L�L��O�,� 0;�1�~�G�D�L�L��O�,�
>� 9@�D�N�N�J�� � �4� 5��Nr' c � � t |� || j v r| j | S | j |� j |� S )a� Returns the angular acceleration Vector of the ReferenceFrame.
Effectively returns the Vector:
``N_alpha_B``
which represent the angular acceleration of B in N, where B is self,
and N is otherframe.
Parameters
==========
otherframe : ReferenceFrame
The ReferenceFrame which the angular acceleration is returned in.
Examples
========
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_acc(N, V)
>>> A.ang_acc_in(N)
10*N.x
)r rX �
ang_vel_in�dt)r* r� s r% �
ang_acc_inzReferenceFrame.ang_acc_in� sE � �: �Z� � ��+�+� +��%�%�j�1� 1��?�?�:�.�1�1�*�=� =r' c �� � t |� | j |d� }t d� }t t |� dz
� D ] }||| j
||dz z
}� |S )a� Returns the angular velocity Vector of the ReferenceFrame.
Effectively returns the Vector:
^N omega ^B
which represent the angular velocity of B in N, where B is self, and
N is otherframe.
Parameters
==========
otherframe : ReferenceFrame
The ReferenceFrame which the angular velocity is returned in.
Examples
========
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_vel(N, V)
>>> A.ang_vel_in(N)
10*N.x
r5 r )r r| r r rN rW )r* r� �flist�outvecr` s r% r� zReferenceFrame.ang_vel_in� sg � �: �Z� ����
�A�.�������s�5�z�A�~�&� ;�A� �e�A�h�,�,�U�1�q�5�\�:� :�F� ;��
r' c �N � t |� || j v r| j | S | j |d� }t d� }t t |� dz
� D ] }||| j ||dz z }� || j |< |j |j | < |S )a� Returns the direction cosine matrix of this reference frame
relative to the provided reference frame.
The returned matrix can be used to express the orthogonal unit vectors
of this frame in terms of the orthogonal unit vectors of
``otherframe``.
Parameters
==========
otherframe : ReferenceFrame
The reference frame which the direction cosine matrix of this frame
is formed relative to.
Examples
========
The following example rotates the reference frame A relative to N by a
simple rotation and then calculates the direction cosine matrix of N
relative to A.
>>> from sympy import symbols, sin, cos
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> A.orient_axis(N, q1, N.x)
>>> N.dcm(A)
Matrix([
[1, 0, 0],
[0, cos(q1), -sin(q1)],
[0, sin(q1), cos(q1)]])
The second row of the above direction cosine matrix represents the
``N.y`` unit vector in N expressed in A. Like so:
>>> Ny = 0*A.x + cos(q1)*A.y - sin(q1)*A.z
Thus, expressing ``N.y`` in A should return the same result:
>>> N.y.express(A)
cos(q1)*A.y - sin(q1)*A.z
Notes
=====
It is important to know what form of the direction cosine matrix is
returned. If ``B.dcm(A)`` is called, it means the "direction cosine
matrix of B rotated relative to A". This is the matrix
:math:`{}^B\mathbf{C}^A` shown in the following relationship:
.. math::
\begin{bmatrix}
\hat{\mathbf{b}}_1 \\
\hat{\mathbf{b}}_2 \\
\hat{\mathbf{b}}_3
\end{bmatrix}
=
{}^B\mathbf{C}^A
\begin{bmatrix}
\hat{\mathbf{a}}_1 \\
\hat{\mathbf{a}}_2 \\
\hat{\mathbf{a}}_3
\end{bmatrix}.
:math:`{}^B\mathbf{C}^A` is the matrix that expresses the B unit
vectors in terms of the A unit vectors.
r r r5 )r rV r| r r rN rU r� )r* r� r� �outdcmr` s r% r� zReferenceFrame.dcm� s� � �P �Z� � �� � � (��?�?�:�.� .����
�A�.���Q����s�5�z�A�~�&� ?�A��e�A�h� 0� 0��q�1�u� � >�>�F� ?� '-����
�#�&,�h�h�
� � �d�#��
r' c �. � | j j � }g }g }||v rg|D ] }|| j v r||gz
}||gz
}� |D ] }|j | = � |D ] }|j | = � i x| _ | j d< i | _ n�g }t |� }d} |rs| rq|j d� }
|
|vrW|j
|
� |
j j � } | D ]' } | |k( rt d� d} n|j
| � �) |r| r�q| j j ||j i� |j j | |i� | j j ||j i� |j j | |i� y )Nr TzxLoops are defined among the orientation of frames. This is likely not desired and may cause errors in your calculations.F)
rV rn rU rY rM �popro r �updater� )
r* �parent�
parent_orient�frames� dcm_dict_del�
dcm_cache_delr �visited�queue�cont�node� neighbors�neighbors
r% �_dcmzReferenceFrame._dcm s� � � � � �%�%�'��� ��
� �V� � �
)���D�N�N�*� �U�G�+�L� �%��(�
�
)� &�
*���O�O�D�)�
*�&�
+���$�$�T�*�
+� /1� 0�D�N�T�[�[��^� �D�O� �G���L�E��D��D� �y�y��|���w�&��N�N�4�(� $��� 3� 3� 5�I�$-� /��#�v�-� � "F� G� $)�D� !� � � �X�.�/� �D�
��� � �v�}��� 7�8���� � ��}� 5�6� ��� � ��
��� 8�9���� � �$�
�!6�7r' c �< � ddl m} t |� t |t � st |t � r||}}t |� }t
|� }|j |� dk( s t d� �|j |� j � }|j d d }t d� ||j z z
t |� z t d|d |d g|d d|d g|d |d dgg� t! |� z z ||j z z }| j# ||� |j% |j& � } | |j |� j � z }
| j( j+ ||
i� |j( j+ | |
i� i | _ y)aZ Sets the orientation of this reference frame with respect to a
parent reference frame by rotating through an angle about an axis fixed
in the parent reference frame.
Parameters
==========
parent : ReferenceFrame
Reference frame that this reference frame will be rotated relative
to.
axis : Vector
Vector fixed in the parent frame about about which this frame is
rotated. It need not be a unit vector and the rotation follows the
right hand rule.
angle : sympifiable
Angle in radians by which it the frame is to be rotated.
Warns
======
UserWarning
If the orientation creates a kinematic loop.
Examples
========
Setup variables for the examples:
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B.orient_axis(N, N.x, q1)
The ``orient_axis()`` method generates a direction cosine matrix and
its transpose which defines the orientation of B relative to N and vice
versa. Once orient is called, ``dcm()`` outputs the appropriate
direction cosine matrix:
>>> B.dcm(N)
Matrix([
[1, 0, 0],
[0, cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])
>>> N.dcm(B)
Matrix([
[1, 0, 0],
[0, cos(q1), -sin(q1)],
[0, sin(q1), cos(q1)]])
The following two lines show that the sense of the rotation can be
defined by negating the vector direction or the angle. Both lines
produce the same result.
>>> B.orient_axis(N, -N.x, q1)
>>> B.orient_axis(N, N.x, -q1)
r r~ z Axis cannot be time-varying.r r? r5 N)r� r r r, r r r r� r �express� normalize�argsr r� r r[ r r� r r� rW r� rT ) r* r� �axis�angler �theta� unit_axis�unit_col�parent_orient_axis�thetad�wvecs r% � orient_axiszReferenceFrame.orient_axisR s� � �z B��V� ��$��'�J�u�f�,E� ��%�D� �T�"�������w�w�v��!�#� � ;�<� <��L�L��(�2�2�4� � �>�>�!�$�Q�'��
��V�h����+�
+�s�5�z� 9� �Q��!�� �h�q�k�2� �a�[�!�h�q�k�\�2� �q�k�\�8�A�;��2�4�
5�
��J�
�
� "�H�J�J�.�
/� �
� � �&�,�-�� � �n� /� /�0���d�l�l�6�*�4�4�6�6�� ���!�!�6�4�.�1�� � �#�#�T�D�5�M�2���r' c � � t |� t |t � s t d� �|}| j ||� | j |� }| j j ||i� |j j | | i� i | _ y)a� Sets the orientation of this reference frame relative to a parent
reference frame by explicitly setting the direction cosine matrix.
Parameters
==========
parent : ReferenceFrame
Reference frame that this reference frame will be rotated relative
to.
dcm : Matrix, shape(3, 3)
Direction cosine matrix that specifies the relative rotation
between the two reference frames.
Warns
======
UserWarning
If the orientation creates a kinematic loop.
Examples
========
Setup variables for the examples:
>>> from sympy import symbols, Matrix, sin, cos
>>> from sympy.physics.vector import ReferenceFrame
>>> q1 = symbols('q1')
>>> A = ReferenceFrame('A')
>>> B = ReferenceFrame('B')
>>> N = ReferenceFrame('N')
A simple rotation of ``A`` relative to ``N`` about ``N.x`` is defined
by the following direction cosine matrix:
>>> dcm = Matrix([[1, 0, 0],
... [0, cos(q1), -sin(q1)],
... [0, sin(q1), cos(q1)]])
>>> A.orient_explicit(N, dcm)
>>> A.dcm(N)
Matrix([
[1, 0, 0],
[0, cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])
This is equivalent to using ``orient_axis()``:
>>> B.orient_axis(N, N.x, q1)
>>> B.dcm(N)
Matrix([
[1, 0, 0],
[0, cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])
**Note carefully that** ``N.dcm(B)`` **(the transpose) would be passed
into** ``orient_explicit()`` **for** ``A.dcm(N)`` **to match**
``B.dcm(N)``:
>>> A.orient_explicit(N, N.dcm(B))
>>> A.dcm(N)
Matrix([
[1, 0, 0],
[0, cos(q1), sin(q1)],
[0, -sin(q1), cos(q1)]])
z+Amounts must be a SymPy Matrix type object.N) r r, r rK r� r� rW r� rT )r* r� r� �parent_orient_dcmr� s r% �orient_explicitz ReferenceFrame.orient_explicit� s� � �F �V� � �#�z�*�� I�J� J� �� � � �&�+�,�� � ��'�� ���!�!�6�4�.�1�� � �#�#�T�D�5�M�2���r' c � � |dk( r;t g d�dt |� t |� gdt |� t |� gg� S |dk( r;t t |� dt |� gg d�t |� dt |� gg� S |dk( r;t t |� t |� dgt |� t |� dgg d�g� S y) z'DCM for simple axis 1,2,or 3 rotations.r5 rG r r? rH r rI N)r[ r r )r* r� r� s r% �_rotzReferenceFrame._rot� s� � � �1�9��9� �s�5�z�C��J�;�7� �s�5�z�3�u�:�6�8� 9�
9� �Q�Y��C��J��3�u�:�6�$� ��Z�K��C��J�7�9� :�
:� �Q�Y��C��J��U�� �Q�7� ��J��E�
�A�6�$�&� '�
'� r' c �� � t |� }t |� D ]$ \ }}t |t � r�t |� ||< �& d}t t
|� dd� }||vr t d� �|D �cg c]
}t |� �� }}t |� dt |� z cxk( rdk( st d� � t d� �t ||� D � �
cg c] \ } }
| j | |
� �� } } }
||| fS c c}w c c}
} w )a Helper for orient_body_fixed and orient_space_fixed.
Parameters
==========
angles : 3-tuple of sympifiable
Three angles in radians used for the successive rotations.
rotation_order : 3 character string or 3 digit integer
Order of the rotations. The order can be specified by the strings
``'XZX'``, ``'131'``, or the integer ``131``. There are 12 unique
valid rotation orders.
Returns
=======
amounts : list
List of sympifiables corresponding to the rotation angles.
rot_order : list
List of integers corresponding to the axis of rotation.
rot_matrices : list
List of DCM around the given axis with corresponding magnitude.
�
�123�231�312�132�213�321�121�131�212�232�313�323� �XYZxyz�123123z(The rotation order is not a valid order.r z*Body orientation takes 3 values & 3 orders) rM r� r, r r r rJ rK �intrN �zipr� ) r* �angles�rotation_order�amountsr` �v�approved_orders� rot_order�r�order�amount� rot_matricess r% � _parse_consecutive_rotationsz+ReferenceFrame._parse_consecutive_rotations s � �. �v�,�� �g�&� (�D�A�q� �a��(� $�Q�Z���
� (�B�� �c�.� 1�8�X�F� � �O� +�� F�G� G�%.�/��S��V�/� �/��G� ��C� �N� 2�7�a�7�� H�I� I� 8�� H�I� I�/2�9�g�/F�H� +�U�F� � � �%��0� H� � H�� �<�/�/�� 0��Hs �)C'� C,c � � ddl m} t |� | j ||� \ }}}| j ||d |d z |d z � t d� D �cg c] }t
dd� �� } }t |� D ], \ }
} ||
j |j � | |
| dz
< �. | d |d j | d |d j | d z z z z \ } }
}| | j z |
| j z z || j z z }| j j ||i� |j j | | i� i | _ yc c}w )a, Rotates this reference frame relative to the parent reference frame
by right hand rotating through three successive body fixed simple axis
rotations. Each subsequent axis of rotation is about the "body fixed"
unit vectors of a new intermediate reference frame. This type of
rotation is also referred to rotating through the `Euler and Tait-Bryan
Angles`_.
.. _Euler and Tait-Bryan Angles: https://en.wikipedia.org/wiki/Euler_angles
The computed angular velocity in this method is by default expressed in
the child's frame, so it is most preferable to use ``u1 * child.x + u2 *
child.y + u3 * child.z`` as generalized speeds.
Parameters
==========
parent : ReferenceFrame
Reference frame that this reference frame will be rotated relative
to.
angles : 3-tuple of sympifiable
Three angles in radians used for the successive rotations.
rotation_order : 3 character string or 3 digit integer
Order of the rotations about each intermediate reference frames'
unit vectors. The Euler rotation about the X, Z', X'' axes can be
specified by the strings ``'XZX'``, ``'131'``, or the integer
``131``. There are 12 unique valid rotation orders (6 Euler and 6
Tait-Bryan): zxz, xyx, yzy, zyz, xzx, yxy, xyz, yzx, zxy, xzy, zyx,
and yxz.
Warns
======
UserWarning
If the orientation creates a kinematic loop.
Examples
========
Setup variables for the examples:
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1, q2, q3 = symbols('q1, q2, q3')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B1 = ReferenceFrame('B1')
>>> B2 = ReferenceFrame('B2')
>>> B3 = ReferenceFrame('B3')
For example, a classic Euler Angle rotation can be done by:
>>> B.orient_body_fixed(N, (q1, q2, q3), 'XYX')
>>> B.dcm(N)
Matrix([
[ cos(q2), sin(q1)*sin(q2), -sin(q2)*cos(q1)],
[sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
[sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])
This rotates reference frame B relative to reference frame N through
``q1`` about ``N.x``, then rotates B again through ``q2`` about
``B.y``, and finally through ``q3`` about ``B.x``. It is equivalent to
three successive ``orient_axis()`` calls:
>>> B1.orient_axis(N, N.x, q1)
>>> B2.orient_axis(B1, B1.y, q2)
>>> B3.orient_axis(B2, B2.x, q3)
>>> B3.dcm(N)
Matrix([
[ cos(q2), sin(q1)*sin(q2), -sin(q2)*cos(q1)],
[sin(q2)*sin(q3), -sin(q1)*sin(q3)*cos(q2) + cos(q1)*cos(q3), sin(q1)*cos(q3) + sin(q3)*cos(q1)*cos(q2)],
[sin(q2)*cos(q3), -sin(q1)*cos(q2)*cos(q3) - sin(q3)*cos(q1), -sin(q1)*sin(q3) + cos(q1)*cos(q2)*cos(q3)]])
Acceptable rotation orders are of length 3, expressed in as a string
``'XYZ'`` or ``'123'`` or integer ``123``. Rotations about an axis
twice in a row are prohibited.
>>> B.orient_body_fixed(N, (q1, q2, 0), 'ZXZ')
>>> B.orient_body_fixed(N, (q1, q2, 0), '121')
>>> B.orient_body_fixed(N, (q1, q2, q3), 123)
r r~ r5 r? r N�r� r r r� r� r r r� r r� r� rD rE rF rW r� rT �r* r� r� r� r r� r� r� r@ �rot_vecsr` r� �u1�u2�u3r� s r% �orient_body_fixedz ReferenceFrame.orient_body_fixed6 sV � �d B��V� �+/�+L�+L� �N�,$�(���L� � � �&�,�q�/�L��O�;�l�1�o�M�N�).�q��2�A�E�!�Q�K�2��2�!�)�,� H�H�A�u�%,�Q�Z�_�_�^�5F�5F�%G�H�Q�K��� � "� H� �a�[�<��?�#4�#4� �Q�K�,�q�/�+�+�h�q�k�9� 9�$;� ;�
��B���D�F�F�{�R�$�&�&�[�(�2����;�6�� ���!�!�6�4�.�1�� � �#�#�T�D�5�M�2����� 3� �E c � � ddl m} t |� | j ||� \ }}}| j ||d |d z |d z � t d� D �cg c] }t
dd� �� } }t |� D ], \ }
} ||
j |j � | |
| dz
< �. | d |d j | d |d j | d z z z z \ } }
}| | j z |
| j z z || j z z }| j j ||i� |j j | | i� i | _ yc c}w )a[ Rotates this reference frame relative to the parent reference frame
by right hand rotating through three successive space fixed simple axis
rotations. Each subsequent axis of rotation is about the "space fixed"
unit vectors of the parent reference frame.
The computed angular velocity in this method is by default expressed in
the child's frame, so it is most preferable to use ``u1 * child.x + u2 *
child.y + u3 * child.z`` as generalized speeds.
Parameters
==========
parent : ReferenceFrame
Reference frame that this reference frame will be rotated relative
to.
angles : 3-tuple of sympifiable
Three angles in radians used for the successive rotations.
rotation_order : 3 character string or 3 digit integer
Order of the rotations about the parent reference frame's unit
vectors. The order can be specified by the strings ``'XZX'``,
``'131'``, or the integer ``131``. There are 12 unique valid
rotation orders.
Warns
======
UserWarning
If the orientation creates a kinematic loop.
Examples
========
Setup variables for the examples:
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q1, q2, q3 = symbols('q1, q2, q3')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
>>> B1 = ReferenceFrame('B1')
>>> B2 = ReferenceFrame('B2')
>>> B3 = ReferenceFrame('B3')
>>> B.orient_space_fixed(N, (q1, q2, q3), '312')
>>> B.dcm(N)
Matrix([
[ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
[-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
[ sin(q3)*cos(q2), -sin(q2), cos(q2)*cos(q3)]])
is equivalent to:
>>> B1.orient_axis(N, N.z, q1)
>>> B2.orient_axis(B1, N.x, q2)
>>> B3.orient_axis(B2, N.y, q3)
>>> B3.dcm(N).simplify()
Matrix([
[ sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3), sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1)],
[-sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1), cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3)],
[ sin(q3)*cos(q2), -sin(q2), cos(q2)*cos(q3)]])
It is worth noting that space-fixed and body-fixed rotations are
related by the order of the rotations, i.e. the reverse order of body
fixed will give space fixed and vice versa.
>>> B.orient_space_fixed(N, (q1, q2, q3), '231')
>>> B.dcm(N)
Matrix([
[cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
[ -sin(q2), cos(q2)*cos(q3), sin(q3)*cos(q2)],
[sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])
>>> B.orient_body_fixed(N, (q3, q2, q1), '132')
>>> B.dcm(N)
Matrix([
[cos(q1)*cos(q2), sin(q1)*sin(q3) + sin(q2)*cos(q1)*cos(q3), -sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1)],
[ -sin(q2), cos(q2)*cos(q3), sin(q3)*cos(q2)],
[sin(q1)*cos(q2), sin(q1)*sin(q2)*cos(q3) - sin(q3)*cos(q1), sin(q1)*sin(q2)*sin(q3) + cos(q1)*cos(q3)]])
r r~ r? r5 r Nr� r� s r% �orient_space_fixedz!ReferenceFrame.orient_space_fixed� sV � �` B��V� �+/�+L�+L� �N�,$�(���L� � � �&�,�q�/�L��O�;�l�1�o�M�N�).�q��2�A�E�!�Q�K�2��2�!�)�,� H�H�A�u�%,�Q�Z�_�_�^�5F�5F�%G�H�Q�K��� � "� H� �a�[�<��?�#4�#4� �Q�K�,�q�/�+�+�h�q�k�9� 9�$;� ;�
��B���D�F�F�{�R�$�&�&�[�(�2����;�6�� ���!�!�6�4�.�1�� � �#�#�T�D�5�M�2����� 3r� c �H � ddl m} t |� t |� }t |� D ]$ \ }}t |t � r�t |� ||< �& t |t t f� t |� dk( z s t d� �|\ }}}} t |dz |dz z |dz z
| dz z
d||z || z z
z d||z || z z z gd||z || z z z |dz |dz z
|dz z | dz z
d|| z ||z z
z gd|| z ||z z
z d||z || z z z |dz |dz z
|dz z
| dz z gg� }
| j ||
� |j } |\ }}}} t || � } t || � }
t || � }t | | � }d|
|z || z z ||z z
| |z z
z }d||z ||z z |
| z z
| |z z
z }d||z |
|z z ||z z
| | z z
z }t
t |||g� | fg� }| j j! ||i� |j j! | | i� i | _ y)a Sets the orientation of this reference frame relative to a parent
reference frame via an orientation quaternion. An orientation
quaternion is defined as a finite rotation a unit vector, ``(lambda_x,
lambda_y, lambda_z)``, by an angle ``theta``. The orientation
quaternion is described by four parameters:
- ``q0 = cos(theta/2)``
- ``q1 = lambda_x*sin(theta/2)``
- ``q2 = lambda_y*sin(theta/2)``
- ``q3 = lambda_z*sin(theta/2)``
See `Quaternions and Spatial Rotation
<https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation>`_ on
Wikipedia for more information.
Parameters
==========
parent : ReferenceFrame
Reference frame that this reference frame will be rotated relative
to.
numbers : 4-tuple of sympifiable
The four quaternion scalar numbers as defined above: ``q0``,
``q1``, ``q2``, ``q3``.
Warns
======
UserWarning
If the orientation creates a kinematic loop.
Examples
========
Setup variables for the examples:
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame
>>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')
Set the orientation:
>>> B.orient_quaternion(N, (q0, q1, q2, q3))
>>> B.dcm(N)
Matrix([
[q0**2 + q1**2 - q2**2 - q3**2, 2*q0*q3 + 2*q1*q2, -2*q0*q2 + 2*q1*q3],
[ -2*q0*q3 + 2*q1*q2, q0**2 - q1**2 + q2**2 - q3**2, 2*q0*q1 + 2*q2*q3],
[ 2*q0*q2 + 2*q1*q3, -2*q0*q1 + 2*q2*q3, q0**2 - q1**2 - q2**2 + q3**2]])
r r~ � z'Amounts are a list or tuple of length 4r? N)r� r r rM r� r, r r rL rN rK r[ r� r� r rW r� rT )r* r� �numbersr r` r� �q0�q1�q2�q3�parent_orient_quaternion�t�q0d�q1d�q2d�q3dr� r� r� r� s r% �orient_quaternionz ReferenceFrame.orient_quaternion� s� � �j B��V� ��w�-�� �g�&� (�D�A�q� �a��(� $�Q�Z���
� (� �7�T�5�M�2�c�'�l�a�6G�H�� E�F� F� ���B��B� �R��U�R��U�]�R��U�*�R��U�2��"�r�'�B��G�+�,��"�r�'�B��G�+�,�.� �"�r�'�B��G�+�,���U�R��U�]�R��U�*�R��U�2��"�r�'�B��G�+�,�.� �"�r�'�B��G�+�,��"�r�'�B��G�+�,���U�R��U�]�R��U�*�R��U�2�4�
5�
6� !�
� � �&�2�3� � � �� ���B��B��2�q�k���2�q�k���2�q�k���2�q�k��
�#��(�S�2�X�%��b��0�3��8�;�
<��
�#��(�S�2�X�%��b��0�3��8�;�
<��
�#��(�S�2�X�%��b��0�3��8�;�
<�����B��|�,�d�3�4�5�� ���!�!�6�4�.�1�� � �#�#�T�D�5�M�2���r' c � � t |� d}t t |� dd� }|j � }||vr t d� �|dk( r| j ||d |d � y
|dk( r| j
||� y
|d k( r| j |||� y
|d
k( r| j |||� y
|d k( r| j ||� y
t d � �)a� Sets the orientation of this reference frame relative to another
(parent) reference frame.
.. note:: It is now recommended to use the ``.orient_axis,
.orient_body_fixed, .orient_space_fixed, .orient_quaternion``
methods for the different rotation types.
Parameters
==========
parent : ReferenceFrame
Reference frame that this reference frame will be rotated relative
to.
rot_type : str
The method used to generate the direction cosine matrix. Supported
methods are:
- ``'Axis'``: simple rotations about a single common axis
- ``'DCM'``: for setting the direction cosine matrix directly
- ``'Body'``: three successive rotations about new intermediate
axes, also called "Euler and Tait-Bryan angles"
- ``'Space'``: three successive rotations about the parent
frames' unit vectors
- ``'Quaternion'``: rotations defined by four parameters which
result in a singularity free direction cosine matrix
amounts :
Expressions defining the rotation angles or direction cosine
matrix. These must match the ``rot_type``. See examples below for
details. The input types are:
- ``'Axis'``: 2-tuple (expr/sym/func, Vector)
- ``'DCM'``: Matrix, shape(3,3)
- ``'Body'``: 3-tuple of expressions, symbols, or functions
- ``'Space'``: 3-tuple of expressions, symbols, or functions
- ``'Quaternion'``: 4-tuple of expressions, symbols, or
functions
rot_order : str or int, optional
If applicable, the order of the successive of rotations. The string
``'123'`` and integer ``123`` are equivalent, for example. Required
for ``'Body'`` and ``'Space'``.
Warns
======
UserWarning
If the orientation creates a kinematic loop.
r� r� r� �*The supplied order is not an approved type�AXISr5 r �DCM�BODY�SPACE�
QUATERNION�#That is not an implemented rotationN) r r rJ �upperrK r� r� r� r� r� �NotImplementedError)r* r� �rot_typer� r� r� s r% �orientzReferenceFrame.orientX s� � �h �V� �B�� �c�)�n�h��A� ��>�>�#�� �O� +�� H�I� I� �v� � � � �V�W�Q�Z���� <�
��
� � � ��� 1�
��
� � "� "�6�7�I� >�
��
� � #� #�F�G�Y� ?�
� �
%� � "� "�6�7� 3� &�&K�L� Lr' c � � | j ||||�� }d} t t |� dd� }|j � }|| vr t d� �|dk( r|j | |d |d � |S |d k( r|j
| |� |S |d
k( r|j | ||� |S |d k( r|j | ||� |S |d k( r|j | |� |S t d
� �)al Returns a new reference frame oriented with respect to this
reference frame.
See ``ReferenceFrame.orient()`` for detailed examples of how to orient
reference frames.
Parameters
==========
newname : str
Name for the new reference frame.
rot_type : str
The method used to generate the direction cosine matrix. Supported
methods are:
- ``'Axis'``: simple rotations about a single common axis
- ``'DCM'``: for setting the direction cosine matrix directly
- ``'Body'``: three successive rotations about new intermediate
axes, also called "Euler and Tait-Bryan angles"
- ``'Space'``: three successive rotations about the parent
frames' unit vectors
- ``'Quaternion'``: rotations defined by four parameters which
result in a singularity free direction cosine matrix
amounts :
Expressions defining the rotation angles or direction cosine
matrix. These must match the ``rot_type``. See examples below for
details. The input types are:
- ``'Axis'``: 2-tuple (expr/sym/func, Vector)
- ``'DCM'``: Matrix, shape(3,3)
- ``'Body'``: 3-tuple of expressions, symbols, or functions
- ``'Space'``: 3-tuple of expressions, symbols, or functions
- ``'Quaternion'``: 4-tuple of expressions, symbols, or
functions
rot_order : str or int, optional
If applicable, the order of the successive of rotations. The string
``'123'`` and integer ``123`` are equivalent, for example. Required
for ``'Body'`` and ``'Space'``.
indices : tuple of str
Enables the reference frame's basis unit vectors to be accessed by
Python's square bracket indexing notation using the provided three
indice strings and alters the printing of the unit vectors to
reflect this choice.
latexs : tuple of str
Alters the LaTeX printing of the reference frame's basis unit
vectors to the provided three valid LaTeX strings.
Examples
========
>>> from sympy import symbols
>>> from sympy.physics.vector import ReferenceFrame, vlatex
>>> q0, q1, q2, q3 = symbols('q0 q1 q2 q3')
>>> N = ReferenceFrame('N')
Create a new reference frame A rotated relative to N through a simple
rotation.
>>> A = N.orientnew('A', 'Axis', (q0, N.x))
Create a new reference frame B rotated relative to N through body-fixed
rotations.
>>> B = N.orientnew('B', 'Body', (q1, q2, q3), '123')
Create a new reference frame C rotated relative to N through a simple
rotation with unique indices and LaTeX printing.
>>> C = N.orientnew('C', 'Axis', (q0, N.x), indices=('1', '2', '3'),
... latexs=(r'\hat{\mathbf{c}}_1',r'\hat{\mathbf{c}}_2',
... r'\hat{\mathbf{c}}_3'))
>>> C['1']
C['1']
>>> print(vlatex(C['1']))
\hat{\mathbf{c}}_1
)r_ rS r^ r� r� r� r� r� r5 r r� r� r� r� r� ) r$ r rJ r� rK r� r� r� r� r� r )
r* �newnamer r� r� r_ rS r^ �newframer� s
r% � orientnewzReferenceFrame.orientnew� s � �d �>�>�'�Y�*1�&� "� B��B�� �c�)�n�h��A� ��>�>�#�� �O� +�� H�I� I� �v� � � � ��w�q�z�7�1�:� >� �� ��
� � $� $�T�7� 3� �� ��
� � &� &�t�W�i� @� �� ��
� � '� '��g�y� A� �� � �
%� � &� &�t�W� 5� �� &�&K�L� Lr' c �� � |dk( r t d� }t |� }t |� | j j ||i� |j j | | i� y)a- Define the angular acceleration Vector in a ReferenceFrame.
Defines the angular acceleration of this ReferenceFrame, in another.
Angular acceleration can be defined with respect to multiple different
ReferenceFrames. Care must be taken to not create loops which are
inconsistent.
Parameters
==========
otherframe : ReferenceFrame
A ReferenceFrame to define the angular acceleration in
value : Vector
The Vector representing angular acceleration
Examples
========
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_acc(N, V)
>>> A.ang_acc_in(N)
10*N.x
r N)r r r rX r� �r* r� �values r% � set_ang_acczReferenceFrame.set_ang_acc �Y � �: �A�:��1�I�E� �e�$���Z� � ���!�!�:�u�"5�6�� � �'�'���v��7r' c �� � |dk( r t d� }t |� }t |� | j j ||i� |j j | | i� y)a Define the angular velocity vector in a ReferenceFrame.
Defines the angular velocity of this ReferenceFrame, in another.
Angular velocity can be defined with respect to multiple different
ReferenceFrames. Care must be taken to not create loops which are
inconsistent.
Parameters
==========
otherframe : ReferenceFrame
A ReferenceFrame to define the angular velocity in
value : Vector
The Vector representing angular velocity
Examples
========
>>> from sympy.physics.vector import ReferenceFrame
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_vel(N, V)
>>> A.ang_vel_in(N)
10*N.x
r N)r r r rW r� r s r% � set_ang_velzReferenceFrame.set_ang_vel< r r' c � � | j S )z=The basis Vector for the ReferenceFrame, in the x direction. )rA r) s r% rD zReferenceFrame.x` �
� � �w�w�r' c � � | j S )z=The basis Vector for the ReferenceFrame, in the y direction. )rB r) s r% rE zReferenceFrame.ye r r' c � � | j S )z=The basis Vector for the ReferenceFrame, in the z direction. )rC r) s r% rF zReferenceFrame.zj r r' c � � |D �cg c]% }| j |� j ||d�� ��' }}t |� dk( r|d S t |� S c c}w )a� Returns the partial angular velocities of this frame in the given
frame with respect to one or more provided generalized speeds.
Parameters
==========
frame : ReferenceFrame
The frame with which the angular velocity is defined in.
gen_speeds : functions of time
The generalized speeds.
Returns
=======
partial_velocities : tuple of Vector
The partial angular velocity vectors corresponding to the provided
generalized speeds.
Examples
========
>>> from sympy.physics.vector import ReferenceFrame, dynamicsymbols
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> u1, u2 = dynamicsymbols('u1, u2')
>>> A.set_ang_vel(N, u1 * A.x + u2 * N.y)
>>> A.partial_velocity(N, u1)
A.x
>>> A.partial_velocity(N, u1, u2)
(A.x, N.y)
F)�
var_in_dcmr5 r )r� r rN rL )r* r �
gen_speeds�speed�partialss r% �partial_velocityz ReferenceFrame.partial_velocityo sd � �B ",�-� � �O�O�E�*�/�/��u��/�O� -�� -� �x�=�A� ��A�;� ���?� "��
-s �*A)NNN)r� )r� NNN)!r7 r8 r9 r: r] ra rd rg ri �__repr__r| r� r� r� r� r� r� r� r� r� r� r� r� r� r r r
r
r; rD rE rF r r2 r' r% r r R s� � � � �F�A+�F4�*.�� �H�FO�P <�)�V!>�F"�HT�l38�jW �rP �d
'� (0�Tb �H` �DZ �xNM�` ?A�7;�n�`"8�H"8�H �� �� �� �� �� ��&#r' c �T � ddl m} t | t � s || t d� � �y )Nr5 )�VectorTypeError�A)�vectorr r, r )r. r s r% r r � s& � �'� �e�^� ,� �e�^�C�%8�9�9� -r' N)�sympy.core.backendr r r r r r r r
r[ r �sympy.core.symbolr �sympy.simplify.trigsimpr
�sympy.physics.vector.vectorr r �sympy.utilities.miscr �warningsr �__all__r r r r2 r' r% �<module>r$ sT ��G� G� G� $� ,� =� *� � � ,�
-��B@�F� B@�JC#� C#�L*:r'