What should I call an internal casting function that may fail

Question

(Almost) all numbers in my program are parsed and treated as complex numbers. There is one corner cases, that specifically needs an integer. Unfortunately my programming languages does not allow to compare integers to complex numbers so I needed to come up with the following code:

function_name(Complex c)
    if c has imaginary part != 0 
        throw exception
    if ( integer(real(c)) - real(c) ) != 0
        throw exception
    return integer(real(c))

I'm stuck on how to call this function. If I call it something like complex_to_int I think it hides the fact, that it fails on non integer complex numbers. If the complex number is real, then I (or other people) might expect this function to work like a normal cast from a floating point value to an integer (i.e. the decimal places are just cut off).

My question is:
-Is there a good name to call this function

Or, at the risk of the question being too subjective

-Should I split this function in two and actually have a real casting function (that just ignores potential imaginary parts and cuts of decimal places) and write a function that checks if the complex number fulfills my criteria before casting it?

Answer 1

You can take inspiration from .NET's TryParse series of methods.

In .NET, a "TryParse" method attempts to parse the parameter it receives, and returns either true or false - true if the conversion was successful, false if it was not.

The parsed number is then returned using an out parameter.

You can use a similar naming scheme for your fuction. "TryConvertToInteger" makes it very clear that this is an attempt, and nothing else - it may very well halt and catch fire.

Another option you have is to do a more... naive casting, and call your method "GetIntegerPart" or similar:

• Do not check if the number is an integer.
• Do not check if the number has an imaginary part.
• Instead, just take out the real part, round it up to the nearest integer, and be done with it.

ex.:

2-2i -> 2   
3.4+i -> 3
3.6-i -> 4

Then it is up to the caller to decide if they need to check the imaginary part or not, or if they need the extra precision.