package kotlinall.chapter5

import java.io.OutputStream
import java.nio.charset.Charset

//复合函数
//求f(g(x))的值
val add5={i:Int->i+5}
val mutilplyBy2 = {i:Int-> i*2}


//复合函数 扩展Function1的扩展方法 infix 中缀表达式
//Function1 传入1个参数的函数 P1 接收的参数类型 P2返回的参数类型
//扩展方法andThen接收一个 一个参数的函数 他的参数 是add5的返回值 再返回最终结果
//andThen左边的函数  Function1<P1,P2> 接收一个参数P1 返回结果P2
//andThen右边的函数 function:Function1<P2,R> 参数为左边函数的返回值P2 返回结果R
//聚合的结果返回函数Function1<P1,R> 是以P1作为参数 R做为结果的函数
//相当于P1,P2 聚合 P2,R 返回 P1,R
//f(g(x))  P1相当于x P2 相当于g(x)返回值 返回的结果Function1<P1,R> R相当于f(g(x)) 的返回值
//Function1<P1,P2> 相当于g(x)
//function:Function1<P2,R> 相当于x
//g(x).andThen(f(g(x)))
infix fun<P1,P2,R> Function1<P1,P2>.andThen(function:Function1<P2,R>):Function1<P1,R>{
    return fun(p1:P1):R{
        return function.invoke(this.invoke(p1))//先执行函数 p1返回p2 再执行 function(p2)返回R
    }
}
//compose左边函数接收参数P2 返回R
//compse右边函数 接收参数P1 返回P2
//返回结果函数P1,R
//相当于先执行右边返回了P1,P2  在执行P2,R函数 聚合成P1,R
//g(f(x))
//f(x).compose(g(f(x)))
infix fun<P1,P2,R> Function1<P2,R>.compose(function:Function1<P1,P2>):Function1<P1,R>{
    return fun(p1:P1):R{
        return this.invoke(function.invoke(p1))
    }
}
//复合函数
fun executeFuhe(){
    println(mutilplyBy2(add5(8)))//(5+8)*2
    val add5andThen = add5 andThen mutilplyBy2
    println(add5andThen(8))
    val add5ComposeThen = add5 compose  mutilplyBy2
    println(add5ComposeThen(8))//g(f(x)) 先*2 再+5
}

//函数的链式调用
//Currying 多元函数变成一元函数的调用链
fun hello(x:String,y:Int,z:Double):Boolean{
    return true
}
//多个参数的函数 演变成多个单参数函数的链式调用
//fun curriedHello(x:String):(y:Int)->(z:Double)->Boolean{
//}
fun log(tag:String,target:OutputStream,message:Any?){
    target.write("[$tag] $message\n".toByteArray())
}

fun log1(tag:String) = fun(target:OutputStream)=fun(message:Any?)=target.write("[$tag] $message\n".toByteArray())
//三个函数链式调用的扩展方法
fun <P1,P2,P3,R> Function3<P1,P2,P3,R>.curry() = fun(p1:P1)=fun(p2:P2)=fun(p3:P3) = this(p1,p2,p3)
fun curryExecute(){
    log("gac",System.out,"HelloWorld")
    log1("gacmy")(System.out)("hello worldAgain")
    ::log.curry()("gacmy")(System.out)("hello worldAgain") //不需要写链式调用方法 统一为模板方法
}


//偏函数
//
fun pianhanshu(){
    val consoleLog=::log.curry()("gac")(System.out)
    consoleLog("hello pioanhanshu")

    val makeString = fun(byteArray:ByteArray,charset:Charset):String{
        return String(byteArray,charset)
    }
    //偏函数
    val makeStringGBK = makeString.partial2(charset("GBK"))
    makeStringGBK("反反复复付".toByteArray())
}
//偏函数的模板方法 固定第二个参数 只需要 最后传入一个参数的函数
fun <P1,P2,R> Function2<P1,P2,R>.partial2(p2:P2) = fun(p1:P1) = this(p1,p2)

//偏函数的模板方法 固定第一个参数 只需要 最后传入一个参数的函数
fun <P1,P2,R> Function2<P1,P2,R>.partial(p1:P1) = fun(p2:P2) = this(p1,p2)


fun main(args: Array<String>) {
   executeFuhe()
   curryExecute()
    pianhanshu()

}

【数学知识】函数与复合函数编程实现
1、函数定义
多项式
指数函数与对数函数
正弦函数
2、复合函数

本博客适合高中学生入门编程知识学习，从高中的数学概念转换到其python实现，提高自身对编程的学习兴趣。
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# 在jupyter notebook显示图片

1、函数定义
我们可以将函数(functions)想象成一台机器f ，每当我们向机器提供输入x，这台机器便会产生输出y。
这台机器所能接受的所有输入x的集合称为定义域(domain)，其所有可能输出y的集合称为值域(range)。函数的定义域和值域有着非常重要的意义，如果我们知道一个函数的定义域，便不会将不合适的输入丢给函数；知道函数的值域，便能判断一个值是否可能是这个函数所输出的。
多项式
# 多项式
# 初中：一元一次函数 y = k*x+b
def f1(x):
    y = 2*x+3  # k=2, b=3
    return y


x = 100
print(f1(100))

203

三次多项式：
$f(x)=x^3-5x^2+9$
# 三次多项式
def f3(x):
    return x**3 - 5*x**2 + 9  # *：乘号 **：求次方

# 画图
x = np.linspace(-100, 100, num = 1000)
y = f3(x)
plt.plot(x,y)

结果如下：


# 5次多项式
def f5(x):
    return 5*x**5+4*x**3+x**3 - 5*x**2 + 9  # *：乘号 **：求次方

y = f5(x)
plt.plot(x,y)


指数函数与对数函数
两个常用的常数：
欧拉常数e

$e = 2.718281828459045$

圆周率pi

$\pi = 3.141592653589793$
# 欧拉常数e
print(np.e)  # e=2.71828
# pi
print(np.pi)  # pi=3.1415926

# 指数函数
def exp(x):
    y = np.e**x  # np.e 就是欧拉常数
    return y  # y>0

y = exp(x)
plt.plot(x,y)

结果如下：


print(exp(0))

1.0

print(exp(-10000))

0.0

$e^x$的本质：

$e^x={x^0}/{0!}+{x^1}/{1!}+{x^2}/{2!}+{x^3}/{3!}+...+{x^n}/{n!}$
对数函数是指数函数的反函数

如果 $y=e^x$

那么 $x=ln(y)$,  y>0
x = np.linspace(0.0001,100,1000,endpoint = False)
y1 = np.log2(x)  # 以2为底
y2 = np.log(x)   # 以e为底
y3 = np.log10(x)  # 以10为底
plt.plot(x,y1,'red',x,y2,'yellow',x,y3,'blue')


正弦函数
正弦函数:

$y = sin(x)$

以及它的变形

$y = Asin({\omega}x+\theta)$
x = np.linspace(-10, 10, num = 1000)
y = np.sin(x)
plt.plot(x,y)

结果如下：


余弦函数:

$y = cos(x)=sin(x+{\pi}/2)$

以及它的变形

$y = Acos({\omega}x+\theta)$
y1 = np.sin(x)   # sin(x)
y2 = np.cos(x)  # cos(x)
plt.plot(x,y1,'red',x,y2,'blue')

下图中红色为sin(x)，蓝色为cos(x)：


2、复合函数
函数$f(x)$和$g(x)$的复合$fg(x)$:，可以理解为首先将输入$x$给函数$g(x)$获得输出y1后将其进而输入给函数$f(x)$，最终获得结果$y$。例如：
$f(x) = 1/x$
$g(x) = e^{-x}+1$
$fg(x) = f(g(x)) = 1/(1+e^{-x})$

这个复合函数实际上是$sigmoid(x)$

链式法则是微积分中的求导法则，用于求一个复合函数的导数

采用复合函数表示十分复杂的函数，有利于我们进行求导运算！

同时，在编程过程中，采用复合函数，将一个复杂的问题分解为若干个阶段的函数，有利于编程调试，容易发现逻辑错误！
def f(x):
    y = 1/x
    return y

def g(x):
    y = np.exp(-x)+1
    return y

# 这是一个复合函数
def sigmoid(x):
    return f(g(x))

x = 1
print(sigmoid(x))

0.7310585786300049

x = np.linspace(-10, 10, num = 10000)
y = sigmoid(x)
plt.plot(x,y)


另一个常用的复合函数：$softplus(x)$
$f(x) = log(x)$
$g(x) = 1+e^x$
$fg(x) = f(g(x)) = log(1+e^x)$
def f(x):
    y = np.log(x)
    return y

def g(x):
    y = np.exp(x)+1
    return y

# 这是一个复合函数
def softplus(x):
    return f(g(x))

x = 1
print(softplus(x))

1.3132616875182228

x = np.linspace(-10, 10, num = 10000)
y = softplus(x)
plt.plot(x,y)



【作者简介】陈艺荣，男，目前在华南理工大学电子与信息学院广东省人体数据科学工程技术研究中心攻读博士，担任IEEE Access、IEEE Photonics Journal的审稿人。两次获得美国大学生数学建模竞赛(MCM)一等奖，获得2017年全国大学生数学建模竞赛(广东赛区)一等奖、2018年广东省大学生电子设计竞赛一等奖等科技竞赛奖项，主持一项2017-2019年国家级大学生创新训练项目获得优秀结题，参与两项广东大学生科技创新培育专项资金、一项2018-2019年国家级大学生创新训练项目获得良好结题，发表SCI论文4篇，授权实用新型专利8项，受理发明专利13项。

我的主页

我的Github

我的CSDN博客

我的Linkedin

目录

函数奇偶性运算法则，以及复合函数奇偶性判断

ln的运算法则，对数函数运算法则

对数函数运算法则口诀，简单记忆

函数奇偶性运算法则，以及复合函数奇偶性判断

下面给你它们四则运算的规律：

1奇函数+奇函数=奇函数

2奇函数+偶函数=非奇非偶函数（特殊的可能是别的结果,不过特殊时可以用定义判断出来的）

3偶函数+偶函数=偶函数

4奇函数*奇函数=偶函数

5偶函数*偶函数=偶函数

6奇函数*偶函数=奇函数

 

复合函数：由两个函数复合而成的复合函数，当里层的函数是偶函数时，复合函数的偶函数，不论外层是怎样的函数；当里层的函数是奇函数、外层的函数也是奇函数时，复合函数是奇函数，当里层的函数是奇函数、外层的函数是偶函数时，复合函数是偶函数。

 

重要：只有奇奇是奇奇，别的都是偶。

 

ln的运算法则，对数函数运算法则

1、ln(MN)=lnM +lnN

2、ln(M/N)=lnM-lnN    千万注意：lnM  / lnN !=ln(M/N)   记住没有

3、ln（M^n)=nlnM

4、ln1=0

5、lne=1

注意：M>0，N>0

自然对数是以常数e为底来数自的对数，记作lnN(N>0)。

对数函数运算法则口诀，简单记忆

（1）乘除变加减，指数提到前：

log a M·N＝log a M＋log a N           由内而外的

log a M/N ＝log a M－log a N

log a Mn＝nlog a M

（2）底真倒变，对数不变；

底真互换，对数倒变；

底真同方，对数一样。

（3）底是正数不为1（在log a N ＝b中，a＞0，a≠1），

底的对数等于1（log a a＝1），

1的对数等于零（log a 1＝0），

零和负数无对数（在log a N＝b中，Ｎ＞０）。

首先，对于简单的凸函数的相加，凸函数求最大值，都是能够保证函数的凸性的，相比而言，复合函数就较为复杂了。
给定函数$f:R^k\rightarrow R$以及$g:R^n\rightarrow R^k$，我们定义复合函数$f=h\cdot g:R^n\rightarrow R$为：

$f(x)=h(g(x)), dom f=\{x\in dom g|g(x)\in dom h\}$

我们考虑当复合函数保持凸性或者凹性时，两个函数分别应该满足什么样的条件。

$\textbf\color{orange}{标量}$

对标量而言，上述方程我们直接求二阶导进行判定即可，复合函数的二阶倒数为
$f''(x)=h''(g(x))g'(x)^2+h'(g(x))g''(x)$

如果这个值恒大与0，那么函数就满足凸函数的性质，那么我们有以下结论：



$\textbf\color{orange}{Genaral Case}$
注意上述结论成立的条件：$g,h$都是二次可微的，而且他们的定义域都是$R$。事实上，对于更一般的情况，$n>1$，不再局限于一维空间，也不再假设$g,h$可微或者$dom g\in R^n,dom h\in R$，一些相似的复合规则仍然成立。



这里需要用到函数的拓展，将函数的定义域拓展到整个$R^n$空间显然会使得我们的分析更加简单。$\widetilde h$即$h$函数的拓展，如果点$g(x)$不在定义域中，而且$h$是凸函数，那么对其赋值为$\infty$（保持$h$的凸性）。反之如果$h$是凹函数，那么对其赋值为$-\infty$。可以看到，这里和上面唯一的不同就在于，我们对$h$函数进行了扩展，使其在整个空间内非增或者非减。

$\textbf\color{grey}{函数扩展的注意事项}$

需要注意的是，函数的扩展非常重要，我们需要$\widetilde h$在整个空间内有单调性，而不只是在定义域内
考虑如下函数：



显然在定义域内$h$是不增不降的，既是凸函数也是凹函数，如果我们根据上述条件，只考虑$\widetilde h$在定义域内的单调性的话，显然复合函数即可以使用第一条性质也可以使用第二条性质，但是实际上，这个函数既不是凸函数，也不是凹函数，因为他连定义域都不是凸的：



而且当我们对他进行函数扩展时可以发现无论是进行凸扩展还是凹扩展，他的$\widetilde h$始终是不具有单调性的，因此该函数既没有凸性，也没有凹性。Again，$\widetilde h$必须在整个空间内具有单调性。

$\textbf\color{orange}{Simple Example}$

函数$h(x)=\log x$，定义域为$dom h=R_{++}$，其在$x\leq0$处扩展为$-\infty$，可以得到$\widetilde h$非减，且$h(x)$为凹函数。
函数$h(x)=x^{1/2}$，定义域为$dom h=R_{+}$，其在$x<0$处扩展为$-\infty$，可以得到$\widetilde h$非减，且$h(x)$为凹函数。
函数$h(x)=x^{3/2}$，定义域为$dom h=R_{+}$，如果其在$x<0$处扩展为$\infty$，可以得到$h(x)$为凹函数，但是不满足$\widetilde h$非减的条件，
函数$h(x)=x^{3/2}$，定义域为$dom h=R_{+}$，如果其在$x<0$处扩展为$0$，可以得到$h(x)$为凹函数，而且满足$\widetilde h$非减的条件，


$\textbf\color{orange}{简单的复合结论}$