Implementing Power Function

This challenge asks you to implement a function that calculates x raised to the power of n (x^n). This is a fundamental operation in mathematics and computer science, with applications ranging from scientific computing and financial modeling to graphics rendering.

Problem Description

You need to create a function that takes two numbers, x (the base) and n (the exponent), and returns the result of x raised to the power of n.

Key Requirements:

• Handle both positive and negative integer exponents.
• Handle fractional bases (x).
• The function should be efficient.

Expected Behavior:

• If n is positive, the function should return x * x * ... * x (n times).
• If n is zero, the function should return 1 (for any x except possibly 0, though for this problem, 0^0 can be considered 1).
• If n is negative, the function should return 1 / (x * x * ... * x) (|n| times).

Important Edge Cases to Consider:

• When x is 0.
• When n is 0.
• When n is negative.
• When x is a fraction or decimal.

Examples

Example 1:

Input: x = 2.0, n = 10
Output: 1024.00000
Explanation: 2.0 raised to the power of 10 is 2 * 2 * ... * 2 (10 times), which equals 1024.0.

Example 2:

Input: x = 2.10000, n = 3
Output: 9.26100
Explanation: 2.1 raised to the power of 3 is 2.1 * 2.1 * 2.1, which equals 9.261.

Example 3:

Input: x = 2.00000, n = -2
Output: 0.25000
Explanation: 2.0 raised to the power of -2 is 1 / (2.0 * 2.0), which equals 1 / 4.0, or 0.25.

Example 4:

Input: x = 3.0, n = 0
Output: 1.00000
Explanation: Any number raised to the power of 0 is 1.

Constraints

• -100.0 < x < 100.0
• -2^31 <= n <= 2^31 - 1 (n is an integer)
• The output should be accurate to 5 decimal places for fractional results.
• Aim for a solution with a time complexity better than O(n) if possible.

Notes

Consider the case where n is negative. You'll need to handle the reciprocal.

Think about how you can optimize the calculation, especially for large values of n. A naive approach of multiplying x by itself n times might be too slow if n is very large. Recursion or iteration with clever optimization can lead to a faster solution. For instance, x^n can be computed as (x^(n/2))^2 if n is even, and x * (x^((n-1)/2))^2 if n is odd.