Code Snippets

Number_IsDigits

public static bool Number_IsDigits(
    string sTextValue)
{
    try
    {
        if (gbEND_GENERAL)
            return false;

        bool IsDigits = true;

        for (int icharno = 0; icharno <= sTextValue.Length - 1; icharno++)
        {
            if (!char.IsDigit(sTextValue[icharno]))
            {
                IsDigits = false;
                return IsDigits;
            }
        }

        return IsDigits;
    }
    catch (System.Runtime.InteropServices.COMException ex)
    {
        mobjCOMException = ex;
    }
    catch (Exception ex)
    {
        mobjException = ex;
    }
    finally
    {
        if (gbDEBUG_GENERAL ||
            (mobjCOMException != null || mobjException != null))
        {
            clsError.Handle(
                "IsDigits",
                msCLASSNAME,
                "determine if '" + sTextValue + "' contains all numerical characters.",
                mobjCOMException,
                mobjException);
        }
    }

    return false;
}

Number_IsEven

public bool Number_IsEven(
    int TheNumber)
{
    try
    {
        if (TheNumber % 2 == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    catch (Exception ex)
    {
        modMessages.ErrorMessage(
            System.Reflection.MethodBase.GetCurrentMethod(),
            ex.Message);
    }

    return false;
}

Number_IsInteger

public static bool Number_IsInteger(
    string sTextValue)
{
    try
    {
        int iresult;
        iresult = Convert.ToInt32(sTextValue);
        return true;
    }
    catch
    {
        return false;
    }
}

Number_IsItInRange

public bool Number_IsItInRange(
    float sngNumber,
    float sngMinValue,
    float sngMaxValue,
    bool bEqualTo = true,
    bool bInformUser = false)
{
    try
    {
        if (My.Settings.USER_ERROR_OCCURRED)
            return false;

        if (bEqualTo)
        {
            if (sngNumber >= sngMinValue && sngNumber <= sngMaxValue)
            {
                return true;
            }
            else
            {
                if (bInformUser)
                {
                    System.Windows.Forms.MessageBox.Show(
                        "The number must be between " + sngMinValue + " and " + sngMaxValue + ".",
                        "Number Out of Range");
                }
                return false;
            }
        }
        else
        {
            if (sngNumber > sngMinValue && sngNumber < sngMaxValue)
            {
                return true;
            }
            else
            {
                if (bInformUser)
                {
                    System.Windows.Forms.MessageBox.Show(
                        "The number must be between " + sngMinValue + " and " + sngMaxValue + ".",
                        "Number Out of Range");
                }
                return false;
            }
        }
    }
    catch (System.Runtime.InteropServices.COMException ex)
    {
        m_objCOMException = ex;
    }
    catch (Exception ex)
    {
        m_objException = ex;
    }
    finally
    {
        if (m_objCOMException != null || m_objException != null)
        {
            modMessages.ErrorMessage(
                System.Reflection.MethodBase.GetCurrentMethod(),
                m_objCOMException,
                m_objException,
                "determine if the number '" + sngNumber +
                "' is in the range between '" + sngMinValue +
                "' to '" + sngMaxValue + "' or not.");
        }
    }

    return false;
}

Number_LargestOneSingle

public static float Number_LargestOneSingle(
    params float[] sngNumbers)
{
    try
    {
        if (gbEND_GENERAL)
            return 0f;

        float snglargest = sngNumbers[0];

        foreach (float sngNumber in sngNumbers)
        {
            if (sngNumber > snglargest)
                snglargest = sngNumber;
        }

        return snglargest;
    }
    catch (System.Runtime.InteropServices.COMException ex)
    {
        gobjCOMException = ex;
    }
    catch (Exception ex)
    {
        gobjException = ex;
    }
    finally
    {
        if (gbDEBUG_GENERAL ||
            (gobjCOMException != null || gobjException != null))
        {
            clsError.Handle(
                "LargestOneSingle",
                "clsNumber",
                "return the largest number from all those passed in.",
                gobjCOMException,
                gobjException);
        }
    }

    return 0f;
}

Number_ReturnPowerOfTen

public static int Number_ReturnPowerOfTen(
    float sngNumber)
{
    try
    {
        if (gbEND_GENERAL)
            return 0;

        // compensate for floating-point drift
        sngNumber = (float)(sngNumber * 1.0001);

        int ReturnPowerOfTen = 0;

        if ((0 < sngNumber) && (sngNumber < 0.0000001f)) ReturnPowerOfTen = 9;
        if ((0.0000001f < sngNumber) && (sngNumber < 0.000001f)) ReturnPowerOfTen = 8;
        if ((0.000001f <= sngNumber) && (sngNumber < 0.00001f)) ReturnPowerOfTen = 7;
        if ((0.00001f <= sngNumber) && (sngNumber < 0.0001f)) ReturnPowerOfTen = 6;
        if ((0.0001f <= sngNumber) && (sngNumber < 0.001f)) ReturnPowerOfTen = 5;
        if ((0.001f <= sngNumber) && (sngNumber < 0.01f)) ReturnPowerOfTen = 4;
        if ((0.01f <= sngNumber) && (sngNumber < 0.1f)) ReturnPowerOfTen = 3;
        if ((0.1f <= sngNumber) && (sngNumber < 1f)) ReturnPowerOfTen = 2;
        if ((1f <= sngNumber) && (sngNumber < 10f)) ReturnPowerOfTen = 1;
        if ((10f <= sngNumber) && (sngNumber < 100f)) ReturnPowerOfTen = 0;
        if ((100f <= sngNumber) && (sngNumber < 1000f)) ReturnPowerOfTen = -1;
        if ((1000f <= sngNumber) && (sngNumber < 10000f)) ReturnPowerOfTen = -2;
        if ((10000f <= sngNumber) && (sngNumber < 100000f)) ReturnPowerOfTen = -3;
        if ((100000f <= sngNumber) && (sngNumber < 1000000f)) ReturnPowerOfTen = -4;
        if ((1000000f <= sngNumber) && (sngNumber < 10000000f)) ReturnPowerOfTen = -5;
        if (10000000f <= sngNumber) ReturnPowerOfTen = -6;

        return ReturnPowerOfTen;
    }
    catch (System.Runtime.InteropServices.COMException ex)
    {
        gobjCOMException = ex;
    }
    catch (Exception ex)
    {
        gobjException = ex;
    }
    finally
    {
        if (gbDEBUG_GENERAL ||
            (gobjCOMException != null || gobjException != null))
        {
            clsError.Handle(
                "ReturnPowerOfTen",
                "clsNumber",
                "return to what power of ten the number '" + sngNumber + "' is.",
                gobjCOMException,
                gobjException);
        }
    }

    return 0;
}

Number_SmallestOneSingle

public static float Number_SmallestOneSingle(
    params float[] sngNumbers)
{
    try
    {
        if (gbEND_GENERAL)
            return 0f;

        float sngsmallest = sngNumbers[0];

        foreach (float sngNumber in sngNumbers)
        {
            if (sngNumber < sngsmallest)
                sngsmallest = sngNumber;
        }

        return sngsmallest;
    }
    catch (System.Runtime.InteropServices.COMException ex)
    {
        gobjCOMException = ex;
    }
    catch (Exception ex)
    {
        gobjException = ex;
    }
    finally
    {
        if (gbDEBUG_GENERAL ||
            (gobjCOMException != null || gobjException != null))
        {
            clsError.Handle(
                "SmallestOneSingle",
                "clsNumber",
                "return the smallest number from all those passed in.",
                gobjCOMException,
                gobjException);
        }
    }

    return 0f;
}

Number_TenToThePowerOf

public static float Number_TenToThePowerOf(
    int iMultiple)
{
    try
    {
        if (gbEND_GENERAL)
            return 0f;

        int ipowersoften = 1;

        if (Math.Abs(iMultiple) == 0)
        {
            ipowersoften = 1;
        }
        else
        {
            for (int icount = 1; icount <= Math.Abs(iMultiple); icount++)
            {
                ipowersoften = 10 * ipowersoften;
            }
        }

        if (iMultiple <= 0)
            return (float)(1.0 / ipowersoften);

        if (iMultiple > 0)
            return ipowersoften;
    }
    catch (System.Runtime.InteropServices.COMException ex)
    {
        gobjCOMException = ex;
    }
    catch (Exception ex)
    {
        gobjException = ex;
    }
    finally
    {
        if (gbDEBUG_GENERAL ||
            (gobjCOMException != null || gobjException != null))
        {
            clsError.Handle(
                "TenToThePowerOf",
                "clsNumber",
                "return 10 to the power of '" + iMultiple + "'.",
                gobjCOMException,
                gobjException);
        }
    }

    return 0f;
}