精华内容
下载资源
问答
  • 表格/列表法之分部积分

    万次阅读 多人点赞 2020-05-28 18:13:32
    成表格 表中内容可分为三部分 图中红色地方表示正 比如v∫u dx,v′′∫∫∫u dxv\int u\,dx,v''\int\int\int u\,dxv∫udx,v′′∫∫∫udx 图中黑色地方表示负 比如−v′∫∫u dx-v'\int\int

    在求积分的过程中,我们经常使用微积分里的分布积分法,但对于一些复杂的函数,需要运用多次分布积分,比如你可能见过这样的,
    在这里插入图片描述
    处理起来很是头疼,然而用表格法就能起到这样的效果
    在这里插入图片描述
    在这里插入图片描述
    下面说明一下如何使用这种方法
    对积分 ∫ v u   d x \int vu\,dx vudx
    列成表格
    在这里插入图片描述
    第一行表示求导,第二行求原函数
    表中内容可分为三部分,连线的地方将他们相乘
    图中红色地方表示正
    比如 v ∫ u   d x , v ′ ′ ∫ ∫ ∫ u   d x v\int u\,dx,v''\int\int\int u\,dx vudx,vudx
    图中黑色地方表示负
    比如 − v ′ ∫ ∫ u   d x -v'\int\int u\,dx vudx
    绿色地方表示
    ( − 1 ) n ∫ ( v n ( ∫ ) n u ) d x (-1)^n\int (v^n(\int)^nu)dx (1)n(vn()nu)dx 注意:这里的n表示求导或积分的总次数
    最后把这三部分加起来即可,不理解的话请看下面这个例子


    C n = 2 l ∫ 0 l x ( l − x ) s i n n π x l d x Cn =\frac{2}{l}\int_0^l x(l-x)sin\frac{nπx}{l}dx Cn=l20lx(lx)sinlnπxdx
    正常计算:
    在这里插入图片描述
    表格法:

    x ( l − x ) x(l-x) x(lx) l − 2 x l-2x l2x − 2 -2 2
    2 l s i n n π x l \frac2lsin\frac{nπx}{l} l2sinlnπx − 2 n π c o s n π x l -\frac{2}{nπ}cos\frac{nπx}{l} nπ2coslnπx − 2 l n 2 π 2 s i n n π x l -\frac{2l}{n^2π^2}sin\frac{nπx}{l} n2π22lsinlnπx

    C n = [ x ( l − x ) ( − 2 n π c o s n π x l ) − ( l − 2 x ) ( − 2 l n 2 π 2 s i n n π x l ) ] ∣ l 0 ∣ + Cn=\left[x(l-x)(-\frac{2}{nπ}cos\frac{nπx}{l})\right.\\-(l-2x)(-\frac{2l}{n^2π^2}sin\frac{nπx}{l})]\begin{vmatrix} l \\ 0\end{vmatrix}+ Cn=[x(lx)(nπ2coslnπx)(l2x)(n2π22lsinlnπx)]l0+ ( − 1 ) 2 ∫ 0 l ( − 2 ) − 2 l n 2 π 2 s i n n π x l d x (-1)^2\int_0^l(-2) \frac{-2l}{n^2π^2}sin\frac{nπx}{l}dx (1)20l(2)n2π22lsinlnπxdx
    = 0 − 4 l 2 n 3 π 3 c o s n π x l ∣ l 0 ∣ =0-\frac{4l^2}{n^3π^3}cos\frac{nπx}{l}\begin{vmatrix} l \\ 0\end{vmatrix} =0n3π34l2coslnπxl0
    = 4 l 2 n 3 π 3 ( 1 − c o s n π ) =\frac{4l^2}{n^3π^3}(1-cosnπ) =n3π34l2(1cosnπ)

    如果还不太懂可以看一下文章开头的那个例子,自己算一下

    运用表格法只需进行对被积函数进行求导积分运算,一步得结果,大大减少了出错率。

    在这里插入图片描述

    展开全文
  • 列表之链接

    千次阅读 2015-06-14 12:38:37
    列表之链接列表的定义 散列表的基本操作 散列表的编码实现 散列表的设计 主测试文件 编译运行 结论注意: 本文中的所有代码你可以在这里 ...或者这里 ...

    注意:
    本文中的所有代码你可以在这里
    https://github.com/qeesung/algorithm/tree/master/chapter11/11-2/hashTable(这里会及时更新)
    或者这里
    http://download.csdn.net/detail/ii1245712564/8804203
    找到

    散列表之链接法

    在之前的文章《散列表之直接寻址表》中介绍了散列表中一种最基本的类型,直接寻址表。直接寻址表是通过键值直接来寻找在在数组里面的映射位置,但是直接寻址表存在一个缺陷,在键值范围较大且元素个数不多的时候,空间利用率不高,比如现在我们只需要映射两个元素 (key:1,data1) (key:10000,data2) ,此时我们需要分配一个大小为 10001 的数组,将第一个元素放到数组的 1 位置,第二个元素放到数组的最后一个位置,剩下的所有数组位置都没有被用到,造成空间的浪费。

    于是,针对上面的情况,我们想到了下面的解决方案

    hash(key)={01,key=1,key=10000

    通过散列函数 hash ,来将 key 映射到合适的位置上,即通过 hash(key) 来找到在数组上的位置,最后我们只需要一个大小为2的数组就可以了。

    散列表的定义

    在直接寻址的方式下,具有关键字 k 的元素被放到数组位置k中。在散列方式下,该元素放在数组的 hash(k) 位置中,即通过散列函数hash(hash function)传入键值 k 来计算元素在数组中合适的位置。

    假设我们有一集合U={d1,d2,d3,...dn},集合中过的每一个元素 di 都有一个键值 keyi 和一个数组值 datai ;新建一个数组 T=[0...m] ,遍历一遍集合 U ,将集合中的每一个元素都放到数组的hash(key)位置上。

    这里的散列表大小 m 一般要比集合的大小U小的多,可以说是具有关键字 k 的元素被散列到hash(k),也就是说 hash(k) 是键值 k 的散列值。

    Alt text

    散列表的基本操作

    散列表的基本操作有:

    • INSERT:插入一个元素
    • DELETE:删除一个元素
    • SEARCH:搜索一个元素

    在我们进行编码实现之前,先来考虑一下下面几个问题

    问题1:散列函数hash该怎么设计?
    回答1:散列函数的设计关乎到整个散列表的运行效率,所以不可等闲待之,需要针对输入的元素集合来设计合适的散列函数,这也是散列表中最大的难点,比如在之前的例子中,我们设计的散列函数很简单,如果输入的key是1,就返回0,如果输入的key是1000,那么就返回1.如果把这个集合运用到其他集合上,那么就是一个很差劲的散列函数


    问题2:因为集合 U 的大小|U|远大于散列表的大小 m ,所以经常会发生不同键值却有相同散列值的情况,于是散列表的同一个位置就会发生冲突,这时应该怎么办?
    回答2:我们可以采用链表的形式,将散列值相同的元素放入同一链表里面,再将列表挂在散列表的对应位置上。
    Alt text

    散列表的编码实现

    下面是用到的文件,我们只列出部分的文件的内容,你可以在这里获得全部内容:
    https://github.com/qeesung/algorithm/tree/master/chapter11/11-2/hashTable

    .
    ├── hash_table.cc 散列表源文件
    ├── hash_table.h 散列表头文件
    ├── hash_table_test.cc 散列表测试源文件
    ├── hash_table_test.h 散列表测试头文件
    ├── link_list.cc 链式链表源文件
    ├── link_list.h 链式链表头文件
    ├── list.h 链表接口文件
    ├── main.cc 主测试文件
    ├── Makefile
    └── README.md
    
    0 directories, 10 files

    散列表的设计

    hash_table.h

    #ifndef  HASHTABLE_INC
    #define  HASHTABLE_INC
    
    #include "link_list.h"
    #include <vector>
    
    /**
     *        Class:  LinkHashTable
     *  Description:  链接法散列表
     */
    template < class T >
    class LinkHashTable
    {
        public:
            /** ====================  LIFECYCLE     ======================================= */
            LinkHashTable (int table_size=0 , int(*_HASH)(const T &)=0);                             /** constructor */
            /** ====================  MUTATORS      ======================================= */
            bool hash_insert(const T &); /*插入操作*/ 
            bool hash_delete(const T &);  /*删除操作*/ 
            std::vector<T> hash_search(int) const; /*查找操作*/ 
            void clear();
            void printToVec(std::vector<std::vector<T> > & );
        private:
            /** ====================  DATA MEMBERS  ======================================= */
            int (*HASH)(const T &);// 定义一个散列函数指针
            LinkList<T> * array; //链表的数组 
            const size_t table_size;// 散列表的大小
    }; /** ----------  end of template class LinkHashTable  ---------- */
    
    #include "hash_table.cc"
    #endif   /* ----- #ifndef HASHTABLE_INC  ----- */

    散列表的成员中有一个散列函数的指针HASH,用户在构造散列表的时候需要制定对应的散列函数,还有一个array指针,是用来指向散列表的起始地址的。

    hash_table.cc

    #include "link_list.h"
    /**
     *       Class:  LinkHashTable
     *      Method:  LinkHashTable
     * Description:  
     */
    template < class T >
    LinkHashTable < T >::LinkHashTable (int _table_size , int(*_HASH)(const T &)) :\
            table_size(_table_size),HASH(_HASH)
    {
        array = new LinkList<T>[table_size]();
    }  /** ----------  end of constructor of template class LinkHashTable  ---------- */
    
    
    template < class T >
    bool LinkHashTable<T>::hash_insert (const T & ele)
    {
        int index = HASH(ele);
        if(index >= table_size || index <0)
            return false;
        return array[index].insert(ele);
    }       /** -----  end of method LinkHashTable<T>::hash_insert  ----- */
    
    
    template < class T >
    bool LinkHashTable<T>::hash_delete (const T & ele)
    {
        int index = HASH(ele);
        if(index >= table_size || index <0)
            return false;
        return array[index].remove(ele);
    }       /** -----  end of method LinkHashTable<T>::hash_delete  ----- */
    
    
    template < class T >
    std::vector<T> LinkHashTable<T>::hash_search (int k) const
    {
        if(k < 0 || k >= table_size)
            return std::vector<T>(); 
        std::vector<int> vec;
        array[k].printToVec(vec);
        return vec;
    }       /** -----  end of method LinkHashTable<T>::hash_search  ----- */
    
    
    
    template < class T >
    void LinkHashTable<T>::clear ()
    {
        for(int i =0 ; i < table_size ; ++i)
        {
            array[i].clear();
        }
        return ;
    }       /** -----  end of method LinkHashTable<T>::clear  ----- */
    
    
    template < class T >
    void LinkHashTable<T>::printToVec (std::vector<std::vector<T> > & vec)
    {
        for(int i =0 ; i < table_size ; ++i)
        {
            std::vector<int> tempVec;
            array[i].printToVec(tempVec);
            vec.push_back(tempVec);
        }
        return ;
    }       /** -----  end of method LinkHashTable<T>::printToVec  ----- */

    主测试文件

    main.cc

    #include <stdlib.h>
    #include "hash_table_test.h"
    #include <cppunit/ui/text/TestRunner.h>
    #include <cppunit/TestCaller.h>
    #include <cppunit/TestSuite.h>
    
    
    
    /** 
     * +++  FUNCTION  +++
     *         Name:  main
     *  Description:  测试的主函数
     */
    int main ( int argc, char *argv[] )
    {
        CppUnit::TextUi::TestRunner runner; 
        CppUnit::TestSuite * suite = new CppUnit::TestSuite();
    
        suite->addTest(new CppUnit::TestCaller<HashTableTest>("Test insert by qeesung", &HashTableTest::test_insert));
        suite->addTest(new CppUnit::TestCaller<HashTableTest>("Test delete by qeesung", &HashTableTest::test_delete));
        suite->addTest(new CppUnit::TestCaller<HashTableTest>("Test search by qeesung", &HashTableTest::test_search));
        runner.addTest(suite);
        runner.run("",true);
        return EXIT_SUCCESS;
    
        return EXIT_SUCCESS;
    }               /** ----------  end of function main  ---------- */

    编译运行

    编译方法

    • 如果你安装了cppunit
    make
    • 如果没有安装cppunit,你需要这样编译
    g++ hash_table_test.cc youSourceFile.cc -o target

    运行方法

    ./hashTest(or your target)

    结论

    散列表最重要的是设计一个性能良好的散列函数(hash function),这也是散列表的难点,如果散列函数设计差劲的话,有可能造成数据分布的不平衡,删除和查找操作性能变差。我们考虑最差劲的散列函数,就是将所有的键值都映射为同一个散列值,那么对散列表的查找和删除操作的运行时间将和操作一个链式链表一样,都为O(n)。我们将在后面的文章中详细讲解散列函数的设计,敬请关注(づ ̄3 ̄)づ╭❤~

    展开全文
  • Jupyter 使用列表实现筛选求素数 使用列表实现筛选求素数可以极大的提高计算机的运算速率。 maxNumber = int(input("请输入一个大于2的自然数:")) lst = list(range(2,maxNumber)) #最大整数的平方根 m = int...
  • 大整数的乘法-列表法

    千次阅读 2013-10-07 18:59:20
    大整数的乘法    在计算机中,长整形(long int)变量的范围是-2147483648至2147483647,因此若用长整形变量做乘法运算,乘积最多不... 比较容易想到的是做多位数乘法时竖式进行计算的方法,只要写出模拟这一过

      大整数的乘法

     

           在计算机中,长整形(long int)变量的范围是-2147483648至2147483647,因此若用长整形变量做乘法运算,乘积最多不能超过10位数。即便用双精度(double)变量,也仅能保证16位有效数字的精度。在某些需要更高精度的乘法运算场合,需要用别的办法来实现运算。

          比较容易想到的是做多位数乘法时列竖式进行计算的方法,只要写出模拟这一过程的程序,就能实现任意大整数的乘法运算。经过查阅资料,找到一种更易于编程的方法,即“列表法”。

     

    下面先介绍“列表法”:

    例如当计算8765*234时,把乘数和被乘数照如下列出,见表1:

     

    8

    7

    6

    5

    *

    16

    14

    12

    10

    2

    24

    21

    18

    15

    3

    32

    28

    24

    20

    4

     

                               表一

     

     

     

    16

    14

    12

    10

     

     

     

    24

    21

    18

    15

     

     

     

    32

    28

    24

    20

    16

    38

    65

    56

    39

    20

     

       

     

    16

    38

    65

    56

    39

    20

    2

    16+4=20

    38+7=45

    65+6=71

    56+4=60

    39+2=41

     

    留2

    留0进2

    留5进4

    留1进7

    留0进6

    留1进4

    留0进2

    2

    0

    5

    1

    0

    1

    0

     

      根据以上思路 就可以编写C程序了,再经分析可得:

    1,一个m位的整数与一个n位的整数相乘,乘积为m+n-1位或m+n位。

    2,程序中,用三个字符数组分别存储乘数,被乘数与乘积。由第1点分析知,存放乘积的字符数组饿长度应不小于存放乘数与被乘数的两个数组的长度之和。

    3,可以把第二步“计算填表”与第三四步“累加进位”放在一起完成,可以节省存储表格2所需的空间。

    4,程序关键部分是两层循环,内层循环累计一数组的和,外层循环处理保留的数字和进位。

    1. #define MAXLENGTH 1000  
    2. #include <stdio.h>  
    3. #include <string.h>  
    4.   
    5. void compute(char * a, char * b,char *c)  
    6. {  
    7.   int i,j,m,n;  
    8.   long sum,carry;  
    9.   m = strlen(a)-1;  
    10.   n = strlen(b)-1;  
    11.  for(i=m;i>=0;i--)  
    12.     a[i] -= '0';  
    13.  for(i=n;i >=0;i--)  
    14.     b[i] -='0';  
    15.   c[m+n+2] ='/0';  
    16.  carry =0;  
    17.  for(i=m+n;i>=0;i--)  
    18.  {  
    19.    sum=carry;  
    20.    if((j=(i-m))<0)  
    21.      j=0;  
    22.    for(;j<=i&& j <=n;j++)  
    23.        sum += a[i-j]b[j];  
    24.    c[i+1] = sum %10 + '0'; /*算出保留的数字*/  
    25.    carry = sum/10;  
    26.  }  
    27.  if((c[0]=carry+'0')=='0') /* if no carry*/  
    28.    c[0] = '/040'; /* space */  
    29. }  
    30.   
    31. int main()  
    32. {  
    33.    char a[MAXLENGTH],b[MAXLENGTH],c[MAXLENGTH*2];  
    34.    puts("Input multiplier");  
    35.    gets(a);  
    36.    puts("Input multiplier");  
    37.    gets(b);  
    38.    compute(a,b,c);  
    39.    puts("Answer:");  
    40.    puts(c);  
    41.    getchar();  
    42. }  

    效率分析:用以上算法计算m位整数乘以n位整数,需要先进行m*n次乘法,再进行约m+n次加法运算和m+n次取模运算(实为整数除法)。把这个程序稍加修改,让它自己生产乘数和被乘数,然后计算机随机的7200为整数互乘。

       经过改进,此算法效率可以提高约9倍。

        注意到以下事实:8216547*96785 将两数从个位起,每3位分为节,列出乘法表,将斜线间的数字相加:

        8  216  547

             96   785

    8

    216

    547

    *

    768

    20736

    52512

    96

    6250

    169560

    429395

    785

     

    768

    20736

    52512

     

     

    6250

    169560

    429395

    768

    27016

    222072

    429395

     

     

     

    将表中最后一行进行如下处理:从个位数开始,每一个方格里只保留三个数字,超出1000的部分进位到前一个方格里:

      

     

    768

    27016

    222072

    429395

     

    768+27=795

    27016+222=27238

    222072+429=222501

    留395进429

     

    795

    238

    501

    395

    所以8216547*96785 = 795238501395

     

     也就是说我们在计算生成这个二维表时,不必一位一位的乘,而可以三位三位的乘;在累加时也是满1000进位。这样,我们计算m位整数乘以n位整数,只需要进行m*n/9次乘法运算,再进行约(m+n)/3次加法运算和(m+n)/3次去摸运算。总体看来,效率是前一种算法的9倍。

      有人可能会想:既然能用三位三位的乘,为什么不能4位4位的乘,甚至5位。听我解来:本算法在累加表中斜线间的数字时,如果用无符号长整数(范围0至~4294967295)作为累加变量,在最不利的情况下(两个乘数的所有数字均为9),能够累加约4294967295/(999*999)=4300次,也就是能够准确计算任意两个约不超过12900(每次累加的结果“值”三位,故4300*3=12900)位的整数相乘。如果4位4位地乘,在最不利的情况下,能过累加月4294967295/(9999*9999)=43次,仅能够确保任意两个不超过172位的整数相乘,没什么实用价值,更不要说5位了。

     

     

    1. #include <stdio.h>  
    2. #include <string.h>  
    3. #include <conio.h>  
    4. #include <stdlib.h>  
    5. #include <time.h>  
    6. #define N 7200 //做72xx位的整数乘法  
    7. int max(int a,int b,int c)  
    8. {  
    9.   int d = (a >b)?a:b;  
    10.   return (d>c)?d:c;  
    11. }  
    12. int initarray(int a[])  
    13. {  
    14.    int q,p,i;  
    15.    q = N + random(100);  
    16.    if(q%3 ==0)  
    17.       p =q/3;  
    18.    else  
    19.       p =q/3+1;  
    20.    for(i=0;i <p;i++)  
    21.       a[i] = random(1000);  
    22.    if(q%3 ==0)  
    23.         a[0] = 100+random(900);  
    24.    if(q%3 == 2)  
    25.        a[0] = 10 + random(90);  
    26.    if(q%3 == 1)  
    27.        a[0] = 1 + random(9);  
    28.    return p;   
    29. }  
    30. void write(int a[],int l)  
    31. {  
    32.    int i;  
    33.    char string[10];  
    34.    for(i=1;i<l;i++)  
    35.    {  
    36.      itoa(a[i],string,10);  
    37.      if(strlen(string)==1)  
    38.        fprintf(fp,"00");  
    39.      if(strlen(string)==2)  
    40.        fprintf(fp,"0");  
    41.      fprintf(fp,"%s",string);  
    42.      if((i+1)%25 == 0)  
    43.         fprintf(fp,"/n");  
    44.    }  
    45.    fprintf(fp,"/n");  
    46.    fprintf(fp,"/n");  
    47. }  
    48. FILE * fp;  
    49.   
    50. int main()  
    51. {  
    52.    int a[5000]={0},b[5000]={0},k[10001]={0};  
    53.    unsigned long c,d,e;//申明作累加用的无符号长整数变量  
    54.    int i,j,la,lb,ma,mi,p,q,t;  
    55.    randomize();//初始化随机数  
    56.      
    57.   la = initarray(a);//被乘数  
    58.   lb = initarray(b);//乘数  
    59.     
    60.   if(la < lb)//如果被乘数长度小于乘数,则交换被乘数与乘数  
    61.   {  
    62.     p = (lb > la)?lb:la;  
    63.     for(q=0;q<p;q++)  
    64.      t=a[q],a[q]=b[q],b[q]=t;  
    65.     t =la,la=lb,lb =t;  
    66.   }   
    67.   c=d=0;  
    68.   for(i=la+lb-2;i>=0;i--)//累加斜线间的数,i位横纵坐标之和  
    69.   {  
    70.     c=d;//将前一位的进位标志存入累加变量C  
    71.     ma =max(0,i-la+1,i-lb+1);//求累加的下限  
    72.      mi = (i > la)?(la-1):i;//求累加的上限  
    73.     for(j=ma;;j<=mi;j++)  
    74.     {  
    75.        c+=a[j]b[i-j];  
    76.     }  
    77.     d=c/1000;//求进位标志  
    78.     if(c>999)  
    79.         c%=1000;//取c的后3位  
    80.      k[i] = c;//保存至表示乘积的数组k[]  
    81.      
    82.   }  
    83.   e = k[0] + 1000*d;//求出乘积的最高位  
    84.   fp = fopen("res.txt","w+");  
    85.   fprintf(fp,"%d",a[0]);//打印被乘数的最高位  
    86.   write(a,la);//打印被乘数其他位数  
    87.   fprintf(fp,"%d",b[0]);//打印乘数的最高位  
    88.   write(b,lb);//打印乘数其他位数  
    89.   fprintf(fp,"%d",e);//打印乘积的最高位  
    90.   write(k,la+lb-1);//打印乘积其他位数  
    91.   fclose(fp);  
    92. }  
     

     

     

      

      

     

     

                               表二

      从最低位的20开始,保留个位数字“0”,把个位以外的数“2”进到前一位;把次低位的39加上低位进上来的2得41,保留个位数字“1”,把“4”进到前一位;以此类推,直至最高位的16,16加上地位进上来的4得20,保留“0”,把2进到最高位,得乘积为

    展开全文
  • 数字电路基础知识——数字逻辑代数(逻辑代数公式、卡洛图的运用、Q-M法化简(列表法)) 本节主要介绍逻辑代数的公式、及逻辑函数的化简、包括公式法化简、卡洛图化简、Q-M列表法化简。 一、逻辑代数的三个基本运算 ...

    数字电路基础知识——数字逻辑代数(逻辑代数公式、卡洛图的运用、Q-M法化简(列表法))
    本节主要介绍逻辑代数的公式、及逻辑函数的化简、包括公式法化简、卡洛图化简、Q-M列表法化简。重点需要知道前面两种的方法,第三种可以了解,能够帮助自己更深的了解逻辑相邻项的理解

    一、逻辑代数的三个基本运算

    逻辑代数中最基本的三个运算:与、或、非
    基本的函数关系如下:
    在这里插入图片描述

    二、逻辑代数的基本定律
    1. 基本公式

    在这里插入图片描述
    在这里插入图片描述

    比较重要的是后面三个定律:

    1. 反演律(德摩根律)
      使用此定律可以将乘积项和项打开。
      具体规则是 × 变++变×原变量变反变量,反变量变原变量
    2. 吸收律
      重点知道这个:A+A’B=A+B、A+AB=A、A(A+B)=A
      A+A’B
      =A+AB+A’B
      =A+B(A+A’)
      =A+B
    3. 冗余律
      AB+A’C+BC=AB+A’C
      AB+A’C+BC
      =AB+A’C+(A+A’)BC
      =AB+A’C+ABC+A’BC
      =AB+ABC+A’C+A’BC
      =AB(1+C)+A’C(1+B)
      =AB+A’C
    2. 基本定理
    1. 代入定理
      任何一个逻辑式代入原来式中所有的相同变量的位置,等式仍然成立。

    2. 反演定理

    3. 对偶定理
      若两逻辑等式相等,则他们的对偶式也相等
      对偶定理主要在某些情况下,证明某式成立时,可以通过证明其对偶式成立来简化证明。
      如:
      Y=A(B+C),则YD=A+BC
      Y=(AB+CD)’,则YD=((A+B)(C+D))’
      Y=AB+(C+D)’,则YD=(A+B)(CD)’
      在这里插入图片描述

    三、逻辑函数的两种标准式
    1. 最小项
      n个变量的最小项是含n个变量的与项,其中每个变量都是以原变量或反变量的形式出现一次。
      通常用mi表示各项。
      在这里插入图片描述
      在这里插入图片描述
      如:对于下面的逻辑表达式:
      在这里插入图片描述

    2. 最大项
      n个变量的最大项是含n个变量的或项,其中每个变量都是以原变量或反变量的形式出现一次。
      通常用Mi表示各项。

    3. 最大项和最小项的性质
      n变量的全部最小项之和恒为1,全部最大项之积恒为0.
      任意两个最小项之积恒为0,任意两个最大项之和恒为1.
      n变量的每一个最小项或者最大项有n个相邻项(相邻项是指两个最小项只有一个因子互为反变量,其余因子均相同,又称逻辑相邻项

    四、逻辑函数的卡洛图化简

    公式法化简逻辑函数其实就是用上面的公式来化简。
    主要介绍一下卡洛图化简。

    1. 相邻项
      首先需要知道相邻项的概念,即两个最小项只有一个因子互为反变量,其余因子均相同,又称逻辑相邻项
    2. 卡洛图
      把任意两个逻辑上相邻的最小项变为几何中的相邻,做到逻辑相邻和几何相邻
      2变量卡洛图:由代表四个最小项的四个方格组成:
      在这里插入图片描述
      三变量卡洛图由8个最小项组成,需要注意的是最小项编码和格雷码的编码类似,即相邻位置或者首尾是逻辑相邻。:
      在这里插入图片描述
      四变量如下(一般卡洛图的化简至多四-五个变量):
      在这里插入图片描述
    3. 逻辑函数在卡洛图的表示
      在这里插入图片描述
      如:
      在这里插入图片描述
    4. 卡洛图最小项合并规则
      任何两个为一的相邻最小项可以合并为一项,并消去一个变量(消去的是互为反变量的因子,保留公因子)
      在这里插入图片描述
      任何四个为一的相邻最小项(可以是循环相邻)可以合并为一项,并消去两个变量
      在这里插入图片描述
      在这里插入图片描述
    5. 图形法化简的基本步骤

    第一、将函数化为最小项之和的形式,然后做函数的卡洛图,确定卡洛图方格矩阵
    第二、画卡洛圈(要遵循卡洛圈最少,最大的原则)
    第三、写逻辑表达式(相同变量留下,不同变量去掉)

    五、Q-M法化简逻辑函数(奎恩-麦克拉斯基),也叫列表化简法

    卡洛图法化简虽然比较直观,简单,但是也有自身的缺点,如当逻辑变量大于五个之后,会变得很困难。
    而公式法化简虽然虽然不受变量数量的影响,但是化简过程并没有固定、通用的步骤。所以也很难借助计算机辅助进行化简。
    本节介绍一下Q-M法化简,本质上也是通过相邻最小项消去多余因子,来求逻辑函数的
    在这里插入图片描述
    先将函数表达式用最小项之和的形式表示:
    如下面的函数表达式:

    1. Y=Σm(0,3,4,5,6,7,8,10,11)
    2. 将其按照一个个数一次排列分组,如下:
      在这里插入图片描述
    3. 合并相邻的最小项
      即将上表中每一组的每一个最小项与相邻组所有的最小项逐一比较,若仅有一个因子不同,则可以合并,并消去不同的因子。如下,例如罪域m0和m4仅尤一位不一样,所以这一位可以合并为0-00,同时将上表中可以合并的用“对号”表示,不能合并的用Pi表示。
      按照同样的方法,可以在次合并下面左边的一列,可以合并的用“对号”表示,不能合并的用Pi表示。
      在这里插入图片描述
      因此经过以上的并向合并,留下了没有合并过的最小项Pi,所以就包含了函数Y的全部最小项,因此,可以表示为:
      Y=P1+P2+P3+P4+P5+P6+P7
      需要注意的是上面的表达式并不一定是最简结果,将所有Pi列成如下表格。

    在这里插入图片描述
    上表格中的m5、m6、m8都是只在Pi中只出现了一次所以最小项一定包含P1和P4,所以选取了这两项之后,以及包含了m4、m5、m6、m7、m8、m10这六个,除去之后剩下的m0、m3、m11如下表所示:

    mi0311
    P2×
    P3×
    P5×
    P6××
    P7×

    现在就是化简上面的结果了,因为P2和P3都有m0,因此可以去任何一项作为最简项。
    对于P5、P6、P7,由于P5和P7行的所有项均包含在P6中,因此P6包含了P5、P7的所有最小项,故将P5、P7删掉。因此最终的结果是:
    Y=P1+P4+P3+P6

    展开全文
  • 建立一个表为例子 SId 学生... 二: select @xuhao:=@xuhao+1 as '序号', a.* from Student a, (SELECT @xuhao:=0) b; 注:@xuhao的写法不唯一,但一定有@,等于号写法一定是:=(冒号等于号) 输出结果相同,如下:
  • 列表式单词记忆

    2005-12-29 10:26:00
    列表式单词记忆“针式背单词”提供了强大的“列表式”的识记方法,可以单独或组合使用下述方法:1、字段模式:改变显示顺序,改变信息组成形式不同对人脑不同的制激2、显示隐藏内容:方便进行回想、即时输入测试...
  • LabVIEW(十六):多列列表框控件

    千次阅读 2018-09-25 08:51:00
    1、多列列表框控件:前面板右键>列表、表格和树>多列列表框 2、默认情况下只显示首,可设置显示行首:前面板选中多列列表框右键>显示>行首 3、LabVIEW中提供42种自带的图标。 (1)、前面板选中多列列表框右键>...
  • python语言对于计算机专业的学生,...本次博客,林君学长主要带大家了解python中筛选求解素数的原理、列表切片操作、内置函数 enumerate()、filer()的使用、序列解包工作原理以及选择结构和循环结构,以例题编写...
  • SET QUOTED_IDENTIFIER ON GO SET ANSI_NULLS ON GO alter Proc usp_GetSectionMO_TEST(@FDate varchar(30)='',@Section varchar(30)='',@StyleNo varchar(30)='',@Type...各位大俠幫我看看 是哪裡語出問題了
  • 方法一、reindex更改行或(定义一个列表,直接对index排序实现行顺序更改,对column排序进行更改)但这种方法,只适合较少行列顺序的改变,否则枚举起来太复杂。优点是,该方法不会直接操作原df。 df = pd....
  • 又称帕累托分析或巴雷托分析、柏拉图分析、主次因分析 、ABC分析、分类管理、物资重点管理、ABC管理、abc管理、巴雷特分析,平常我们也称之为“80对20”规则,EMBA、MBA等主流商管教育均对ABC分类...
  • 比如:第4表示为:“D”,第255表示为“IU”。 事实上,Excel提供了两种地址表示方法,还有一种表示叫做RC格式地址。 你的任务是:编写程序,实现常规地址格式到字母地址格式到的转换。 例如:1-a,2-b;26...
  • 哈希表-线性探测/链地址

    千次阅读 2018-10-27 13:34:48
    假设散列表的长度是13,三函数为H(K) = k % 13,给定的关键字序列为{32, 14, 23, 01, 42, 20, 45, 27, 55, 24, 10, 53}。分别画出用线性探测和拉链解决冲突时构造的哈希表,并求出在等概率情况下,...
  • DataGridView控件用法 目录(?)[+] ...DataGridView控件用法(一)绑定数据-修改值-序号-交换顺序 ... 一、 DataGridView控件的用法(如何绑定、修改其中某一值、添加序号、交换任意2显示顺序)
  • 新闻列表中标题和日期的左右分别对齐的几种处理方法前言在新闻列表中,有标题和日期,然后分别对齐,这种应用场景非常广泛。而在前端实践中,其也有很多中布局方式。很多前端新手在入门时,可能会稍微有点迷茫。今天...
  • python获取矩阵某一元素

    万次阅读 2018-10-22 19:41:29
    今天写线性回归问题的时候遇到了一个问题: 对于一个二维矩阵, python如何遍历其某...方法二: 列表解析 这个方法其实和上面的那个方法是一样的, 不过列表解析的技术更酷一些. a = [[1, 2, 3], [4, 5, 6], [7, 8, 9...
  • 例举(创新技法4)

    千次阅读 2015-05-05 23:22:25
    例举法和检核表法都是一种列表法。例举法表示:一、缺点列举法:缺点例举法是美国通用公司的发明的一种创新方法,方法是通过对事物的分析,着重找出它的缺点和不足,然后再根据主次和因果,采取改进措施。从而在原有...
  • Eratosthenes筛选计算质数

    千次阅读 2015-09-25 14:11:01
    Eratosthenes筛选是一种计算质数的有效方法。这个算法的第一步就是写下所有从2至某个上限之间的所有整数。在算法的剩余部分,遍历整个列表并剔除所有不是质数的整数。 后面的步骤是这样的。找到列表中的第1个不...
  • 文章目录TOPSIS(优劣解距离)介绍及 python3 实现1 简述2 TOPSIS过程2.1 指标属性同向化,一般选择指标正向化2.1.1 极小型指标:期望指标值越小越好(如患病率、死亡率等)2.1.2 中间型指标:期望指标值既不要太...
  • 回溯与分支限界

    万次阅读 2016-11-30 19:25:02
    回溯解题的一个显著特征是在搜索过程中动态产生问题的解空间。在任何时刻,算法只保存从根结点到当前扩展结点的路径。
  • 一、散列表基本概念 1、散列表(hash table) ,也叫哈希表,是根据关键码而直接进行访问的数据结构。也就是说,它通过把关键码映射到表中一个位置 来访问记录,以加快查找的速度。这个映射函数叫做散列函数,...
  • jupyter notebook显示全部

    万次阅读 2018-08-08 12:02:00
    设定,设定全部的时候也想, pd.set_option('max_columns', 5) 来设定,too young too simple。 别忘了google大,参考[2],通过以下设定: pd.set_option('display.max_columns'...
  • 哈希表(散列表)原理详解

    万次阅读 多人点赞 2018-07-03 19:40:58
    哈希表(Hash table,也叫散列表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组...
  • dbgrideh 下拉框设置及应用

    千次阅读 2008-11-16 16:18:00
    方法一: picklist 方法 1. 只能下拉单列;picklist: 选择显示列表;...12 方法二:lookup 字段1.可下拉多; demo: Delphi 的 DBGrid 中的下拉列表和查找字段编程方法 作者: 来源:plwww 发布时间:
  • 数学归纳及例题分析

    万次阅读 多人点赞 2019-03-27 15:57:42
    学算法,不得不提的就是数学归纳。许多算法都会用到归纳假设的思想,其追溯回去便是数学归纳。 数学归纳 最简单和常见的数学归纳是证明当n等于任意一个自然数时某命题成立。证明分下面两步: 证明当n= 1...
  • 雅可比迭代欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • 1.1、等价类划分: 根据软件测试原则可以知道,要做到穷举是不可能的,事实上也是不必要的。为了减少工作量,需要对测试用例进行适当选取。等价类划分便提供了一种选取测试用例的方法。 等价类划分把程序的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 118,515
精华内容 47,406
关键字:

列表法怎么列