计算以2为底的log

最新推荐文章于 2023-02-01 15:55:51 发布

LostSpeed

最新推荐文章于 2023-02-01 15:55:51 发布

阅读量6.8k

点赞数

在学习大数n!算法时, 想到log2(x)怎么算?

math.h中没有log2接口, 只有log和log10.

上网查了下, 原来用对数换底公式可以搞定这事^_^

// @file power_exp_log.cpp
// @brief 计算以2为底的log

#include <iostream>                 // for i/o functions
#include <math.h>                   // for exp(), log(), and log10()
#include <conio.h>

using namespace std;

#define CONST_E 2.718282 ///< 常数e的值约为2.718282

/// math.h中没有log2的函数
double log2(double dblpow2);

void fnTest_power_exp_log_2(); ///< 用对数换底公式做
void fnTest_power_exp_log_E();
void fnTest_power_exp_log_10();

int main(int argc, char* argv[])
{
    fnTest_power_exp_log_2();
    // fnTest_power_exp_log_E();
    // fnTest_power_exp_log_10();

    printf("END, press any key to quit\n");
    _getch();
    return 0;
}

double log2(double dblpow2)
{
    /**
    math.h中没有log2的接口
    用对数换底公式来间接计算

    对数换底公式
    Loga(B) = logc(B) / logc(A)
    a, c均大于0且不等于1

    math.h中有log和log10
    logc 可以用log或1og10
    */

    double dbllog2 = 0;
    dbllog2 = log(dblpow2) / log(2);
    return dbllog2;
}

void fnTest_power_exp_log_2()
{
    double dblIndex = 0;
    double dblpow = 0;
    double dbllog = 0;

    for (dblIndex = 0; dblIndex <= 10; dblIndex++)
    {
        dblpow = pow(2, dblIndex);
        printf("pow(2, %f) = %f\n", 
            dblIndex, dblpow);

        dbllog = log2(dblpow);
        printf("log2(%f) = %f\n", 
            dblpow, dbllog);

        printf("\r\n");
    }

    /** run result
    pow(2, 0.000000) = 1.000000
    log2(1.000000) = 0.000000

    pow(2, 1.000000) = 2.000000
    log2(2.000000) = 1.000000

    pow(2, 2.000000) = 4.000000
    log2(4.000000) = 2.000000

    pow(2, 3.000000) = 8.000000
    log2(8.000000) = 3.000000

    pow(2, 4.000000) = 16.000000
    log2(16.000000) = 4.000000

    pow(2, 5.000000) = 32.000000
    log2(32.000000) = 5.000000

    pow(2, 6.000000) = 64.000000
    log2(64.000000) = 6.000000

    pow(2, 7.000000) = 128.000000
    log2(128.000000) = 7.000000

    pow(2, 8.000000) = 256.000000
    log2(256.000000) = 8.000000

    pow(2, 9.000000) = 512.000000
    log2(512.000000) = 9.000000

    pow(2, 10.000000) = 1024.000000
    log2(1024.000000) = 10.000000
    */
}

void fnTest_power_exp_log_10()
{
    double dblIndex = 0;
    double dblpow = 0;
    double dbllog = 0;

    for (dblIndex = 0; dblIndex <= 10; dblIndex++)
    {
        dblpow = pow(10, dblIndex);
        printf("pow(10, %f) = %f\n", 
            dblIndex, dblpow);

        dbllog = log10(dblpow);
        printf("log10(%f) = %f\n", 
            dblpow, dbllog);

        printf("\r\n");
    }

    /** run result
    pow(10, 0.000000) = 1.000000
    log10(1.000000) = 0.000000

    pow(10, 1.000000) = 10.000000
    log10(10.000000) = 1.000000

    pow(10, 2.000000) = 100.000000
    log10(100.000000) = 2.000000

    pow(10, 3.000000) = 1000.000000
    log10(1000.000000) = 3.000000

    pow(10, 4.000000) = 10000.000000
    log10(10000.000000) = 4.000000

    pow(10, 5.000000) = 100000.000000
    log10(100000.000000) = 5.000000

    pow(10, 6.000000) = 1000000.000000
    log10(1000000.000000) = 6.000000

    pow(10, 7.000000) = 10000000.000000
    log10(10000000.000000) = 7.000000

    pow(10, 8.000000) = 100000000.000000
    log10(100000000.000000) = 8.000000

    pow(10, 9.000000) = 1000000000.000000
    log10(1000000000.000000) = 9.000000

    pow(10, 10.000000) = 10000000000.000000
    log10(10000000000.000000) = 10.000000
    */
}

void fnTest_power_exp_log_E()
{
    double dblIndex = 0;
    double dblexp = 0;
    double dblpow = 0;
    double dbllog = 0;

    for (dblIndex = 0; dblIndex <= 10; dblIndex++)
    {
        dblpow = pow(CONST_E, dblIndex);
        printf("pow(CONST_E, %f) = %f\n", 
            dblIndex, dblpow);

        dblexp = exp(dblIndex);
        printf("exp(%f) = %f\n", 
            dblIndex, dblexp);

        dbllog = log(dblexp);
        printf("log(%f) = %f\n", 
            dblexp, dbllog);

        printf("\r\n");
    }

    /** run result
    pow(CONST_E, 0.000000) = 1.000000
    exp(0.000000) = 1.000000
    log(1.000000) = 0.000000

    pow(CONST_E, 1.000000) = 2.718282
    exp(1.000000) = 2.718282
    log(2.718282) = 1.000000

    pow(CONST_E, 2.000000) = 7.389057
    exp(2.000000) = 7.389056
    log(7.389056) = 2.000000

    pow(CONST_E, 3.000000) = 20.085541
    exp(3.000000) = 20.085537
    log(20.085537) = 3.000000

    pow(CONST_E, 4.000000) = 54.598164
    exp(4.000000) = 54.598150
    log(54.598150) = 4.000000

    pow(CONST_E, 5.000000) = 148.413206
    exp(5.000000) = 148.413159
    log(148.413159) = 5.000000

    pow(CONST_E, 6.000000) = 403.428946
    exp(6.000000) = 403.428793
    log(403.428793) = 6.000000

    pow(CONST_E, 7.000000) = 1096.633643
    exp(7.000000) = 1096.633158
    log(1096.633158) = 7.000000

    pow(CONST_E, 8.000000) = 2980.959492
    exp(8.000000) = 2980.957987
    log(2980.957987) = 8.000000

    pow(CONST_E, 9.000000) = 8103.088530
    exp(9.000000) = 8103.083928
    log(8103.083928) = 9.000000

    pow(CONST_E, 10.000000) = 22026.479695
    exp(10.000000) = 22026.465795
    log(22026.465795) = 10.000000
    */
}