giulio98/xlcost-single-prompt huggingface dataset:
# find interior angles for each side of a given cyclic quadrilateral | python3 program for the above approach ; function to find the interior angles of the cyclic quadrilateral ; stores the numerator and the denominator to find angle a ; stores the numerator and the denominator to find angle b ; stores the numerator and the denominator to find angle c : ; stores the numerator and the denominator to find angle d : ; 

import math


def findAngles(a, b, c, d):
    numerator = a * a + d * d - b * b - c * c
    denominator = 2 * (a * b + c * d)
    x = numerator / denominator
    print("A: ", '%.2f' % ((math .acos(x) * 180) / 3.141592), " degrees")
    numerator = a * a + b * b - c * c - d * d
    x = numerator / denominator
    print("B: ", '%.2f' % ((math .acos(x) * 180) / 3.141592), " degrees")
    numerator = c * c + b * b - a * a - d * d
    x = numerator / denominator
    print("C: ", '%.2f' % ((math .acos(x) * 180) / 3.141592), " degrees")
    numerator = d * d + c * c - a * a - b * b
    x = numerator / denominator
    print("D: ", '%.2f' % ((math .acos(x) * 180) / 3.141592), " degrees")


if __name__ == "__main__":
    A = 10
    B = 15
    C = 20
    D = 25
    findAngles(A, B, C, D)

# Expected output:
A:  85.59  degrees
B:  122.58  degrees
C:  94.41  degrees
D:  57.42  degrees
# number of smaller circles that can be inscribed in a larger circle | python3 program for the above approach ; function to count number of smaller circles that can be inscribed in the larger circle touching its boundary ; if r2 is greater than r1 ; stores the angle made by the smaller circle ; stores the ratio of r2 / ( r1 - r2 ) ; stores the count of smaller circles that can be inscribed ; stores the ratio ; if the diameter of smaller circle is greater than the radius of the larger circle ; otherwise ; find the angle using formula ; divide 360 with angle and take the floor value ; return the final result ; 

import math


def countInscribed(R1, R2):
    if (R2 > R1):
        return 0
    angle = 0
    ratio = 0
    number_of_circles = 0
    ratio = R2 / (R1 - R2)
    if (R1 < 2 * R2):
        number_of_circles = 1
    else:
        angle = (abs(math .asin(ratio) * 180) / 3.14159265)
        number_of_circles = (360 / (2 * math .floor(angle)))
    return number_of_circles


if __name__ == "__main__":
    R1 = 3
    R2 = 1
    print(int(countInscribed(R1, R2)))

# Expected output:
6
# count pairs of coordinates connected by a line with slope in the range [ | function to find the number of pairs of points such that the line passing through them has a slope in the range [ - k , k ] ; store the result ; traverse through all the combination of points ; if pair satisfies the given condition ; increment ans by 1 ; print the result ; 
def findPairs(x, y, K):
    n = len(x)
    ans = 0
    for i in range(n):
        for j in range(i + 1, n):
            if (K * abs(x[i] - x[j]) >= abs(y[i] - y[j])):
                ans += 1
    print(ans)


if __name__ == '__main__':
    X = [2, 1, 0]
    Y = [1, 2, 0]
    K = 1
    findPairs(X, Y, K)

# Expected output:
2
# number of largest circles that can be inscribed in a rectangle | function to count the number of largest circles in a rectangle ; if length exceeds breadth ; swap to reduce length to smaller than breadth ; return total count of circles inscribed ; 
def totalCircles(L, B):
    if (L > B):
        temp = L
        L = B
        B = temp
    return B // L


L = 3
B = 8
print(totalCircles(L, B))

# Expected output:
2
# program to calculate length of diagonal of a square | python3 program for the above approach ; function to find the length of the diagonal of a square of a given side ; 

import math


def findDiagonal(s):
    return math .sqrt(2) * s


if __name__ == "__main__":
    S = 10
    print(findDiagonal(S))

# Expected output:
14.142135623730951
# area of largest isosceles triangle that can be inscribed in an ellipse whose vertex coincides with one extremity of the major axis | python 3 program for the above approach ; function to calculate area of the isosceles triangle ; if a and b are negative ; stores the area of the triangle ; print the area ; 

from math import sqrt


def triangleArea(a, b):
    if (a < 0 or b < 0):
        print(-1)
        return
    area = (3 * sqrt(3) * a * b) / (4)
    print("{:.5f}".format(area))


if __name__ == '__main__':
    a = 1
    b = 2
    triangleArea(a, b)

# Expected output:
2.59808
# queries to count points lying on or inside an isosceles triangle with given length of equal sides | python3 implementation of above approach ; function to find answer of each query ; stores the count of points with sum less than or equal to their indices ; traverse the array ; ` if both x and y - coordinate < 0 ; stores the sum of co - ordinates ; increment count of sum by 1 ; prefix array ; perform queries ; 

from math import ceil
MAX = 10 ** 6 + 5


def query(arr, Q):
    pre = [0] * (MAX)
    for i in range(len(arr)):
        if (arr[i][0] < 0 or arr[i][1] < 0):
            continue
        sum = ceil((arr[i][0] + arr[i][1]))
        pre[sum] += 1
    for i in range(1, MAX):
        pre[i] += pre[i - 1]
    for i in range(len(Q)):
        print(pre[Q[i]], end=" ")


if __name__ == '__main__':
    arr = [[2.1, 3.0], [3.7, 1.2], [1.5, 6.5], [1.2, 0.0]]
    Q = [2, 8, 5]
    N = len(arr)
    M = len(Q)
    query(arr, Q)

# Expected output:
1 4 2
# perimeter of the union of two rectangles | function to check if two rectangles are intersecting or not ; if one rectangle is to the right of other 's right edge ; if one rectangle is on the top of other 's top edge ; function to return the perimeter of the union of two rectangles ; stores the resultant perimeter ; if rectangles do not interesect ; perimeter of rectangle 1 ; perimeter of rectangle 2 ; if the rectangles intersect ; get width of combined figure ; get length of combined figure ; return the perimeter ; 
def doIntersect(X, Y):
    if (X[0] > X[3] or X[2] > X[1]):
        return False
    if (Y[0] > Y[3] or Y[2] > Y[1]):
        return False
    return True


def getUnionPerimeter(X, Y):
    perimeter = 0
    if (not doIntersect(X, Y)):
        perimeter += 2 * (abs(X[1] - X[0]) + abs(Y[1] - Y[0]))
        perimeter += 2 * (abs(X[3] - X[2]) + abs(Y[3] - Y[2]))
    else:
        w = max(X) - min(X)
        l = max(Y) - min(Y)
        perimeter = 2 * (l + w)
    return perimeter


if __name__ == '__main__':
    X = [-1, 2, 4, 6]
    Y = [2, 5, 3, 7]
    print(getUnionPerimeter(X, Y))

# Expected output:
24
# check whether two straight lines are parallel or not | function to check if two lines are parallel or not ; if slopes are equal ; 
def parallel(a1, b1, c1, a2, b2, c2):
    if ((-(a1 / b1)) == (-(a2 / b2))):
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    a1 = -2
    b1 = 4
    c1 = 5
    a2 = -6
    b2 = 12
    c2 = 6
    parallel(a1, b1, c1, a2, b2, c2)

# Expected output:
Yes
# calculate area and height of an isosceles triangle whose sides are radii of a circle | python3 program for the above approach ; function to convert given angle from degree to radian ; function to calculate height and area of the triangle oab ; stores the angle oab and oba ; stores the angle in radians ; stores the height ; print height of the triangle ; stores the base of triangle oab ; stores the area of the triangle ; print the area of triangle oab ; 

from math import sin, cos


def Convert(degree):
    pi = 3.14159265359
    return (degree * (pi / 180))


def areaAndHeightOfTraingle(radius, a):
    if (a >= 180 or a == 0):
        print("Not possible")
        return
    base_angle = (180 - a) / 2
    radians = Convert(base_angle)
    height = sin(radians) * radius
    print("Height of triangle ", round(height, 1))
    base = cos(radians) * radius
    area = base * height
    print("Area of triangle ", round(area, 4))


if __name__ == '__main__':
    R, angle = 5, 120
    areaAndHeightOfTraingle(R, angle)

# Expected output:
Height of triangle  2.5
Area of triangle  10.8253
# radius of a circle having area equal to the sum of area of the circles having given radii | function to calculate radius of the circle having area equal to sum of the area of two circles with given radii ; area of first circle ; area of second circle ; area of third circle ; radius of third circle ; 
def findRadius(r1, r2):
    a1, a2, a3, r3 = 0, 0, 0, 0
    a1 = 3.14 * r1 * r1
    a2 = 3.14 * r2 * r2
    a3 = a1 + a2
    r3 = ((a3 / 3.14)**(1 / 2))
    return r3


if __name__ == '__main__':
    r1 = 8
    r2 = 6
    print(int(findRadius(r1, r2)))

# Expected output:
10
# minimum number of cuboids required to form a cube | function to calculate and return lcm of a , b , and c ; find gcd of a and b ; find lcm of a and b ; lcm ( a , b , c ) = lcm ( lcm ( a , b ) , c ) ; finding lcm of a , b , c ; return lcm ( a , b , c ) ; function to find the minimum number of cuboids required to make the volume of a valid cube ; find the lcm of l , b , h ; volume of the cube ; volume of the cuboid ; minimum number cuboids required to form a cube ; 
def find_lcm(a, b, c):
    g = __gcd(a, b)
    LCM1 = (a * b) // g
    g = __gcd(LCM1, c)
    LCM = (LCM1 * c) // g
    return LCM


def __gcd(a, b):
    if (b == 0):
        return a
    else:
        return __gcd(b, a % b)


def minimumCuboids(L, B, H):
    lcm = find_lcm(L, B, H)
    volume_cube = lcm * lcm * lcm
    volume_cuboid = L * B * H
    print((volume_cube // volume_cuboid))


if __name__ == '__main__':
    L = 1
    B = 1
    H = 2
    minimumCuboids(L, B, H)

# Expected output:
4
# check if given polygon is a convex polygon or not | utility function to find cross product of two vectors ; stores coefficient of x direction of vector a [ 1 ] a [ 0 ] ; stores coefficient of y direction of vector a [ 1 ] a [ 0 ] ; stores coefficient of x direction of vector a [ 2 ] a [ 0 ] ; stores coefficient of y direction of vector a [ 2 ] a [ 0 ] ; return cross product ; function to check if the polygon is convex polygon or not ; stores count of edges in polygon ; stores direction of cross product of previous traversed edges ; stores direction of cross product of current traversed edges ; traverse the array ; stores three adjacent edges of the polygon ; update curr ; if curr is not equal to 0 ; if direction of cross product of all adjacent edges are not same ; update curr ; 
def CrossProduct(A):
    X1 = (A[1][0] - A[0][0])
    Y1 = (A[1][1] - A[0][1])
    X2 = (A[2][0] - A[0][0])
    Y2 = (A[2][1] - A[0][1])
    return (X1 * Y2 - Y1 * X2)


def isConvex(points):
    N = len(points)
    prev = 0
    curr = 0
    for i in range(N):
        temp = [points[i], points[(i + 1) % N], points[(i + 2) % N]]
        curr = CrossProduct(temp)
        if (curr != 0):
            if (curr * prev < 0):
                return False
            else:
                prev = curr
    return True


if __name__ == '__main__':
    points = [[0, 0], [0, 1], [1, 1], [1, 0]]
    if (isConvex(points)):
        print("Yes")
    else:
        print("No")

# Expected output:
Yes
# program to find all possible triangles having same area and perimeter | function to print sides of all the triangles having same perimeter & area ; stores unique sides of triangles ; i + j + k values cannot exceed 256 ; find the value of 2 * s ; find the value of 2 * ( s - a ) ; find the value of 2 * ( s - b ) ; find the value of 2 * ( s - c ) ; if triplets have same area and perimeter ; store sides of triangle ; sort the triplets ; inserting in set to avoid duplicate sides ; print sides of all desired triangles ; 
def samePerimeterAndArea():
    se = []
    for i in range(1, 256, 1):
        for j in range(1, 256, 1):
            for k in range(1, 256, 1):
                peri = i + j + k
                mul1 = -i + j + k
                if (k > 100):
                    break
                if (j > 100):
                    break
                if (i > 100):
                    break
                mul2 = i - j + k
                mul3 = i + j - k
                if (16 * peri == mul1 * mul2 * mul3):
                    v = [i, j, k]
                    v .sort(reverse=False)
                    se .append(v)
                    se .sort(reverse=False)
    temp = []
    temp .append(se[0])
    temp .append(se[6])
    temp .append(se[12])
    temp .append(se[18])
    temp .append(se[24])
    for it in temp:
        print(it[0], it[1], it[2])


if __name__ == '__main__':
    samePerimeterAndArea()

# Expected output:
5 12 13
6 8 10
6 25 29
7 15 20
9 10 17
# count rectangles generated in a given rectangle by lines drawn parallel to x and y axis from a given set of points | function to get the count of ractangles ; store distinct horizontal lines ; store distinct vertical lines ; insert horizontal line passing through 0 ; insert vertical line passing through 0. ; insert horizontal line passing through rectangle [ 3 ] [ 0 ] ; insert vertical line passing through rectangle [ 3 ] [ 1 ] ; insert all horizontal and vertical lines passing through the given array ; insert all horizontal lines ; insert all vertical lines ; 
def cntRect(points, N, rectangle):
    cntHor = set([])
    cntVer = set([])
    cntHor .add(0)
    cntVer .add(0)
    cntHor .add(rectangle[3][0])
    cntVer .add(rectangle[3][1])
    for i in range(N):
        cntHor .add(points[i][0])
        cntVer .add(points[i][1])
    return ((len(cntHor) - 1) * (len(cntVer) - 1))


if __name__ == "__main__":
    rectangle = [[0, 0], [0, 5], [5, 0], [5, 5]]
    points = [[1, 2], [3, 4]]
    N = len(points)
    print(cntRect(points, N, rectangle))

# Expected output:
9
# count squares possible from m and n straight lines parallel to x and y axis respectively | function to count all the possible squares with given lines parallel to both the x and y axis ; stores the count of all possible distances in x [ ] & y [ ] respectively ; find distance between all pairs in the array x [ ] ; add the count to m1 ; find distance between all pairs in the array y [ ] ; add the count to m2 ; find sum of m1 [ i ] * m2 [ i ] for same distance ; find current count in m2 ; add to the total count ; return the final count ; 
def numberOfSquares(X, Y, N, M):
    m1 = {}
    m2 = {}
    ans = 0
    for i in range(0, N):
        for j in range(i + 1, N):
            dist = abs(X[i] - X[j])
            if dist in m1:
                m1[dist] = m1[dist] + 1
            else:
                m1[dist] = 1
    for i in range(0, M):
        for j in range(i + 1, M):
            dist = abs(Y[i] - Y[j])
            if dist in m2:
                m2[dist] = m2[dist] + 1
            else:
                m2[dist] = 1
    for key in m1:
        if key in m2:
            ans = ans + (m1[key] * m2[key])
    return ans


if __name__ == "__main__":
    X = [1, 3, 7]
    Y = [2, 4, 6, 1]
    N = len(X)
    M = len(Y)
    print(numberOfSquares(X, Y, N, M))

# Expected output:
3
# program to calculate area of a parallelogram | python3 program for the above approach ; function to return the area of parallelogram using sides and angle at the intersection of diagonal ; calculate area of parallelogram ; return the answer ; function to return the area of parallelogram using sides and angle at the intersection of sides ; calculate area of parallelogram ; return the answer ; function to return the area of parallelogram using diagonals and angle at the intersection of diagonals ; calculate area of parallelogram ; return the answer ; 

import math


def Area_Parallelogram1(a, b, theta):
    area = (abs(math .tan(math .radians(theta))) / 2) * abs(a ** 2 - b ** 2)
    return area


def Area_Parallelogram2(a, b, gamma):
    area = (abs(math .sin(math .radians(gamma)))) * abs(a * b)
    return area


def Area_Parallelogram3(d1, d2, theta):
    area = (abs(math .sin(math .radians(theta))) / 2) * abs(d1 * d2)
    return area


d1 = 3
d2 = 5
theta = 90
area = Area_Parallelogram3(d1, d2, theta)
print(round(area, 2))

# Expected output:
7.5
# count squares of size k inscribed in a square of size n | function to calculate the number of squares of size k in a square of size n ; stores the number of squares ; 
def No_of_squares(N, K):
    no_of_squares = 0
    no_of_squares = (N - K + 1) * (N - K + 1)
    return no_of_squares


if __name__ == '__main__':
    N = 5
    K = 3
    print(No_of_squares(N, K))

# Expected output:
9
# Count cubes of size K inscribed in a cube of size N | Function to find the number of the cubes of the size K ; Stores the number of cubes ; Stores the number of cubes of size k ; Size of the bigger cube ; Size of the smaller cube
def No_of_cubes(N, K):
    No = 0
    No = (N - K + 1)
    No = pow(No, 3)
    return No


N = 5
K = 2
print(No_of_cubes(N, K))

# Expected output:
64
# count of smaller rectangles that can be placed inside a bigger rectangle | function to count smaller rectangles within the larger rectangle ; if the dimension of the smaller rectangle is greater than the bigger one ; return the number of smaller rectangles possible ; 
def No_of_rectangles(L, B, l, b):
    if (l > L) or (b > B):
        return -1
    else:
        return (L - l + 1) * (B - b + 1)


if __name__ == '__main__':
    L = 5
    B = 3
    l = 4
    b = 1
    print(No_of_rectangles(L, B, l, b))

# Expected output:
6
# program to check whether a triangle is equilateral , isosceles or scalene | function to check if the triangle is equilateral or isosceles or scalene ; _check for equilateral triangle ; check for isosceles triangle ; otherwise scalene triangle ; 
def checkTriangle(x, y, z):
    if x == y == z:
        print("Equilateral Triangle")
    elif x == y or y == z or z == x:
        print("Isosceles Triangle")
    else:
        print("Scalene Triangle")


x = 8
y = 7
z = 9
checkTriangle(x, y, z)

# Expected output:
Scalene Triangle
# find the remaining vertices of a square from two given vertices | function to find the remaining vertices of a square ; check if the x - coordinates are equal ; check if the y - coordinates are equal ; if the the given coordinates forms a diagonal of the square ; otherwise ; square does not exist ; 
def findVertices(x1, y1, x2, y2):
    if (x1 == x2):
        print((x1 + y2 - y1), ",", y1)
        print((x2 + y2 - y1), ",", y2)
    elif (y1 == y2):
        print(x1, ",", (y1 + x2 - x1))
        print(x2, ",", (y2 + x2 - x1))
    elif (abs(x2 - x1) == abs(y2 - y1)):
        print(x1, ",", y2)
        print(x2, ",", y1)
    else:
        print("-1")


if __name__ == '__main__':
    x1 = 1
    y1 = 2
    x2 = 3
    y2 = 4
    findVertices(x1, y1, x2, y2)

# Expected output:
1 , 4
3 , 2
# find the area of rhombus from given angle and side length | python3 program to calculate area of rhombus from given angle and side length ; function to return the area of rhombus using one angle and side . ; 

import math


def Area_of_Rhombus(a, theta):
    area = (a ** 2) * math .sin(math .radians(theta))
    return area


a = 4
theta = 60
ans = Area_of_Rhombus(a, theta)
print(round(ans, 2))

# Expected output:
13.86
# count of equilateral triangles of unit length possible from a 
def calculateTriangles(sides):
    count = pow(sides[0] + sides[1] + sides[2], 2)
    count -= pow(sides[0], 2)
    count -= pow(sides[2], 2)
    count -= pow(sides[4], 2)
    return int(count)


sides = [1, 1, 1, 1, 1, 1]
print(calculateTriangles(sides))
sides = [2, 2, 1, 3, 1, 2]
print(calculateTriangles(sides))

# Expected output:
6
19
# length of diagonal of a parallelogram using adjacent sides and angle between them | python3 program to find length of diagonal of a parallelogram using sides and angle between them . ; function to return the length of diagonal of a parallelogram using sides and angle between them . ; given sides ; 

import math


def Length_Diagonal(a, b, theta):
    diagonal = math .sqrt(((a ** 2) + (b ** 2)) - 2 *
                          a * b * math .cos(math .radians(theta)))
    return diagonal


a = 3
b = 5
theta = 45
ans = Length_Diagonal(a, b, theta)
print(round(ans, 2))

# Expected output:
3.58
# maximum number of tiles required to cover the floor of given size using 2 x1 size tiles | function to find the maximum number of tiles required to cover the floor of size m x n using 2 x 1 size tiles ; prthe answer ; 
def maximumTiles(n, m):
    print(int((m * n) / 2))


if __name__ == '__main__':
    M = 3
    N = 4
    maximumTiles(N, M)

# Expected output:
6
# length of a diagonal of a parallelogram using the length of sides and the other diagonal | python program to implement the above approach ; function to calculate the length of the diagonal of a parallelogram using two sides and other diagonal ; 

import math


def Length_Diagonal(a, b, d):
    diagonal = math .sqrt(2 * ((a ** 2) + (b ** 2)) - (d ** 2))
    return diagonal


A = 10
B = 30
D = 20
ans = Length_Diagonal(A, B, D)
print(round(ans, 2))

# Expected output:
40.0
# length of diagonals of a cyclic quadrilateral using the length of sides . | python3 program to implement the above approach ; function to calculate the length of diagonals of a cyclic quadrilateral ; 

import math


def Diagonals(a, b, c, d):
    p = math .sqrt(((a * c) + (b * d)) *
                   ((a * d) + (b * c)) / ((a * b) + (c * d)))
    q = math .sqrt(((a * c) + (b * d)) *
                   ((a * b) + (c * d)) / ((a * d) + (b * c)))
    return [p, q]


A = 10
B = 15
C = 20
D = 25
ans = Diagonals(A, B, C, D)
print(round(ans[0], 2), round(ans[1], 2))

# Expected output:
22.06 26.07
# minimum sum of euclidean distances to all given points | python3 program to implement the above approach ; function to calculate euclidean distance ; function to calculate the minimum sum of the euclidean distances to all points ; calculate the centroid ; calculate distance of all points ; 

from math import sqrt


def find(x, y, p):
    mind = 0
    for i in range(len(p)):
        a = p[i][0]
        b = p[i][1]
        mind += sqrt((x - a) * (x - a) + (y - b) * (y - b))
    return mind


def getMinDistSum(p):
    x = 0
    y = 0
    for i in range(len(p)):
        x += p[i][0]
        y += p[i][1]
    x = x // len(p)
    y = y // len(p)
    mind = find(x, y, p)
    return mind


if __name__ == '__main__':
    vec = [[0, 1], [1, 0], [1, 2], [2, 1]]
    d = getMinDistSum(vec)
    print(int(d))

# Expected output:
4
# coplanarity of two lines in 3d geometry | function to generate determinant ; return the sum ; 
def det(d):
    Sum = d[0][0] * ((d[1][1] * d[2][2]) - (d[2][1] * d[1][2]))
    Sum -= d[0][1] * ((d[1][0] * d[2][2]) - (d[1][2] * d[2][0]))
    Sum += d[0][2] * ((d[0][1] * d[1][2]) - (d[0][2] * d[1][1]))
    return Sum


if __name__ == '__main__':
    x1, y1, z1 = -3, 1, 5
    a1, b1, c1 = -3, 1, 5
    x2, y2, z2 = -1, 2, 5
    a2, b2, c2 = -1, 2, 5
    det_list = [[x2 - x1, y2 - y1, z2 - z1], [a1, b1, c1], [a2, b2, c2]]
    if (det(det_list) == 0):
        print("Lines are coplanar")
    else:
        print("Lines are non coplanar")

# Expected output:
Lines are coplanar
# Distance between Incenter and Circumcenter of a triangle using Inradius and Circumradius | Python3 program for the above approach ; Function returns the required distance ; Length of Inradius ; Length of Circumradius

import math


def distance(r, R):
    d = math .sqrt((R ** 2) - (2 * r * R))
    return d


r = 2
R = 5
print(round(distance(r, R), 2))

# Expected output:
2.24
# check if an n | function to check if the polygon exists or not ; initialize a variable to store the sum of angles ; loop through the array and calculate the sum of angles ; check the condition for an n - side polygon ; 
def checkValidPolygon(arr, N):
    Sum = 0
    for i in range(N):
        Sum += arr[i]
    if Sum == 180 * (N - 2):
        print("Yes")
    else:
        print("No")


N = 3
arr = [60, 60, 60]
checkValidPolygon(arr, N)

# Expected output:
Yes
# find the angle of rotational symmetry of an n | function to find required minimum angle of rotation ; calculating the angle of rotation and type - casting the integer n to type ; 
def minAnglRot(N):
    res = 360 // N
    return res


if __name__ == '__main__':
    N = 4
    print("Angle of Rotational Symmetry: ", minAnglRot(N))

# Expected output:
Angle of Rotational Symmetry:  90