前言： 
 这是第三篇博客，也是一次介绍二个计算的博客，可能难度会比前两篇博客大一点，所以建议对于初学者来说一定要看完我的前两篇博客再来看本篇博客，关于本次实验的环境，和思想在第一篇博客已经简单介绍过了，所以不再赘述，我会先介绍大数的乘法载介绍大数的除法，乘法的难点在于要使用一个嵌套循环，除法的难点在于一个字使用符串比较方法的技巧，本次还是会将算法都写成函数，然后在main()函数中调用，原因是在第四篇我们要将整个大数运算的方法做成自己的一个库文件，可以供自己或他人使用。
 
大数乘法： 
 由于乘法可以互换所以对于输入的数字没有限制条件，计算方法还是模仿手工算法，由被乘数的低位开始和乘数的每一位相乘并且要将大于９的十位数向前进一位，存在３个问题需要我们解决。
 
问题： 
 １　我们要用多大的数组存储结果？ 
 ２　要使用嵌套循环吗？ 
 ３　如何在计算的过程中保证进位？
 
其实问题也很好解决，前两个问题都可以看出答案，最后一个问题和前两篇博客的进位问题很相似，所以简单的说明后再看注释的代码是很好懂的。 
 １　二个数相乘最大的位数是两个乘数的位数之和。 
 ２　很明显由于乘法的特性使用嵌套循环很合适。 
 ３　在大数加减中执行完毕后再对存储结果的result数组进行一次进位，但在乘法中我们需要每执行一趟就要对数组进行进位的处理。
 
实现： 
 下面是全面的含有注释的代码。
 
  1 //#include"big.h"
  2 #include<stdio.h>
  3 #include<stdlib.h>
  4 #include<string.h>
  5 char * bigmul(char *m,int lena,char *f,int lenb){  //乘法运算函数。
  6    int i,j,k,lensum,tmp_result,carry,num='0';
  7    lensum=lena+lenb;                               //确定结果数组的长度。
  8    for(i=0;i<lena;i++){                            //将ASCII码转为对应的数字存储。
  9       m[i]=m[i]-num;
 10    }
 11    for(i=0;i<lenb;i++){
 12       f[i]=f[i]-num;
 13    }
 14    char *result,final[BUFSIZ];
 15    result=(char*)calloc(lensum,1);
 16    for(i=0;i<lenb;i++){                      //为被乘数作一趟乘法。
 17       for(j=0;j<lena;j++){
 18          tmp_result=f[lenb-i-1]*m[lena-j-1];
 19          result[j+i]+=tmp_result;
 20       }
 21       for(k=0;k<=j+i-1;k++){                 //每作一趟乘法整理一次结果数组。
 22          if(result[k]>9){
 23             carry=result[k]/10;
 24             result[k]=result[k]%10;
 25             result[k+1] += carry;
 26          }
 27       }
 28    }
 29    j=0;
 30    if(result[lensum-1]!=0){                  //去除前导零将结果整理到final数组中。
 31       final[j]=result[lensum-1]+num;
 32       j++;
 33    }
 34    for(i=lensum-2;i>=0;i--){
 35       final[j++]=result[i]+num;
 36    }
 37    result=final;                             //将指针指向final数组并返回该指针。      
 38    return result;
 39 }
 40 int main(){                                                 //利用main测试方法，用puts打印结果。               
 41    int lena,lenb;
 42    char *result,sa[BUFSIZ],sb[BUFSIZ];
 43    scanf("%s",sa);
 44    scanf("%s",sb);
 45    lena=strlen(sa);
 46    lenb=strlen(sb);
 47    result=bigmul(sa,lena,sb,lenb);
 48    puts(result);
 49 
 50 }
 
下面是大数除法。
 
前言： 
 大数除法的难点在于思考算法，可以用连续的减法来实现，举个简单了例子：３２／２可以用３２连续减去２每减一次ｉ加一，当差小于被减数时停止。ｉ即为商，由于我们前面实现了大数减法所以用该方法可以实现，但是有一个问题就是如果用一亿除以一那么就需要执行一亿次，况且我们做的是大数数算，输入１００位以上的数也都是有可能的，那么计算的时间就是几天，几年，几万年都有可能。所以只有模仿手工的方法，从高位开始计算。３２／２从高位先用３－２只能减１次，将余数保留变成１２／２，可以减６次，从而得到结果１６极大的降低了循环减的次数。
 
大数除法： 
 有很多问题大多都是的我们前面遇到的问题，例如结果数组的位数，对数组的整理进位问题，嵌套循环和乘法相同按趟执行，既然是相似的问题我就不再说了。
 
注意： 
 除法对数据有限制不能分母为零，分母为零没有意义，不能用小数除以大数，因为小数除以大数本质还是大数除以小数结果加个分之一就可以了。 
 返回的结果是保存商的数组的指针，不包含余数。
 
实现： 
 下面是完整的含有注释的代码，如果想判断输入，或输入余数，可自行修改代码。
 
  1 //#include"big.h"
  2 #include<stdio.h>
  3 #include<string.h>
  4 char diva[BUFSIZ],divb[BUFSIZ];
  5 char result_tmp[BUFSIZ];
  6 char final[BUFSIZ];
  7 char * bigdiv(char *diva,int lena,char *divb,int lenb){        //大数除法函数。
  8     int i,j,k;
  9     char  * result;
 10 /*          if((lena<lenb||lena==lenb)&&strcmp(diva,divb)<0){  //去除了以小除大的判断
 11                 printf("0 余数=");//求余数  
 12                 for(i=0; i<lena; i++)  
 13                     printf("%d",diva[i]-'0');  
 14                 printf("\n");  
 15                 return result;
 16             }  
 17 */
 18             k=0;
 19             while(1){                        //死循环只有当lena和lenb相等时跳出循环，因为会不断的在divb数组前加0所以该数组的长度，
 20                                              //会不断的变化当两者相等时说明已经无法在作减法。
 21                 result_tmp[k]=0;
 22                 while(strcmp(diva,divb)>=0){ //用字符串比较的方法是一个亮点，很巧妙。因为strcmp()比较的方式是从前到后依次比较 
 23                  int i=0,j;                  //如果相等则向后移动一位一旦发现不等则立即返回忽略后面的所有数据。
 24                      while(1){
 25                         if(diva[i]=='0') i++;//去除diva高位前面的0
 26                         else{
 27                            j=i;              //去除divb高位填充的0
 28                          break;  
 29                         }  
 30                }
 31     
 32                for(; i<lenb; i++)            //作减法
 33                diva[i]=diva[i]-divb[i]+'0';
 34                for(i=lenb-1; i>j; i--)       //每作一组减法就整理数组，这种整理数组在前几篇中都有使用。
 35                if(diva[i]<'0'){              //不过在这里不是整理结果数组而是diva数组，结果保存在ａ数组中不用整理
 36                   diva[i]+=10;;
 37                   diva[i-1]--;
 38                }
 39                     result_tmp[k]++;
 40 
 41                }
 42                   k++;
 43                   if(lena==lenb)   break;
 44                   for(i=lenb-1; i>=0; i--)   //将divb中的元素先后移位，同时扩大divb长度并且在divb前端补一位0。
 45                     divb[i+1]=divb[i];
 46                   divb[0]='0';               //由于数组后移所以divb[0]每次移动后都为空，所以每次用0补齐。
 47                   lenb++;
 48                   divb[lenb]='\0';           //在结尾加上字符串的结束标记。
 49             }
 50             i=0;j=0;
 51             while(result_tmp[i]==0) i++;
 52             for(; i<k; i++){
 53                 final[j++]=result_tmp[i]+'0';
 54 
 55             }
 56             result=final;
 57 /* 
 58             printf(" 余数=");  
 59             j=0;//求余数  
 60             while(diva[j]=='0')  j++;  
 61             if(j==lena)  
 62             {  
 63                 printf("0\n");  
 64                 continue;  
 65             }  
 66             for(; j<n; j++)  
 67                 printf("%d",diva[j]-'0');  
 68             printf("\n");  
 69       */
 70 
 71             return result;
 72 
 73 }
 74 int main(){                                                 //利用main测试方法，用puts打印结果。               
 75    int lena,lenb;
 76    char *result,sa[BUFSIZ],sb[BUFSIZ];
 77    scanf("%s",sa);
 78    scanf("%s",sb);
 79    lena=strlen(sa);
 80    lenb=strlen(sb);
 81    result=bigdiv(sa,lena,sb,lenb);
 82    puts(result);
 83 
 84 }
 
所有的运算到此完结最后一篇做一个大数运算库，有时间我会把库放到github如果以后有时间我会做些优化并且加入对浮点的支持。

对于大数的处理，由于double类型甚至long long数据类型都无法储存大数，所以我们把大数当成字符串来处理。不论是大数的加法还是大数的减法我们都应该从低位开始操作，但是输入时往往从高位开始操作，因此我们需要书写倒序函数。
 
//逆序函数
void rev(char str[], int len)
{
    char t;
    for(int i = 0; i < len / 2; ++i){
        t = str[i];
        str[i] = str[len - i - 1];
        str[len - i - 1] = t;
    }
}
 
大数加法：
 首先将两个大数保存到数组中，然后对数组逆序后进行逐位分别相加，相加后判断是否有进位（用carry变量来记录）。
 代码实现：
 
//加法
int main()
{
    char a[1000],b[1000],c[1000];
    int ai, bi, val, carry;        
    int len, len1, len2;
    scanf("%s %s", a, b);
    len1 = strlen(a);
    len2 = strlen(b);
    //如果len1 > len2，len = len1;否则len = len2
    len = len1 > len2 ? len1 : len2;
    rev(a,len1);
    rev(b,len2);
    carry = 0;//进位
    for(int i = 0; i < len; ++i){
        ai = i < len1 ? a[i] - '0' : 0;
        bi = i < len2 ? b[i] - '0' : 0;
        val = (ai + bi + carry) % 10;
        carry = (ai + bi + carry) /10;
        c[i] = val + '0';
    }
    if(carry == 1) putchar('1');
    for(int i = len - 1; i >=0 ; --i)
        putchar(c[i]);
    puts("");

    return 0;
}
 
大数减法：
 与大数的加法类似，减法运算可以看做异号加法，结果的最大位数和较大的减数位数相同，可以把被减数缺少的位数用零补全然后相减，也可以只减到被减数的位数，然后将减数的高位直接写到结果的数组中。
 
int main()
{
    char a[1000],b[1000],c[1000];
    int ai, bi, val, bit;
    int len, len1, len2;
    scanf("%s %s", a, b);
    len1 = strlen(a);
    len2 = strlen(b);
    len = len1 > len2 ? len1 : len2;
    rev(a,len1);
    rev(b,len2);
    bit = 0;
    for(int i = 0; i < len; ++i){
        ai = i < len1 ? a[i] - '0' : 0;
        bi = i < len2 ? b[i] - '0' : 0;
        ai -= bit;
        bit = 0;
        if(ai - bi < 0){
            bit ++;
            ai += 10;
        }
        c[i] = ai - bi + '0';
        int flag = 1;
        // 1 0 6 0 0
        for(int i = len - 1; i >= 0; i--){
            if(c[i] == '0' && flag)
            continue;
            flag = 0;
            putchar(c[i]);
        }
        puts("");
    }
    return 0;
}
 
*大数乘法：
 对于大数乘法运算以乘法的每一位去乘以被乘数。例如，首先以乘数的个位去乘被乘数，将结果通过进位处理后保存到结果位中。接着用乘数的十位去乘以被乘数，将每位计算结果累加到最终结果中。注意：两个数相乘最大的位数是两个乘数的位数之和，在乘法中我们需要每执行一次乘法就要对数组进行进位的处理。
 
大数乘法函数实现代码：
 
void BigIntMul(pBIGINT num1,pBIGINT num2,pBIGINT result)
{
    char carry,temp;
    int i,j,pos;
    //结果数组和中间数清0 
    for(i=0;i<num1->digit+num2->digit;i++)     
        result->num[i]=0;
    //用乘数的每一位乘以被乘数 
    for(i=0;i<num2->digit;i++)               
    {
        carry=0;                              //清除进位 
        //被乘数的每一位 
        for(j=0;j<num1->digit;j++)                  
        {
            //相乘并加上进位 
            temp=num2->num[i] * num1->num[j]+carry;    
             //计算进位carry 
            carry =temp/10; 
            //计算当前位的值                       
            temp=temp%10;                         
            pos=i+j;
            //计算结果累加到临时数组中 
            result->num[pos]+=temp;             
            carry=carry+result->num[pos]/10;           //计算进位 
            result->num[pos]=result->num[pos]%10; 
        }
        if(carry>0)
        {
            result->num[i+j]=carry;                //加上最高位进位 
            result->digit=i+j+1;                  //保存结果位数 
        }else
            result->digit=i+j;                   //保存结果位数 
    } 
    result->sign=num1->sign * num2->sign;        //结果的符号 
}
 
大数除法：
 对于大数除法运算，首先取被除数的最高两位作为部分被除数，去除以除数，根据该部分被除数与除数的结果——商，得到一位数的商。 除法对数据有限制不能分母为零，分母为零没有意义；不能用小数除以大数。
 
代码实现（返回的结果是保存商的数组的指针，不包含余数。）
 
void BigIntDiv(pBIGINT num1,pBIGINT num2,pBIGINT result,pBIGINT residue)
{
    BIGINT residol;
    int i,j,k,m;               //k保存试商结果，m保存商的位数 
    char t;
    result->sign = num1->sign * num2->sign;        //商的符号 
     //分配余数的内存空间
    residue->num =(char *)malloc(sizeof(char) * num2->digit);   
    for(i=0;i<residue->digit;i++)            //将余数全部清0 
        residue->num[i]=0;
    m=0;
    for(i=num1->digit-1;i>=0;i--)
    {
        //重新设置余数的位数比除数多一位 
        residue->digit=num2->digit+1;       
        for(j=num2->digit-1;j>0;j--)               //移余数 
            residue->num[j]=residue->num[j-1];
        //复制被除数中的一位到余数的最低位中 
        residue->num[0]=num1->num[i];          
        BigIntTrim(residue);                  //整理余数 
        k=0;                                      //试商 
         //比较余数与除数的大小 
        while(BigIntEqual(residue,num2)>=0)    
        {
            BigIntSub1(residue,num2,residue);     //用余数减去除数，差值保存在余数中 
            k++;                       //试商加1 
        } 
        result->num[m++]=k;           //保存商 
    }
    result->digit=m;                 //保存商的位数 
    for(i=0;i<m/2;i++)              //反转商的值            
    {
        t=result->num[i];
        result->num[i]=result->num[m-1-i];
        result->num[m-1-i]=t; 
    } 
    BigIntTrim(result);          //整理商 
    BigIntTrim(residue);            //整理余数 
 }

概率论与数理统计分成两大块，前一大块就是研究随机变量这个东西，一维的，二维的，连续的，离散的。研究他们的分布函数，概率密度函数或是分布律，然后有随机变量的性质和一些常见的概率分布。
 后边这一大块主要就是讲怎么通过一些样本得到这个随机变量。
 
参数估计
 
讲的就是估计随机变量的参数，分为点估计和区间估计。点估计就是给出一个值，而区间估计是给出一个区间。点估计分为矩估计和极大似然法估计。
 
矩估计就是让样本的k阶原点矩（Mk）等于总体的k阶原点矩（mk），然后求出要求的参数.k阶原点矩，说白了就是x的k次的均值。
 做题步骤
 1.令M1=m1或是M2=m2,具体是1还是2要看具体情况。
 2.把M1和m1都求出来，然后相等，解出参数。
 注意：总体的期望等于样本的均值，总体的方差等于样本的二阶中心矩。（证明还没看懂，先做题再说）
 m1=Ex，m2=Ex2，M1就是样本的均值，M2就是样本平方的均值。
 极大似然法估计则是构造一个极大似然函数L（Θ），就是样本的概率密度函数乘到一起，然后找Θ的值，使得这个函数的值最大。
 做题步骤
 1.先求出单个样本的概率密度函数，或者是分布律，然后根据这个概率密度函数求出极大似然函数
 2.然后将函数两边取对数，在求导，令导数等于零，求出来的Θ就是要求的极大似然估计量。
 3.将样本带入其中，就求出了极大似然估计值。
 
注意：极大似然估计值的关键就在于找出让似然函数最大时Θ的值，当写出似然函数以后，如果能一眼看出来是单调递增或者单调递减的话，就不用取对数求导，如果是单增或者单减的话，Θ肯定会有一个取值范围，然后根据取值范围判断Θ的值。
 
PS::
对数的运算法则
1.两个正数的积的对数，等于同一底数的这两个数的对数的和，即
㏒₃(N·M)=㏒₃N+㏒₃M
2.两个正数商的对数，等于同一底数的被除数的对数减去除数对数的差，即
㏒₃（N/M)=㏒₃N﹣㏒₃M (以上所有下标₃等同于a）
 
估计量的性质
 无偏性，有效性，相合性
 无偏性
 根据样本选取的估计量本质上还是随机变量，是随机变量就会有他的期望。如果这个随机变量的期望等于你要估计的参数的真实的值，那么这个估计量就是无偏的。所以要看一个估计量是不是无偏的，就去求他的期望，看期望和真实的值是否有差别。
 有效性
 怎么判断一个估计量是不是有效的呢？如果这个估计量的方差很大，那么就算你这个估计量很准确，也没啥用。因为我们最好要估计一个确定的值，方差越大就越不容易实现这一目标。
 所以判断一个估计量比另一个估计量小的方法就是这个估计量的差小。
 相合性
 如果一个估计量他随着n的增大，估计量越来越接近于估计参数的真值，那么这个估计量就具有相合性。
 
区间估计
 区间估计就是估计一个参数的区间，不是估计出一个值而是估计出这个参数可能取值的区间。这个就分为对μ的估计和对σ的估计，做题的话，就要熟记那一张表。
 反正关于μ的是要背会。分为σ已知和σ未知。已知的话服从标准正态分布，未知的话服从t（n-1）分布。
 做题步骤
 1.列出公式
 2.带值，求出置信区间。
 
假设检验
 
假设检验也是对总体的某个参数的估计。假设参数是某个值或者大于或小于某个值，看这个假设对不对。
 
 
 做题步骤
 1.写出假设。
 2.写出拒绝域。
 3.带入数值，如果在这个拒绝域内，就拒绝原假设
 
 
 
时间：2019.12.12晚，2019.12.13早,2019年12.13下午
 

简介
 
一般地，对数函数是以幂（真数）为自变量，指数为因变量，底数为常量的函数。
 
对数函数是6类基本初等函数之一。其中对数的定义：
 
如果ax =N（a>0，且a≠1），那么数x叫做以a为底N的对数，记作x=logaN，读作以a为底N的对数，其中a叫做对数的底数，N叫做真数。
 
一般地，函数y=logaX（a>0，且a≠1）叫做对数函数，也就是说以幂（真数）为自变量，指数为因变量，底数为常量的函数，叫对数函数。
 
其中x是自变量，函数的定义域是（0，+∞），即x>0。它实际上就是指数函数的反函数，可表示为x=ay。因此指数函数里对于a的规定，同样适用于对数函数。
 
在实数域中，真数式子没根号那就只要求真数式大于零，如果有根号，要求真数大于零还要保证根号里的式子大于等于零（若为负数，则值为虚数），底数则要大于0且不为1。
 
对数函数
 
对数函数的底数为什么要大于0且不为1？【在一个普通对数式里 a<0，或=1 的时候是会有相应b的值。但是，根据对数定义：log以a为底a的对数；如果a=1或=0那么log以a为底a的对数就可以等于一切实数（比如log11也可以等于2，3，4，5，等等）】
 
通常我们将以10为底的对数叫常用对数（common logarithm），并把log10N记为lgN。另外，在科学计数中常使用以无理数e=2.71828···为底数的对数，以e为底的对数称为自然对数（natural logarithm），并且把logeN 记为In N。根据对数的定义，可以得到对数与指数间的关系：
 
当a>0，a≠1时，aX=N
 
 
 X=logaN。（N>0）
 
由指数函数与对数函数的这个关系，可以得到关于对数的如下结论：
 
在实数范围内，负数和零没有对数；
 
  ，log以a为底1的对数为0（a为常数） 恒过点（1，0）。
 
有理和无理指数
 
如果  是正整数，   表示等于  的
 
 个因子的加减:
 
加减
 
但是，如果是   不等于1的正实数，这个定义可以扩展到在一个域中的任何实数  （参见幂）。类似的，对数函数可以定义于任何正实数。对于不等于1的每个正底数   ，有一个对数函数和一个指数函数，它们互为反函数。
 
对数可以简化乘法运算为加法，除法为减法，幂运算为乘法，根运算为除法。所以，在发明电子计算机之前，对数对进行冗长的数值运算是很有用的，它们广泛的用于天文、工程、航海和测绘等领域中。它们有重要的数学性质而在今天仍在广泛使用中。
 
复对数
 
复对数计算公式
 
复数的自然对数，实部等于复数的模的自然对数，虚部等于复数的辐角。
 
 
 
产生历史
 
编辑
 
16世纪末至17世纪初的时候，当时在自然科学领域（特别是天文学）的发展上经常遇到大量精密而又庞大的数值计算，于是数学家们为了寻求化简的计算方法而发明了对数 [1]  。
 
德国的史蒂非（1487-1567）在1544年所著的《整数算术》中，写出了两个数列，左边是等比数列（叫原数），右边是一个等差数列（叫原数的代表，或称指数，德文是Exponent ，有代表之意）。
 
欲求左边任两数的积（商），只要先求出其代表（指数）的和（差），然后再把这个和（差）对向左边的一个原数，则此原数即为所求之积（商），可惜史提非并未作进一步探索，没有引入对数的概念。
 
纳皮尔对数值计算颇有研究。他所制造的「纳皮尔算筹」，化简了乘除法运算，其原理就是用加减来代替乘除法。 他发明对数的动机是为寻求球面三角计算的简便方法，他依据一种非常独等的与质点运动有关的设想构造出所谓对数方法，其核心思想表现为算术数列与几何数列之间的联系。在他的1619年发表《奇妙的对数表的描述》中阐明了对数原理，后人称为 纳
 
对数的图像
 
皮尔对数，记为Nap．㏒x，它与自然对数的关系为：
 
Nap．㏒x=10㏑（107/x）
 
由此可知，纳皮尔对数既不是自然对数，也不是常用对数，与现今的对数有一定的距离。
 
瑞士的彪奇（1552-1632）也独立地发现了对数，可能比纳皮尔较早，但发表较迟（1620）。
 
英国的布里格斯在1624年创造了常用对数。
 
1619年，伦敦斯彼得所著的《新对数》使对数与自然对数更接近（以e=2.71828...为底）。
 
对数的发明为当时社会的发展起了重要的影响，简化了行星轨道运算问题。正如科学家伽利略（1564-1642）说：「给我时间，空间和对数，我可以创造出一个宇宙」。 又如十八世纪数学家拉普拉斯（ 1749-1827）亦提到：「对数用缩短计算的时间来使天文学家的寿命加倍」。
 
最早传入我国的对数著作是《比例与对数》，它是由波兰的穆尼斯（1611-1656）和我国的薛凤祚在17世纪中叶合 编而成的。当时在lg2=0.3010中，2叫真数，0.3010叫做假数，真数与假数对列成表，故称对数表。后来改用假数为对数」。
 
我国清代的数学家戴煦（1805-1860）发展了多种求对数的捷法，著有《对数简法》（1845）、《续对数简法》（1846）等。1854年，英国的数学家艾约瑟（1825-1905）看到这些著作后，大为叹服。
 
当今中学数学教科书是先讲「指数」，后以反函数形式引出「对数」的概念。但在历史上，恰恰相反，对数概念不是来自指数，因为当时尚无分指数及无理指数的明确概念。布里格斯曾向纳皮尔提出用幂指数表示对数的建议。1742年，J．威廉（1675-1749）在给G.威廉的《对数表》所写的前言中作出指数可定义对数。而欧拉在他的名著《无穷小分析寻论》（1748）中明确提出对数函数是指数函数的逆函数，和21世纪的教科书中的提法一致。
 
 
函数性质
 
编辑
 
定义域求解：对数函数y=logax 的定义域是{x 丨x>0}，但如果遇到对数型复合函数的定义域的求解，除了要注意大于0以外，还应注意底数大于0且不等于1，如求函数y=logx（2x-1）的定义域，需同时满足x>0且x≠1
 
和2x-1>0 ，得到x>1/2且x≠1，即其定义域为 {x 丨x>1/2且x≠1}
 
值域：实数集R，显然对数函数无界；
 
定点：对数函数的函数图像恒过定点（1，0）；
 
单调性：a>1时，在定义域上为单调增函数；
 
0<a<1时，在定义域上为单调减函数；
 
奇偶性：非奇非偶函数
 
周期性：不是周期函数
 
对称性：无
 
最值：无
 
零点：x=1
 
注意：负数和0没有对数。
 
两句经典话：底真同对数正，底真异对数负。解释如下：
 
也就是说：若y=logab （其中a>0，a≠1，b>0）
 
当0<a<1， 0<b<1时，y=logab>0;
 
当a>1， b>1时，y=logab>0;
 
当0<a<1， b>1时，y=logab<0;
 
当a>1， 0<b<1时，y=logab<0。
 
 
公式推导
 
编辑
 
e的定义：
 
 
设a>0，a≠1
 
方法一： 
 
指数函数
 
 
 
 
 
 
 
特殊地，当   时，
 
    。
 
方法二：
 
设  ，两边取对数ln y=xln a
 
 
 
两边对x求导：y'/y=ln a，y'=yln a=a^xln a
 
特殊地，当a=e时，y'=（a^x）'=（e^x）'=e^xln e=e^x。
 
eº=1
 
 
运算性质
 
编辑
 
 
性质
 
一般地，如果a（a>0，且a≠1）的b次幂等于N，那么数b叫做以a为底N的对数，记作logaN=b，其中a叫做对数的底数，N叫做真数。
 
底数则要>0且≠1 真数>0
 
并且，在比较两个函数值时：
 
如果底数一样，真数越大，函数值越大。（a>1时）
 
如果底数一样，真数越小，函数值越大。（0<a<1时）
 
当a>0且a≠1时，M>0，N>0，那么：
 
对数函数化简问题
 
 
和差
 
和差
 
 
换底公式
 
换底公式
 
推导：设
 
换底公式
 
所以
 
换底公式
 
两边取对数，则有
 
换底公式
 
即
 
换底公式
 
又因为
 
换底公式
 
所以
 
换底公式
 
 
指系
 
指系
 
 
互换
 
互换
 
 
倒数
 
倒数
 
 
链式
 
链式 [2]
 
 
表达方式
 
编辑
 
（1）常用对数：lg（b）=log10b（10为底数）。
 
（2）自然对数：ln（b）=logeb（e为底数）。
 
e为无限不循环小数，通常情况下只取e=2.71828。
 
 
与指数的关系
 
编辑
 
同底的对数函数与指数函数互为反函数。
 
当a>0且a≠1时，ax=N
 
 
 x=㏒aN。
 
关于y=x对称。
 
对数函数的一般形式为 y=㏒ax，它实际上就是指数函数的反函数（图象关于直线y=x对称的两函数互为反函数），可表示为x=ay。因此指数函数里对于a的规定（a>0且a≠1），右图给出对于不同大小a所表示的函数图形：关于X轴对称、当a>1时，a越大，图像越靠近x轴、当0<a<1时，a越小，图像越靠近x轴。
 
可以看到，对数函数的图形只不过是指数函数的图形的关于直线y=x的对称图形，因为它们互为反