calc.hpp

/**************************************************************************************************
 * Copyright (c) 2023-2025 NWSOFT                                                                 *
 *                                                                                                *
 * Permission is hereby granted, free of charge, to any person obtaining a copy                   *
 * of this software and associated documentation files (the "Software"), to deal                  *
 * in the Software without restriction, including without limitation the rights                   *
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell                      *
 * copies of the Software, and to permit persons to whom the Software is                          *
 * furnished to do so, subject to the following conditions:                                       *
 *                                                                                                *
 * The above copyright notice and this permission notice shall be included in all                 *
 * copies or substantial portions of the Software.                                                *
 *                                                                                                *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR                     *
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,                       *
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE                    *
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER                         *
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,                  *
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE                  *
 * SOFTWARE.                                                                                      *
 **************************************************************************************************/

 
#pragma once
 
#include "fn/root.hpp"
#include "output.hpp"
 
#include <string>
#include <util.hpp>
 
using namespace std::literals;

namespace steppable::__internals::calc
{
    struct QuotientRemainder
    {
        std::string quotient;
        std::string remainder;
    };

    std::string abs(const std::string& _number, int steps);

    std::string add(const std::string& a,
                    const std::string& b,
                    int steps = 2,
                    bool negative = false,
                    bool properlyFormat = true);

    std::string compare(const std::string& _a, const std::string& _b, int steps = 2);

    std::string decimalConvert(const std::string& _inputString, const std::string& baseString, int steps = 2);

    std::string baseConvert(const std::string& _number, const std::string& baseStr, int steps = 2);

    std::string divide(const std::string& number, const std::string& divisor, int steps = 2, int decimals = 5);

    QuotientRemainder divideWithQuotient(const std::string& number, const std::string& divisor);

    std::string getGCD(const std::string& _a, const std::string& _b);

    std::string multiply(const std::string& a, const std::string& b, int steps = 2, int decimals = MAX_DECIMALS);

    std::string power(const std::string& _number, const std::string& raiseTo, int steps = 2, int decimals = 8);

    std::string exp(const std::string& x, size_t decimals = 10);

    std::string subtract(const std::string& a, const std::string& b, int steps = 2, bool noMinus = false);

    std::string root(const std::string& _number, const std::string& base, size_t decimals = 8, int steps = 0);

    Surd rootSurd(const std::string& _number, const std::string& base);

    std::string rootIntPart(const std::string& _number, const std::string& base);

    std::string factorial(const std::string& _number, int steps = 2);

    std::string degToRad(const std::string& _deg);

    std::string gradToRad(const std::string& _grad);

    std::string cos(const std::string& x, int decimals, int mode = 0);

    std::string sin(const std::string& x, int decimals, int mode = 0);

    std::string tan(const std::string& x, int decimals, int mode = 0);

    std::string sec(const std::string& x, int decimals, int mode = 0);

    std::string csc(const std::string& x, int decimals, int mode = 0);

    std::string cot(const std::string& x, int decimals, int mode = 0);

    std::string acos(const std::string& x, int decimals, int mode = 0);

    std::string asin(const std::string& x, int decimals, int mode = 0);

    std::string atan(const std::string& x, int decimals, int mode = 0);

    std::string asec(const std::string& x, int decimals, int mode = 0);

    std::string acsc(const std::string& x, int decimals, int mode = 0);

    std::string acot(const std::string& x, int decimals, int mode = 0);

    std::string sinh(const std::string& x, int decimals);

    std::string cosh(const std::string& x, int decimals);

    std::string tanh(const std::string& x, int decimals);

    std::string sech(const std::string& x, int decimals);

    std::string csch(const std::string& x, int decimals);

    std::string coth(const std::string& x, int decimals);

    std::string asinh(const std::string& x, int decimals);

    std::string acosh(const std::string& x, int decimals);

    std::string atanh(const std::string& x, int decimals);

    std::string acoth(const std::string& x, int decimals);

    std::string asech(const std::string& x, int decimals);

    std::string acsch(const std::string& x, int decimals);

    std::string logb(const std::string& _number, const std::string& _base, size_t _decimals);

    std::string log10(const std::string& _number, size_t _decimals);

    std::string log2(const std::string& _number, size_t _decimals);

    std::string ln(const std::string& _number, size_t _decimals);

    template<typename Pred>
    void loop(const std::string& times, Pred predicate)
    {
        // We're done already!
        if (times == "0")
            return;
        if (times == "1")
            return predicate("1");
 
        std::string current = "0";
        auto result = compare(current, times, 0);
 
        while (result == "0")
        {
            try
            {
                predicate(current);
            }
            catch (std::exception& e)
            {
                output::error("loop", "Exception occurred in predicate."s);
                output::error("loop", "Exception message: {0}"s, { e.what() });
            }
            current = add(current, "1", 0);
            result = compare(current, times, 0);
        }
    }
 
} // namespace steppable::__internals::calc