精华内容
下载资源
问答
  • 2016-08-27 12:07:55

    初步接触了以下几种高阶函数,还用的不是很熟练。

    1、map(): 这个函数接受两个参数: ‘map(function, sequence)’ 第一个必需参数是一个编辑好的函数,第二个参数是一个序列,map()的作用是按照序列的顺序依次对元素使用function。个人理解就类似于批处理吧,比如由一大堆名字组成的序列,其中没有规范的使用大小写,那我们可以定义一个修改函数,并依次对列表元素使用。以下是廖雪峰大大布置的作业:

    思路:1、用map()函数来处理列表。所以

    map(func, ['aDam', 'BerT', 'JERRY'])

    2、定义func函数,输入一个字符串,输出成为首字母大写,其余小写的字符串。

    3、使用lower()函数,在此我遇到了一个错误,以为lower()还属于半自动化的函数,比如一个指令小写一个字母,因此我用了迭代的方法去使用这个函数:

    def func(word):
         for s in word:
            return s.lower()
    


    结果:

    >>>func('Adam')
    'a'


    一时间没想通,后来在交互式界面中发现lower()可以直接将一整个字符串改写为小写。囧

    于是修改后的函数:

    def func(word):
        return word.lower()


    这样就能得到全是小写的string。用map函数套用上,得到三个小写的string,想再定义一个函数,使所有字符串的首字母大写。

    想到字符串也是一个列表,用string[0]可以定位到第一个字母,但是回想起之前所学的slice操作,发现可以减少不少步骤:

    def func(s):
        return s[0].upper() + s[1:].lower()


    于是这样就在一行里完成了这个函数。(其实这一步参考了大家的想法。。sad。。思维还是比较死板的,也反映出了基础打得不扎实)

    接着套用map函数就可以完成作业了。


    4、质数的判定:伪代码:

    n是否是大于1 的正整数--T/F

    大于1则生成2~n-1的列表a

    迭代,若在a中有一个数使得n能被整除,则不是质数。

    def is_prime(x):
        if type(x) != int or x <= 1:
            return False
        else:
            for n in range(2, x):
               if (x % n) == 0:
                   return False
                   break
            else:
                return True
            

    虽然练过很多次了还是很艰难的写出来,主要是如何判断质数这里想了很久,数学也是很差=。=
    继续努力吧

    5、filter(func, sequence)    筛选函数, 对序列使用函数,返回true的留下返回false的抛弃

    6、6、6、6、6、6、 闭包是什么鬼啊。。。。。s一头雾水,
    首先:廖雪峰大大用返回值来引入:
    def sum(*args):      #输入多个变量
        ax = 0
        for n in args:      #迭代输入的变量
             ax = ax + n   #依次相加求和
        return ax
    

    这里的返回值是ax 是一个整数,代表着前面*args的总和

    接下来老师说 “如果返回的是函数呢?”
    def lazy_sum(*args):
        def sum():
            ax = 0
            for n in args:
                 ax = ax + n
            return ax
        return sum

    到这里已经开始有点迷惑了 来一步步分析:
    交互式界面中调用lazy_sum(1,2,3,4,5)
    返回一个函数<function ...............>
    若要得到其值 要先将lazy_sum赋值给一个变量 比如F
    再用F() 调用
    这里就不是很懂,一点愚见“一开始定义了两个函数,所以要经过两次调用才能得出结果“ 这是初步的一种记忆的方法 接着看

    #要注意的问题 返回的函数并没有立即执行,要经过F()才执行。

    另一个开始不懂的例子:
    def count():
         fs = []
         for i in range(1, 4):
             def f():
                  return  i*i
             fs.append(f)
         return fs
    
    f1, f2, f3 = count()

    第一步 定义count()函数, 调用函数时,内部先创建一个空列表,接着生成一个从1-3的列表进行迭代
    第二步 列表中取出 1 ,调用f() 返回1*1 (函数1),并将此函数添加到fs这个列表里
    第三步 列表中取出 2 ,调用f() 返回2*2 (函数2),并将此函数添加到fs这个列表里
    第四步 列表中………………………………………………………………………………
    第五步 迭代完成 返回一个含有3个元素的列表 fs ,并且元素是函数f()
    第六步 注意此时返回的函数并没有执行,要再次经过调用,而且调用的内容是i*i
    第七步 注意之前的i是正在迭代的 从1 - 3 所以此时的i=3
    第八步 将fs中的三个函数分别赋值给f1, f2, f3  再依次调用f()
    第九步 发现结果全都是9 (3*3)

    果然列出来了就是想清楚了 nice!

    再来一波: 避免在返回的函数里(f())引用循环变量,或者后续会发生的变量,比如刚才的i*i

    def count():
        fs = []
        for i in range(1, 4):
            def f(j):
                def g():
                    return j*j
                return g
            fs.append(f(i))
        return fs
    
    f1, f2, f3 = count()

    第一步 定义count函数,函数中有一个空列表fs 生成1-3的列表。

    第二部 定义f函数,参数是j ,在f函数内部定义函数g 返回j*j, 再将此函数返回f函数,此时函数f(j)返回一个函数j*j(g).

    第三步 向fs列表中添加 参数是i的f(), 此时j=i 代入运算返回 g1=i*i(此时i = 1) 所以g1 = 1*1

    第四步 向fs列表中添加  参数是i的f(), 此时j=i 带入运算返回 g2 = i * i (此时 i=2 )所以g2 = 2 * 2

    第五步 同上

    第六步 迭代完成后fs中有三个f() 分别为g1 g2 g3 要再次进行调用才能得出结果。分别赋值给f123 3个变量

    第七步 运行 得到结果 不受i的影响,因为j取值是i是固定的 随后i改变时j不变 因此得以保存


    弄了这么多还没有触及到闭包 囧。。。

    教程说 “在外函数中定义了内函数,并且 内部函数可以引用外部函数的参数和局部变量。当外层函数返回内层函数时,相关参数和变量都保存在返回的函数(内函数)中,这种称为闭包的程序结构 巴拉巴拉” 似乎懂一点,


    先拿它的作用来凑个数 [转载 来自  ] what? 为啥连超链接和下面的url都不能用复制 我都写了转载。。






    更多相关内容
  • 二元关系函数

    2021-06-15 23:14:01
    文章目录二元关系函数笛卡儿积1.1 定义**笛卡儿积****n笛卡儿积**1.2 性质二元关系2.1 定义2.2 A上关系**定义**设A,B为集合, A×B的任何子集所定义的二元关系叫做从A到B的关系**计数规则****重要实例**小于等于...

    二元关系和函数

    笛卡儿积

    1.1 定义

    • 笛卡儿积

    笛卡尔积一般是指笛卡尔乘积, 笛卡尔乘积是指在数学中,两个集合X和Y的笛卡尓积 ,又称直积。

    表示为: A×B ={ <x,y> | x∈A ∧ y∈B }

    • n阶笛卡儿积

    · 定义:n阶笛卡尔积

    ​ A × B × … × Z = {<a,b…z>|

    ​ a ∈ A ∧ b ∈ B ∧ … ∧ z ∈ Z}

    · 定义:A^n =A1×A2×…×An

    · 定理:|A× B×…× Z|=a× b×…× z.

    (若无特殊说明,所涉及的笛卡儿积都指2阶笛卡儿积)

    1.2 性质

    · 不适合交换律 A× B ≠ B× A (A≠ B,A ≠ Ø ,B ≠ Ø )

    · 不适合结合律 (B×C)× A≠ A× (B× C) (A ≠ Ø ,B ≠ Ø )

    · 对于并或交运算满足分配律:

    ​ A×(B ∪ C)=(A×B) ∪ (A×C)
    ​ (B ∪ C)×A=(B×A) ∪ (C×A)
    ​ A×(B ∩ C)=(A×B) ∩ (A×C)
    ​ (B ∩ C)×A=(B×A) ∩ (C×A)

    若A或B中有一个为空集,则A× B 就是空集。

    A×Ø = Ø × B= Ø

    若|A|=m,|B|=n,则|A× B|=mn

    在这里插入图片描述

    二元关系

    2.1 定义

    · 定义: 集合X与集合Y上的二元关系是R=(X,Y,G®),当中G(R),称为R的图,是笛卡尔积的子集。若(x,y)∈G(R)则称x与y有关系R,并记作xRy或R(x,y)。

    有四件物件{球,糖,车,枪}及四个人{甲,乙,丙,丁}。若甲拥有球,乙拥有糖,及丁拥有车-即无人有枪及丙一无所有-则二元关系为“……拥有……”便是

    R =({球,糖,车,枪}, {甲,乙,丙,丁}, {(球,甲), (糖,乙), (车,丁)})。

    其中R的首项 的首项是物件的集合,次项是人的集合,而末项是由有序对(物件,主人)组成的集合。比如有序对(球,甲)以球R甲表示,代表球为甲拥有。

    2.2 A上关系

    定义

    设A,B为集合, A×B的任何子集所定义的二元关系叫做从A到B的关系
         二元关系。
        当A=B时则叫做 A上的二元关系
    

    计数规则

    假设A有n个元素,A2有n2个元素,每个元素可选可不选,故总共2n2种不同的二元关系

    重要实例

    • 小于等于关系 LA:
      LA={<x,y>| x,y∈A∧x≤y}, A⊆R,R为实数集合

    ​ e.g.设集合 A ={2,3,6} ,LA= {❤️,2>,<6,2>,<6,3>}

    • 整除关系DA
      DA={<x,y>| x,y∈B∧x整除y}, B⊆Z*, Z*为非0整数集

    ​ e.g.设集合 A ={2,3,6} ,DA={<2,6>,❤️,6>}

    • 包含关系R⊆
      R⊆={<x,y>| x,y∈A∧x⊆y}, A是集合族

    ​ e.g.设集合A={1,2,3} , r={<1,1>,<2,3>,❤️,3>}

    2.4 三种特殊关系

    空关系∅

    空集Ø称作A上的空关系

    全域关系EA

    EA=A×A 称作A上的全域关系完全关系

    恒等关系IA

    IA={(x,x)|x∈A}称作A上的恒等关系

    a quizze:设A={0,1,2},求A上的恒等关系R。

    ​ 解:R={<0,0>,<1,1>,<2,2>}.

    2.5 表达方式

    集合表达式

    关系矩阵

    ​ 若A={a1, a2, …, am},B={b1, b2, …, bn},R是从A到B的关系,R的关系矩阵是布尔矩阵MR = [ rij ] m×n, 其中 rij = 1\leftrightarrow < ai, bj> \epsilonR。

    a quizze:设A={1,2.3,4},R={<1,1>,<1,2>,<2,3>,<2,4>,<4,2>},是A上的二元关系,求A的关系矩阵。

    解:
    在这里插入图片描述

    关系图

    ​ 若A= {x1, x2, …, xm},R是从A上的关系,R的关系图是GR=<A, R>, 其中A为结点集,R为边集。如果<xi,xj>属于关系R,在图中就有一条从 xi 到 xj 的有向边。

    a quizze:设A={1,2.3,4},R={<1,1>,<1,2>,<2,3>,<2,4>,<4,2>},是A上的二元关系,求A的关系图。

    解:在这里插入图片描述

    笛卡尔生平故事

    3.1 生平

    · 出生于法国,毕业于普瓦捷大学,法国著名哲学家、物理学家、数学家,被黑格尔称为“近代哲学之父”。

    · 笛卡尔自成体系,融唯物主义与唯心主义于一炉,是欧洲近代资产阶级哲学的奠基人之一

    3.2 成就

    · 哲学方面:从逻辑学、几何学和代数学中发现了4条规则:

    1. 绝不承认任何事物为真,对于我完全不怀疑的事物才视为真理;

    2. 必须将每个问题分成若干个简单的部分来处理;

    3. 思想必须从简单到复杂;

    4. 我们应该时常进行彻底的检查,确保没有遗漏任何东西。

      · 物理学方面:第一次提出了动量守恒定律:物质和运动的总量永远保持不变。为能量守恒定律奠定了基础。 笛卡尔对碰撞和离心力等问题曾作过初步研究,给后来克里斯蒂安·惠更斯的成功创造了条件。

      · 天文学方面: 笛卡尔把他的机械论观点应用到天体,发展了宇宙演化论,形成了他关于宇宙发生与构造的学说 。

      · 数学方面:

      1.建立笛卡尔坐标系:也叫直角坐标系。并且成功的创立了解析几何学。 他的这一成就为微积分的创立奠定了基础,而微积分又是现代数学的重要基石。解析几何直到现在仍是重要的数学方法之一。

      2.笛卡尔符号法则: 笛卡尔符号法则首先由笛卡尔在他的作品《La Géométrie》中描述,是一个用于确定多项式的正根或负根的个数的方法。

      3.欧拉-笛卡尔公式: 在任意凸多面体,设V为顶点数,E为棱数,F是面数,则V−E+F=2。

      4.笛卡尔叶形线:笛卡尔叶形线是一个代数曲线,首先由笛卡尔在 1638年提出。

    3.3 浪漫的公式体情书(心形曲线 )

    ​ 怎么说,看过百岁山矿泉水的广告都应该对立面的故事有印象吧,这波啊,这波不为百岁山打广告。立面讲述的就是18岁的瑞典公主克里斯汀于街头邂逅穷困潦倒的笛卡尔 。妥妥的白富美啦,这不得出任官职,走向人生巅峰?

    ​ 害,但好景不长,在成为 她的数学老师,日日相处使他们彼此产生爱慕之心,公主的父亲国王知道了后勃然大怒,下令将笛卡尔处死,后因女儿求情将其流放回法国,克里斯汀也被父亲软禁起来。笛卡尔回法国后不久便染上黑死病,他日日给公主写信,因被国王拦截,克里斯汀一直没收到笛卡尔的信。笛卡尔在给克里斯汀寄出第十三封信后就气绝身亡了,这第十三封信内容只有短短的一个公式:r=a(1-sinθ)。国王看不懂,觉得他们俩之间并不是总是说情话的,大发慈悲就把这封信交给一直闷闷不乐的克里斯汀,公主看到后,立即明了恋人的意图,她马上着手把方程的图形画出来,看到图形,她开心极了,她知道恋人仍然爱着她,原来方程的图形是一颗心的形状。公主在纸上建立了极坐标系,用笔在上面描下方程的点,看到了方程所表示的心脏线,理解了笛卡尔对自己的深深爱意 。

    ​ 虽然在后人的种种考究下,证实了这只是个浪漫的传说,并不是笛卡尔的真实经历,但不妨碍我们知道:学好数学,情话不愁。同理,学好离散,浪漫至死不渝。在这里插入图片描述

    二元关系的应用场景

    4.1 应用场景

    ​ 表示集合中两个元素之间的某种相关性

    4.2 栗子一

    ​ 设A={1,2,3,4,5,6},B={1,2,3},从A到B的关系R={<x,y>|x=y×y},求R。

    ​ 解:R={<1,1>,<4,2>}.

    4.3 栗子二

    ​ 设A={1,2,3,4,5,6},R是A上的整除关系,求R。

    ​ 解:R={<1,1>,<1,2>,<1,3>,<1,4>,<1,5>,<1, 6>,<2,4>,<2,6>,❤️,6>,}.

    ,5,6},B={1,2,3},从A到B的关系R={<x,y>|x=y×y},求R。

    ​ 解:R={<1,1>,<4,2>}.

    4.3 栗子二

    ​ 设A={1,2,3,4,5,6},R是A上的整除关系,求R。

    ​ 解:R={<1,1>,<1,2>,<1,3>,<1,4>,<1,5>,<1, 6>,<2,4>,<2,6>,❤️,6>,}.

    在这里插入图片描述

    展开全文
  • 阶函数(一)

    千次阅读 2017-09-23 10:16:25
    阶函数其实看着挺吓人,不过就是把函数作为参数或者返回值的一类函数而已。其实这样的函数我们都见过很多了

    原文链接:https://github.com/enbandari/Kotlin-Tutorials

    1. 什么是高阶函数

    1.1 高阶函数的基本概念

    高阶函数其实看着挺吓人,不过就是把函数作为参数或者返回值的一类函数而已。其实这样的函数我们都见过很多了,来看个例子:

    public inline fun <T> Array<out T>.forEach(action: (T) -> Unit): Unit { 
        for (element in this) action(element) 
    } 

    这是我们的老朋友了,forEach,传入了一个 Lambda 表达式,之后在迭代数组的时候调用这个 Lambda。你可千万别把 Lambda 不当函数,人家可是正儿八经的 FunctionN 的实例,这个我们在前面一篇文章细说 Lambda 表达式已经介绍过了

    如果使用 forEach,我们就这么写:

    array.forEach{ 
        print("$it, ") 
    } 

    输出结果就类似:

    1, 2, 3, 4,  

    forEach 其实就是一个把函数当参数传入的高阶函数了。

    1.2 函数引用

    下面我们要来思考一个问题。为什么 Kotlin 可以有高阶函数?

    其实这个问题,我们早就有答案了,因为在 Kotlin 当中,函数是“一等公民”,函数的引用可以自由传递,赋值,并在合适的时候调用。为什么这么说呢?难道仅仅是因为我们可以任性的定义 Lambda 表达式这种匿名函数,并把它赋值为一个变量,然后可以随便传递和调用吗?

    当然不能完全是这样了。其实 Kotlin 当中的任何方法、函数都是有其名字和引用的,我们前面其实看到过一个 forEach 的例子,我再给大家拿出来:

    array.forEach(::println) 

    这个例子当中,我们其实是想要把元素挨个打印一遍,forEach 传入的是一个 (T) -> Unit,这并不是说它只能传入一个符合参数和返回值的 Lambda,而是说符合参数和返回值定义的任意函数。println 有很多版本,其中有一个符合上面的条件:

    public inline fun println(message: Any?) { 
        System.out.println(message) 
    } 

    所以我们可以把它当参数传入。这个意义上讲,::println 跟 Function1 是什么关系呢?很明显接口实现的关系了,同时 ::println 因为可以具名引用到一个函数,所以我们也把类似的写法叫做函数引用。

    我们再来看一个类成员的例子:

    class Hello{ 
        fun world(){ 
            println("Hello world.") 
        } 
    } 
      
    val helloWorld: (Hello)-> Unit = Hello::world 

    我们同样可以用 :: 的方式来引用类成员方法,当然扩展方法也是可以的。这个要怎么用呢?

    fun Int.isOdd(): Boolean = this % 1 == 0 
      
    ... 
    val ints = intArrayOf(1,3,4,5,8) 
    ints.filter(Int::isOdd) 

    注意到 filter 的参数类型:

    public inline fun IntArray.filter(predicate: (Int) -> Boolean): List<Int> { 
        return filterTo(ArrayList<Int>(), predicate) 
    } 

    跟我们前面 Hello::World 的例子是不是一模一样呢?

    不过相比包级函数,这种引用在 Kotlin 1.1 以前显得有些苍白,为什么这么说呢?

    class PdfPrinter{ 
        fun println(any: Any?){ 
            println(any) 
        } 
    } 
      
    ... 
      
    array.forEach(PdfPrinter::println) //错误!! 

    请问,这种情况下,我该如何像 ::println 一样将 PdfPrinter::println 传递给 forEach 呢?我们知道,所有的类成员方法,它们其实都有一个隐含的参数,即类的实例本身,所以它的类型应该是下面这样:

    val pdfPrintln: (PdfPrinter, Any?)-> Unit = PdfPrinter::println 

    那么,有人就会说,我干脆构造一个 PdfPrinter 的实例,然后这么写看看:

    array.forEach(PdfPrinter()::println)// Since Kotlin 1.1 

    看着很不错了吧?可惜,这个在 1.1 才支持哦,不过距离 1.1 正式发布应该不久了!

    2 常见的内置高阶函数

    Kotlin 为我们内置了不少好用的高阶函数,这一节我们就给大家简要介绍一下。

    2.1 map

    我们经常用 forEach 来迭代一个集合,如果我们想要把一个集合映射成另外一个集合的话,通常我们会这么写:

    val list = listOf(1,3,4,5,10,6,8,2) 
      
    val newlist = ArrayList<Int>() 
    list.forEach {  
        val newElement = it * 2 + 3 
        newlist.add(newElement) 
    } 

    看上去还是挺简单的,不过终究不够简洁,而且还在 Lambda 表达式内部访问了外部变量,这其实都不是很好的编程习惯。

    map 其实就是对类似的操作做了一点封装,类似的集合映射的操作用 map 再合适不过了:

    val newlist  =  list.map { 
        it * 2 + 3 
    } 

    Lambda 的参数是原集合的元素,返回值是对应位置的新集合的元素,新集合是 map 的返回值。我们再来看个例子:

    val stringlist = list.map(Int::toString) 

    上面这个例子,我们把一个整型的集合映射成了一个字符串类型的集合。不管你做何种变换,map 的返回值始终是一个大小与原集合相同的集合。

    2.2 flatMap

    如果我手头有一个整型集合的集合,我想把他们打平,变成一个整型集合,用我们传统的方法就是两层循环。如果我还想要做点儿变换,那么这代码写起来就更丑了。

    如果我们要用 flatMap,那么这个故事就直截了当得多:

    val list = listOf( 
            1..20, 
            2..5, 
            100..232 
    ) 
      
    val flatList = list.flatMap { it } 
    println(flatList) 

    flatMap 后面的 Lambda 参数是 list 的元素,也就 1..20、2..5 这些 range,返回的值呢是一个 Iterable,flatMap 会把这些 Lambda 返回的 Iterable 统统添加到它自己的返回值也就是 flatList 当中,这样就相当于把 list 做了一次打平。

    结果:

    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 2, 3, 4, 5, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232] 

    那么这么直白的打平也不见得是我们的目标,比如我们要把这些数都做一些运算再打平,那么这个也简单:

    val flatList = list.flatMap { iterable ->  
        iterable.map { element -> 
            element * 2 + 3 
        } 
    } 

    我们只需要对 iterable 做一次 map 即可。

    2.3 fold / reduce

    其实 fold 就是折叠的意思嘛,把一个集合的元素折叠起来的并得到一个最终的结果,这就是 fold 要做的事情。

    fun main(args: Array<String>) { 
        val ints = intArrayOf(1,2,3,4,5) 
        val r = ints.fold(5){ 
            sum, element -> 
            println("$sum, $element") 
            sum + element 
        } 
        println(r) 
    } 

    结果呢?就是从 5 开始,每次返回的结果又成了 sum,一直这么折叠下去,直到最后输出 20。

    5, 1 
    6, 2 
    8, 3 
    11, 4 
    15, 5 
    20 

    当然,对于fold来说,我们还可以得到其他类型的结果,不一定要与集合的元素类型相同:

    val r1 = ints.fold(StringBuilder()){ 
        sb, element-> 
        sb.append(element).append(",") 
    } 
      
    println(r1) 

    大家看到,我们的初始值实际上是一个 StringBuilder,后续一直在做字符串追加的操作,最后得到的 r1 其实就是一个追加了所有元素的 StringBuilder,我们把它打印出来:

    1,2,3,4,5, 

    我们再来看下 reduce。

    val r2 = ints.reduce { sum, element -> sum + element } 
    println(r2) 

    输出的最终结果是 15,也即元素之和。显然,reduce 每次求值的结果都作为下一次迭代时传入的 sum,这个看上去跟 fold 极其的类似,只不过 reduce 没有额外的初始值,并且返回值类型也需要保持与集合的元素相同。

    如果我们要求一个数的阶乘,那代码其实很容易写:

    fun factorial(n: Int): Int{ 
        if(n == 0) return 1 
        return (1..n).reduce { factorial, element -> factorial * element } 
    } 

    2.4 filter / takeWhile

    如果我们有一个很大的集合,想要过滤掉其中的一些元素,那么通常的做法也是构造一个新集合来,然后遍历原集合。

    显然,我们有更好的写法:

    val evens = (1..100).filter {  
        it % 2 == 0 
    } 

    找出 1 到 100 之间的所有偶数,我们只需要用 filter,并传入判断条件,那么符合条件的元素就会被保留到返回的集合当中。

    类似的,takeWhile 则返回的集合是原集合中从第一个元素开始到第一个不符合条件的元素之前的所有元素。例如:

    println((1..10).takeWhile { it % 5 != 0 }) 

    这表明,从 1..10 当中取元素,只要遇到一个是 5 的倍数的元素,那么立即返回,即结果为:

    [1, 2, 3, 4] 

    2.5 let

    let 实际上比较简单,我们先来看下它的定义:

    public inline fun <T, R> T.let(block: (T) -> R): R = block(this) 

    我们看到 let 实际上传入了一个 Lambda,而这个 Lambda 传入的参数就是 let 的调用者本身,返回值随便你。这个 let 有什么用呢?

    val person: Person? = findPerson() 

    我们看到 person 这个变量是可空的,我们需要做一些判断才能对其进行操作。通常的写法可能是这样的:

    person?.name = "张三" 
    person?.age = 18 
    ... 

    不过,这种问好满天飞的写法,看着其实并不是很让人舒服。

    我们还可以这么写:

    if(person != null){ 
        person.name = "张三" // person 被智能转换成 Person 类型 
        person.age = 18 
        ... 
    } 

    当然,我们还有一种写法就是:

    person?.let{ 
        it.name = "张三" 
        it.age = 18 
        ... 
    } 

    let 比较简单,其用法也是很灵活的,大家可以自行发挥。

    2.6 apply / with

    下面我们来看 apply。

    public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this } 

    注意到 apply 传入的 Lambda 也是 apply 的调用者的扩展方法,所以,apply 相当于给了我们一个灵活切换上下文的机会,

    class Options{ 
        var scale: Float = 1f 
        var offsetX: Double = 0.0 
        var offsetY: Double = 0.0 
        var rotationX: Float = 0f 
        var rotationY: Float = 0f 
    } 

    假设我们有这么一个类,我们在操作一个地图变换的时候需要传入这个东西,告诉地图该怎么变换。

    mapView.animateChange(Options().apply {  
        //Options 的作用域 
        scale = 2f 
        rotationX = 180f 
    }) 

    而 with 呢?

    public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block() 

    跟 apply 比较类似,不同之处在与 Lambda 返回值。with 只是单纯的获取 receiver 的上下文,而 apply 则同时也把它本身返回了。

    val br = BufferedReader(FileReader("hello.txt")) 
    with(br){ 
        var line: String? 
        while (true){ 
            line = readLine()?: break 
        } 
        close() 
    } 

    我们看到在 with 当中,readLine 和 close 方法可以直接调用。

    内置高阶函数其实非常多,这几个比较常用,剩下的大家可以自行学习。

    3 尾递归优化

    递归大家都熟悉,一说递归大家都容易哆嗦:你可别递归的层次太深了啊,不然小心 StackOverflow!没错,StackOverflow 这个异常实在是太常见了,所以你最熟悉的程序员社交网站当中就有一个叫 StackOverflow 的。

    其实大家肯定也都知道,递归能实现的,用迭代也基本上能实现,这个感觉就好像做小学数学题,用递归就好比设个 x,列个方程求解;而用迭代呢,就好比用算式生生的去把结果给算出来。前者思考起来比较直接,编写起来也自然更符合人的思维模式,后者呢往往编写困难,代码可读性差。

    如果有一天,我能写出递归程序,编译器呢,却能够按照迭代的方式给我运行,那么我岂不是既能获得递归的简洁性,又不失迭代的运行效率,那该。。。想得美啊。

    我们今天就要给大家看一种特定条件下的编译优化措施。其实前面我们的设想并不是完全做不到,对于某些比较简单的场景,编译器是可以直接把我们的递归代码翻译成迭代代码的,而这种场景其实就是“尾递归”。

    什么叫“尾递归”?函数在调用自己之后,没有任何操作的情形就是尾递归。

    比如:

    data class ListNode(val value: Int, var next: ListNode?) 
      
    fun findListNode(head: ListNode?, value: Int): ListNode?{ 
        head?: return null 
        if(head.value == value) return head 
        return findListNode(head.next, value) 
    } 

    我们随便定义了一个链表,ListNode 是它的元素,findListNode 目的是找到对应值的元素。我们看到最后一行只有 findListNode 的调用,没有其他任何操作,这就是尾递归。

    我们再来看几个例子:

    fun factorial(n: Long): Long{ 
        return n * factorial(n - 1) 
    } 

    求阶乘,因为 factorial 调用之后还有乘以 n 的操作,所以这个不是尾递归。

    data class TreeNode(val value: Int){ 
        var left: TreeNode? = null 
        var right: TreeNode? = null 
    } 
      
    fun findTreeNode(root: TreeNode?, value: Int): TreeNode?{ 
        root?: return null 
        if(root.value == value) return root 
        return findTreeNode(root.left, value) ?: return findTreeNode(root.right, value) 
    } 

    这个算不算尾递归呢?好像最后一行的两个 return 都是之调用了 findTreeNode,没有其他操作了啊,这个应该是尾递归吧?答案当然不是。。因为第一个 findTreeNode 的结果拿到之后,我们要看下他是不是为 null,实际上这个判断操作在 findTreeNode 之后,所以不能算尾递归。对于不是尾递归的情况,编译器是没有办法做优化的。

    而对于尾递归的情况,我们该如何启用编译器优化呢?

    要说告诉编译器需要尾递归优化,其实非常简单,加一个关键字即可:

    tailrec fun findListNode(head: ListNode?, value: Int): ListNode?{ 
        head?: return null 
        if(head.value == value) return head 
        return findListNode(head.next, value) 
    } 

    这个看起来真的很简单,简单到没有说服力。我们看一段小程序:

    val MAX_NODE_COUNT = 100000 
    val head = ListNode(0) 
    var p = head 
    for (i in 1..MAX_NODE_COUNT){ 
        p.next = ListNode(i) 
        p = p.next!! 
    } 
    //前面先构造了一个链表,节点个数有 10 万个 
    //后面进行查找,查找值为 MAX_NODE_COUNT - 2 的节点 
    println(findListNode(head, MAX_NODE_COUNT - 2)?.value) 

    对于没有 tailrec 关键字的版本,结果非常抱歉:

    Exception in thread "main" java.lang.StackOverflowError 
        at net.println.kotlin.RecursiveKt.findListNode(Recursive.kt:34) 
        at net.println.kotlin.RecursiveKt.findListNode(Recursive.kt:34) 

    而对于有 tailrec 的版本,结果是:

    99998 

    显然,对于尾递归优化的版本,即使你递归再多的层次,都不会有 StackOverflow,原因也很简单,编译器其实已经把这种递归编译成迭代来运行了,迭代怎么会有 StackOverflow 呢?

    接着我们再来讨论一下非尾递归代码可以改写为尾递归代码的条件。大家仔细观察我们前面给出的两个例子,一个是求阶乘,一个是超找树的节点。二者最后一句:

    return n * factorial(n - 1) 
    return findTreeNode(root.left, value) ?: return findTreeNode(root.right, value) 

    虽然都不是尾递归,但还是有差异的。前者在调用完自己之后进行了跟调用自己无关的运算;后者调用完一次自己之后,还有可能调用一次自己。注意,如果调用完自己,又进行了其他操作,也即没有再次调用自己,那么这种递归其实有希望转换为尾递归代码,下面我们就改写一下求阶乘的代码,让它变成尾递归代码。

    fun factorial(n: Long): Long{ 
        class Result(var value: Long) 
      
        tailrec fun factorial0(n: Long, result: Result){ 
            if(n > 0) { 
                result.value *= n 
                factorial0(n - 1, result) 
            } 
        } 
        val result = Result(1) 
        factorial0(n, result) 
        return result.value 
    } 

    这个例子当中有一些比较有意思的概念哈,我们在一个函数当中定义了一个函数和一个类,它们被称作“本地函数”和“本地类”,由于定义在函数内部,因此在外部无法使用它们。接着我们对内部的 factorial0 加了 tailrec 关键字,由于最后一行只有对自己的调用,因此符合尾递归优化的条件。

    我们看到,之前 n * 的这部分操作通过 Result 携带的中间结果被移到了自身调用的前面,这样做让原本的递归代码符合了尾递归优化的条件,却也让代码本身复杂了许多。而对于此类操作,我个人更倾向于直接使用迭代。

    fun factorial(n: Long): Long{ 
        var result: Long = 1 
        for (i in 1..n){ 
            result *= i 
        } 
        return result 
    } 

    迭代的代码显然也直截了当得多。

    总而言之,使用递归是为了让我们的代码更直接,更自然,使用迭代往往是为了追求效率(空间效率)。对于类似查找链表节点这样的场景,它很自然的就是一个尾递归的结构,我们可以使用尾递归优化来提升它的性能;而对于求阶乘这样的场景,它本来就不是尾递归的结构,我们尽管可以通过某种方式改写它,但这样做其实根本没必要;而对于查找树节点这样的场景,尾递归基本上是无能无力了。

    4 闭包

    对象是要携带状态的。比如:

    val string = "HelloWorld" 

    string 这个对象它有值,这个值就是它的状态。那么同样作为对象的函数,它有什么状态呢?我们看个例子:

    fun makeFun(): ()->Unit{ 
        var count = 0 
        return fun(){ 
            println(++count) 
        } 
    } 
      
    ... 
      
    val x = makeFun() 
    x() 
    x() 
    x() 
    x() 

    输出的结果会是什么呢?从函数当中返回一个函数,这在 Java 当中简直不能想象,不过这在函数为“一等公民”的 Groovy、JavaScript 当中确实寻常可见。

    1 
    2 
    3 
    4 

    每次调用 x,打印的值都不一样,这说明函数也是可以保存状态的。受到这个启发,我们是不是可以继续写出这样的例子:

    fun fibonacci(): ()->Long{ 
        var first = 0L 
        var second = 1L 
        return fun(): Long{ 
            val result = second 
            second += first 
            first = second - first 
            return result 
        } 
    } 
    ... 
      
    val next = fibonacci() 
    for (i in 1..10){ 
        println(next()) 
    } 

    输出结果:

    1 
    1 
    2 
    3 
    5 
    8 
    13 
    21 
    34 
    55 

    我们干脆再进一步吧:

    fun fibonacciGenerator(): Iterable<Long>{ 
        var first = 0L 
        var second = 1L 
        return Iterable { 
            object : LongIterator(){ 
                override fun hasNext() = true 
      
                override fun nextLong(): Long { 
                    val result = second 
                    second += first 
                    first = second - first 
                    return result 
                } 
            } 
        } 
    } 
      
    ... 
      
    for(x in fibonacciGenerator()){ 
        println(x) 
        if(x > 100) break 
    } 

    这个例子我们干得更彻底,通过返回一个 Iterable,我们甚至可以用 for 循环迭代这个结果。

    不管我们怎么写,请注意,每次调用同一个函数的结果都不一样,而承载返回结果的 first 和 second 这两个变量是定义在最外层的函数当中的,按说这个函数一旦运行完毕,它所在的作用域就会被回收,如果真是那样,前面的这两段代码一定是我们产生的幻觉。如果不是幻觉,那只能说明一个问题:这个作用域没有被回收。

    这个作用域包含了所有函数运行的状态,包括变量、本地类、本地函数等等,那这个作用域其实就是闭包。

    我们再来看个好玩的例子:

    fun add(x: Int) = fun(y: Int) = x + y 
      
    ... 
    val add5 = add(5) 
    println(add5(2)) 

    很显然,结果是 7,这个 add 的定义其实写得有些令人迷惑,我把它改写一下给大家看:

    fun add(x: Int): (Int)->Int{ 
        return fun(y: Int): Int{ 
            return x + y 
        } 
    } 

    很显然,当我们调用 add(5) 返回 add5 这个函数时,它是持有了 add 函数的运行环境的,不然它怎么知道 x 的值是多少呢?

    通过这几个小例子,相信大家对闭包有了一定的了解。闭包其实就是函数运行的环境。

    下周我们还会继续跟大家讨论函数编程相关的一些话题,谢谢大家的关注

    展开全文
  • 本题判断二元关系的性质:自反性、对称性、传递性。

    本题判断二元关系的性质:自反性(reflexive)、对称性(symmetrical)、传递性(transitive)。

    输入格式:

    输入关系矩阵的阶数n(n<=10),接着输入如具有关系R的元素下标(i,j),输入 -1 -1,结束输入。判断该二元关系具有的性质。

    输出格式:

    输出二元关系a的性质,如果具有自反性性,则显示“a is reflexive”,如果具有对称性,则显示“a is transitive”,如果具有传递性,则显示“a is transitive”,如果具有自反性、对称性、传递性,则显示具有等价性“a is equivalent”。如果输入的n大于10,或者输入的数组元素下标i,j大于等于n(数组元素的下标应小于n),则显示"error",并结束程序。注意每个显示前后无空格,末尾回车。

    输入样例:

    在这里给出一组输入。例如:

    3
    1 0 2 0 0 1 2 1  0 2 1 2 -1 -1 
    

    输出样例:

    在这里给出相应的输出。例如:

    a is symmetrical

    一、知识点说明:

    一直以来用关系图理解自反对称传递等性质,放到关系矩阵中我就懵了

    首先关系图中有n个点 ,关系矩阵就用 n阶矩阵

    其次:三种性质都是蕴含式

    注意:记关系图中各点依次 为1,2,3....;关系矩阵中,有向边(关系)则用(i, j)表示

    最后三种性质特点(题目只考察自反对称传递,这里先不提反自反,反对称)

    1.自反性

    关系图,每个顶点都有环,则矩阵中表示(a, a)[即:有从该点自身到自身的有向边]

    关系矩阵,n阶矩阵,主对角线元素全为1.

    2.对称性

    关系图:如果两个顶点之间有边,则一定是一对方向相反的边

    (注意:这是蕴含式,如果前件不成立,两点之间连边都没有,同样满足对称性)

    关系矩阵:存在关系(a,b)且存在关系(b,a),即:矩阵为对称矩阵

    3.传递性

    关系图:如果顶点a到b有边,b到c有边,则a到c有边

    (同样注意:蕴含式,如果前件不成立,即不满足"a到b有边,且b到c有边",也满足传递性)

    关系矩阵:如果存在关系(a,b)且(b,c),则存在关系(a,c)

    二、代码:(分别用函数判断)

    最开始想着函数判断思路可能会更清晰,后来发现同学的代码不用函数更简洁

    #include<iostream>
    using namespace std;
    
    //1:判断自反性函数 :
    bool Reflexive(int ARR[10][10], int n)
    	{
    	int a1 = 0;//定义一个计数器,用于记录对角线为1的元素个数
    	for (int i = 0; i <= n; i++)
    		{
    		for (int j = 0; j <= n; j++)
    			{
    			if (ARR[i][j] == 1)//为1 的元素进入,准备判断各种性质
    				{
    				if (i == j)//其实两个条件可以合并
    					{
    					a1++;//满足自反的元素个数
    					}
    				}
    			}
    		}
    	if ( a1 == n)
    		{
    		return 1;//满足自反性,返回1
    		}
    	else
    		{
    		return 0;//不满足自反
    		}
    
    	}
    
    //2:判断对称性函数
    bool Symmetrical(int ARR[10][10], int n)
    	{
    	int B = 0;//记录关系数
    	int b= 0;//记录满足对称性的关系数目
    	for (int i = 0; i <= n; i++)
    		{
    		for (int j = 0; j <= n; j++)
    			{
    			if (ARR[i][j] == 1)
    				{
    				B++;//(1,1)这种对角线关系,也满足对称性定义
    				if (ARR[i][j] == 1 && ARR[j][i] == 1)
    					{
    					b++;//两个顶点间是双向边,则记录
    					}
    				}
    			}
    		}
    	if (b== B )//存在关系<i,j>,且存在<j,i>,双向边,则b==B
    		{
    		return 1;//满足对称
    		}
    	else
    		{
    		return 0;//不对称
    		}
    	}
    
    
    //3:判断传递性函数 :
    bool Transitive(int ARR[10][10], int n)
    	{
    	int C1 = 0;
    	int c1 = 0;
    	for (int i = 0; i <= n; i++)
    		{
    		for (int j = 0; j <= n; j++)
    			{
    			if (ARR[i][j] == 1)//为1 的元素进入,准备判断各种性质
    				{
    				for (int k = 0; k <= n; k++) //用于(j,k)
    					{
    					if (ARR[j][k] == 1)
    						{
    						C1++;//记录前件“顶点a到b有边,且b到c有边”	的次数					 
                            if (ARR[i][k] == 1)
    							{
    							c1++;//记录后件“a到c有边”的次数
    							}
    						}
    					}
    				}
    			}
    		}
    
    	if (c1 == C1 || C1 == 0)//前件后件均成立,顶点a到b有边,b到c有边,且a到c有边,则蕴含式为真,满足传递(c1==C1);或者蕴含式前件都不满足,即不存在“顶点a到b有边,且b到c有边”,蕴含式也为真,亦满足传递性(C1==0);
    		{
    		return 1;//满足传递性
    		}
    	else
    		{
    		return 0;//不满足传递性
    		}
    	}
    
    
    int main()
    	{
    //一:输入元素阶数n,以及元素关系(a,b),初始化关系 为1
    	int arr[10][10] = { 0 };
    	int n, a = 0, b = 0;
    	cin >> n;
    	while (a != -1 && b != -1)//输入(-1,-1)时,结束输入
    		{
    		cin >> a >> b;
    		if (n > 10 || a >= n || b >= n)//解决题目中[如果输入的n大于10,或者输入的数组元素下标i,j大于等于n(数组元素的下标应小于n),则显示"error",并结束程序。]问题
    			{
    			cout << "error";
    			return 0;
    			}
    		arr[a][b] = 1;//初始化该关系为1
    		}
    
    //二:调用函数判断并输出性质
    	int A, B, C;//记录性质,满足对应性质为1,不满足为0
    	A = Reflexive(arr, n);
    	B = Symmetrical(arr, n);
    	C = Transitive(arr, n);
    
    //这题输出格式,满足几条性质就输出几条性质;三种均满足,则输出三条性质外,还需格外输出等价性。
    	if (A == 1)
    		{
    		cout << "a is reflexive" << endl;
    		}
    	if (B == 1)
    		{
    		cout << "a is symmetrical" << endl;
    		}
    	if (C == 1)
    		{
    		cout << "a is transitive" << endl;
    		}
    
    	if (A == 1 && B == 1 && C == 1)//三种性质均满足,格外输出等价性
    		{
    		cout << "a is equivalent";
    		}
    
    	}

    有空了重做,简化了再来

    展开全文
  • 用高阶函数轻松实现Java对象的深度遍历前言背景知识的简单介绍幺元(identity)Java的函数类型函数的类型签名函数的幺元高阶函数Stream流式计算里的高阶函数对象的浅遍历List列表的遍历Map映射的浅遍历Set集合的浅遍历...
  • 文章目录前言多元函数微分学 前言 本笔记不涉及基础知识,重点在于分析考研数学的出题角度和对应策略。笔记随着做题的增多,不定时更新。且为了提高效率,用表线性...出题角度也是从这里面挑一到多进行考察。 ...
  • 一元函数,多元函数,可微的含义:就是用极限的思想近似反应两个可变因素之间函数关系。近似代替。 一元函数微分的几何意义:就是曲线x增加了一部分,y增加多少的表示。用了极限分割的思想,无线接近。dy与△y...
  • 写在前头:本人只是一名普通的大二学生,这学期刚学习《信号与系统》(郑君里第三版),对于书本中突然出现的“奇异函数平衡原理/奇异函数系数平衡”这知识点,一直搞不清楚(书上也没有特别的详细说明,网上查...
  • 高等数学-多元函数微分法

    万次阅读 多人点赞 2019-07-20 21:11:14
    1,多元函数的概念 1.1 函数是数集到数集的映射,多元函数是n维空间Rn上的点集D到一维空间R上的映射。n维空间R^n上的点集D到一...分别从y=x和y=-x两个方向去趋近)。 1.3 有界性与最大值最小值定理。在有界闭区域D上...
  • 文章目录Python函数函数式编程1、函数概述1.1函数的基本概念1.2函数的功能1.3Python中函数的分类2、函数的声明和调用2.1函 数对象的创建2.2函数的调用2.3函数的副作用3、参数的传递3.1形式参数和实际参数3.2形式...
  • 机器学习:核函数的一小题目

    万次阅读 2016-03-27 11:50:30
    题目:给一百万三角形,再给一点,判断在不在某个三角形内。 解法1:RTree 解法2:核函数映射。使得二维空间线性不可分的情况变为三维或四维空间线性可分的。 ------------------------------------------------...
  • 为什么要去学习函数式编程

    千次阅读 2020-12-31 14:58:53
    函数式编程在js当中是一比较抽象的概念,大家在以前可能听说过函数式编程,但是可能并没有系统的去了解过他们。 函数式编程和面向对象编程一样,是一套编程范式,你可以根据函数式编程的理论为你的代码设计这...
  • 第五章:函数和代码复用

    千次阅读 2020-12-04 19:45:26
    函数也可以看作是一段具有名字的子程序,可以在需要的地方调用执行,不需要在每执行地方重复编写这些语句。每次使用函数可以提供不同的参数作为输入,以实现对不同数据的处理。函数执行后,还可以反馈相应的处理...
  • 本文主要介绍了 MSE、MAE、CEE 、Hinge、Huber 等 15 常用损失函数的计算方式和使用场景,讲解 SGD、AdaGrad、Adam、RMSProp 4类优化器的公式原理,对阶跃激活函数、Sigmoid 激活函数、ReLU激活函数、Leaky ReLU ...
  • 概念:1 一个函数返回一个函数。2 函数参数可以接受一个函数。 满足任意点即可。 场景: 扩展方法 function core(...args){ // 核心代码 console.log('core'); } 要在core核心代码执行前后处理一些逻辑...
  • Visual Basic快捷教程——函数与子程序

    千次阅读 多人点赞 2017-04-19 22:30:14
    函数的本质就是为了把程序切分成若干相对独立的模块各司其职,而各个函数的作用也就是仅仅专门负责自己份内的那份功能。在Visual Basic中,函数是一组以Function开头和End Function结尾的封闭程序代码语句。当函数...
  • Hive 函数使用——窗口函数

    千次阅读 2022-03-29 19:06:53
    关系运算符是二元运算符,执行的是两个操作数的比较运算。每个关系运算符都返回boolean类型结果(true or false) •等值比较: = 、== •不等值比较: <> 、!= •小于比较: < •小于等于比较: <= •大于...
  • 如果将微博中的用户视作节点,用户之间关系视作节点之间的边,那么这些节点和边将构成一社交的网络拓扑结构,或称作社交图谱,如图1所示。微博中的信息从社交图谱中的某个节点发出,并通过边来传播。
  • MATLAB多元函数导数求极值或最优值

    千次阅读 2021-04-25 00:01:00
    MATLAB多元函数导数求极值或最优值 实验六 多元函数的极值 【实验目的】 1....计算多元函数的自由极值 对于多元函数的自由极值问题,根据多元函数极值的必要和充分条件,可分为以下几步骤: 步骤1.定义多元函数 步...
  • ⑤确定校正装置的传递函数:校正装置的两个转折频率可由 和 求出 最后写出校正装置的传递函数 串联超前校正受以下因素的限制: ①未校正系统不稳定,超前网络要提供很大的超前角,这样,超前网络的a必须很大,造成...
  • matlab常用函数

    千次阅读 2019-09-07 16:33:57
    一、软件操作函数 1)命令窗口函数: clc:清空命令窗口,使用向上箭头翻看命令。 open:打开文件,文本文件(*.doc),可执行文件(*.exe),图形文件(*.fig),超文本文件(*.html,*.htm),MATLAB数据库文件(*....
  • 函数式编程中的Functor详解

    千次阅读 2021-01-03 12:41:11
    其实函子就是一特殊的容器,我们可以把函子想象成一盒子,那这盒子里面有一值,并且这盒子对外要公布一方法,这方法我们叫做map,map方法会去接收一参数,这参数是一对值进行处理的函数。...
  • matlab函数总结

    千次阅读 2018-07-28 10:38:58
    size(A)返回A各个维的最大元素数 length(A)返回max(size(A)) [m,n]=size(A)如果A是二维数组,返回行数和列数 nnz(A)返回A中非0元素的个数 MATLAB的取整函数:fix(x), floor(x) :,ceil(x) , ro...
  • matlab基本函数

    千次阅读 2021-04-05 09:41:04
    linspace(开始,结束,元素数),等差生成指定元素数的一维矩阵,省略数则生成100 c = linspace(0,10,5); (4)特殊矩阵: zeros函数:产生零矩阵 ones函数:产生全1矩阵 eye函数:产生对角线为1的矩阵 rand函数...
  • 通俗理解:概率分布函数、概率密度函数

    千次阅读 多人点赞 2019-09-26 14:24:42
    这篇文章通俗地解释了概率论的两个基石函数:概率分布函数、概率密度函数,建议不熟悉的同学,认真阅读。1先从离散型随机变量和连续性随机变量说起对于如何分辨离散型随机变量和...
  • 实验五用matlab求二元函数及极值.doc

    千次阅读 2021-04-18 07:59:13
    1.计算二元函数的极值对于二元函数的极值问题,根据二元函数极值的必要和充分条件,可分为以下几步骤:步骤1.定义二元函数.步骤2.求解方程组,得到驻点.步骤3.对于每一驻点,求出二阶偏导数步骤4. 对于每一驻点,...
  • 复变函数与积分变换小结

    千次阅读 多人点赞 2020-11-19 17:06:53
    复变函数与积分变换第一章:复数与复变函数复数复数的基本概念复数的四则运算复平面复数的三角表示复数的模与辐角复数模的三角不等式复数的三角表示复数的三角表示作乘除法复数的乘方与开方平面点集开集与闭集区域...
  • oracle 高级函数

    千次阅读 多人点赞 2017-08-17 16:44:19
    工作年了,一直使用的oracle,最近经常使用不常用的sql语句,索性就自己整理一下,发出来 供大家参考,后续会不断添加、整理,本文章不做详细的功能解释,主要集合描述目前接触过的一些函数 复制表结构和数据 ...
  • 函数的可微与可导

    千次阅读 2021-01-27 20:20:41
    最近复习到高数的一元函数微分部分 ,可导和可微是两个特别重要也特别容易混淆的概念。所以简单记录一下,便于自己理解,仅供参考。 导数 从物理角度来说(牛顿是从物理学的角度发明出的微积分)某点的导数就是一个...
  • 2.4.1 函数极限的定义 函数极限时的无穷小与无穷大 函数极限与数列极限的关系 2.4.2 函数极限的性质、运算法则和判断法 判别法 2.4.3 两个重要的极限 2.4.4 无穷小的比较 2.5 函数的连续 2.5.1 连续的概念 2.5.2 间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,154
精华内容 8,461
关键字:

判断两个函数之间阶的关系

友情链接: Pre-processing.rar