



def       lowerCamelCase_  (    _a       :						list[int]    ):



    '''simple docstring'''




    if len(_a    ) > 1:
        UpperCAmelCase_     :       Any  		=					len(_a    ) // 2  # Finds the middle of the array
        UpperCAmelCase_     :       Tuple  		=					arr[
            :middle_length
        ]  # Creates an array of the elements in the first half.
        UpperCAmelCase_     :       int  		=					arr[
            middle_length:
        ]  # Creates an array of the elements in the second half.
        UpperCAmelCase_     :       Dict  		=					len(_a    )
        UpperCAmelCase_     :       str  		=					len(_a    )
        merge(_a    )  # Starts sorting the left.
        merge(_a    )  # Starts sorting the right
        UpperCAmelCase_     :       List[str]  		=					0  # Left Counter
        UpperCAmelCase_     :       Tuple  		=					0  # Right Counter
        UpperCAmelCase_     :       str  		=					0  # Position Counter
        while (
            left_index < left_size and right_index < right_size
        ):  # Runs until the lowers size of the left and right are sorted.
            if left_array[left_index] < right_array[right_index]:
                UpperCAmelCase_     :       Tuple  		=					left_array[left_index]
                left_index += 1
            else:
                UpperCAmelCase_     :       int  		=					right_array[right_index]
                right_index += 1
            index += 1
        while (
            left_index < left_size
        ):  # Adds the left over elements in the left half of the array
            UpperCAmelCase_     :       Union[str, Any]  		=					left_array[left_index]
            left_index += 1
            index += 1
        while (
            right_index < right_size
        ):  # Adds the left over elements in the right half of the array
            UpperCAmelCase_     :       Tuple  		=					right_array[right_index]
            right_index += 1
            index += 1
    return arr


if __name__ == "__main__":
      import doctest

      doctest.testmod()





from math import cos, sin







def       lowerCamelCase_  (    _a       :						float    ):



    '''simple docstring'''




    UpperCAmelCase_     :       str  		=					float(_a    )
    return [[scaling_factor * int(x == y    ) for x in range(2    )] for y in range(2    )]







def       lowerCamelCase_  (    _a       :						float    ):



    '''simple docstring'''




    UpperCAmelCase_		, UpperCAmelCase_     :       List[str]  		=					cos(_a    ), sin(_a    )
    return [[c, -s], [s, c]]







def       lowerCamelCase_  (    _a       :						float    ):



    '''simple docstring'''




    UpperCAmelCase_		, UpperCAmelCase_     :       Optional[Any]  		=					cos(_a    ), sin(_a    )
    UpperCAmelCase_     :       Dict  		=					c * s
    return [[c * c, cs], [cs, s * s]]







def       lowerCamelCase_  (    _a       :						float    ):



    '''simple docstring'''




    UpperCAmelCase_		, UpperCAmelCase_     :       List[Any]  		=					cos(_a    ), sin(_a    )
    UpperCAmelCase_     :       Optional[Any]  		=					c * s
    return [[2 * c - 1, 2 * cs], [2 * cs, 2 * s - 1]]


print(F"    {scaling(5) = }")
print(F"  {rotation(45) = }")
print(F"{projection(45) = }")






print(F"{reflection(45) = }")
