6) 创建一元函数/二元函数functionCreater [原创,泛型编程,自由下载转载，需注明出处]

最新推荐文章于 2021-05-20 06:22:28 发布
最新推荐文章于 2021-05-20 06:22:28 发布
阅读量1k 收藏
点赞数 1
分类专栏： 原创的泛型库(完整代码见我的下载资源，本库已应用于项目) 文章标签： 泛型 C++ Meta programming
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tonny0832/article/details/19112755
版权

源代码可以在我的资源中去下载(包括用法测试的源代码):
http://download.csdn.net/detail/tonny0832/7426991
只需要用VS建一个空的工程，然后引入我的测试头文件即可。然后测试函数会在main函数之前运行，在控制台窗口中可以看到输出。


这个文件是和将多元函数转换为一元函数unaryFunctionConverter配合使用的，unaryFunctionConverter提供了转换的实现，但是使用起来不便，此文件functionCreater将这些转换封装成了makeUnaryFunction/makeBinaryFunction以方便使用，使用者只需要提供函数指针及必要的传入参数即可创建正确的一元/二元函数对象、


#ifndef functorCreater_h__
#define functorCreater_h__
/********************************************************************
created: 2014-1-9   15:35
author: Shen Tony

purpose: helper to create binary function , avoid writing complex template struct/class
                create interface to convert (global /member) function into unary function ,this function supports 5 parameters dynamical at most. e.g.
                R (*)(P1);
                R (*)(P1,P2);
                R (*)(P1,P2,P3);
                R (*)(P1,P2,P3,P4);
                R (*)(P1,P2,P3,P4,P5);
                R (O::*)(P1);
                R (O::*)(P1,P2);
                R (O::*)(P1,P2,P3);
                R (O::*)(P1,P2,P3,P4);
                R (O::*)(P1,P2,P3,P4,P5);


                UnaryFunction<F,x> : No.x parameter of functor F is input parameter in every call.
                FunctorParams<F>::Return_T is the return type of every calling
*********************************************************************/
#include "function.h"


namespace UtilExt
{
    /// binary function creator /
    template<typename TP1 ,typename TP2, typename R>
    BinaryFunction<R (*)(TP1,TP2)> makeBinaryFunction( R (*f)(TP1,TP2) )
    {
        return BinaryFunction<R (*)(TP1,TP2)>(f);
    }


    template<typename O,typename TP1 ,typename TP2, typename R>
    BinaryFunction<R (O::*)(TP1,TP2)> makeBinaryFunction(TPP(O) obj, R (O::*f)(TP1,TP2) )
    {
        return BinaryFunction<R (*)(TP1,TP2)>(obj,f);
    }


    /// unary function creator //
    template<typename F,int Idx> struct UnaryFunctionCreater;
    template<typename F> struct UnaryFunctionCreater<F,0> : public CreateUnaryFunctionImpl<F> { };
    template<typename F> struct UnaryFunctionCreater<F,1> : public CreateUnaryFunctionImpl<F> { };
    template<typename F> struct UnaryFunctionCreater<F,2> : public CreateUnaryFunctionImpl<F> { };
    template<typename F> struct UnaryFunctionCreater<F,3> : public CreateUnaryFunctionImpl<F> { };
    template<typename F> struct UnaryFunctionCreater<F,4> : public CreateUnaryFunctionImpl<F> { };
    template<typename F> struct UnaryFunctionCreater<F,5> : public CreateUnaryFunctionImpl<F> { };


    //member function
    template<typename R,typename O> 
    static UnaryFunction<R(O::*)(),0> makeUnaryFunction(R(O::*f)(),_)  { return UnaryFunctionCreater<R(O::*)(),0>::create(f,_$); };
    template<typename R,typename O,typename TP1> 
    static UnaryFunction<R(O::*)(TP1),0> makeUnaryFunction(R(O::*f)(TP1),_,TPP(TP1) p1)  { return UnaryFunctionCreater<R(O::*)(TP1),0>::create(f,_$,p1); };
    template<typename R,typename O,typename TP1,typename TP2> 
    static UnaryFunction<R(O::*)(TP1,TP2),0> makeUnaryFunction(R(O::*f)(TP1,TP2),_,TPP(TP1) p1,TPP(TP2) p2)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2),0>::create(f,_$,p1,p2); };
    template<typename R,typename O,typename TP1,typename TP2,typename TP3> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3),0> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3),_,TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3),0>::create(f,_$,p1,p2,p3); };
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4),0> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4),_,TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3,TPP(TP4) p4)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4),0>::create(f,_$,p1,p2,p3,p4); };
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4,TP5),0> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4,TP5),_,TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3,TPP(TP4) p4,TPP(TP5) p5)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4,TP5),0>::create(f,_$,p1,p2,p3,p4,p5); };


    template<typename R,typename O,typename TP1> 
    static UnaryFunction<R(O::*)(TP1),1> makeUnaryFunction(R(O::*f)(TP1),TPP(O) p0,_)  { return UnaryFunctionCreater<R (O::*)(TP1),1>::create(f,p0,_$); };
    template<typename R,typename O,typename TP1,typename TP2> 
    static UnaryFunction<R(O::*)(TP1,TP2),1> makeUnaryFunction(R(O::*f)(TP1,TP2),TPP(O) p0,_,TPP(TP2) p2)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2),1>::create(f,p0,_$,p2); };
    template<typename R,typename O,typename TP1,typename TP2,typename TP3> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3),1> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3),TPP(O) p0,_,TPP(TP2) p2,TPP(TP3) p3)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3),1>::create(f,p0,_$,p2,p3); };
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4),1> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4),TPP(O) p0,_,TPP(TP2) p2,TPP(TP3) p3,TPP(TP4) p4)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4),1>::create(f,p0,_$,p2,p3,p4); };    
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4,TP5),1> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4,TP5),TPP(O) p0,_,TPP(TP2) p2,TPP(TP3) p3,TPP(TP4) p4,TPP(TP5) p5)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4,TP5),1>::create(f,p0,_$,p2,p3,p4,p5); };


    template<typename R,typename O,typename TP1,typename TP2> 
    static UnaryFunction<R(O::*)(TP1,TP2),2> makeUnaryFunction(R(O::*f)(TP1,TP2),TPP(O) p0,TPP(TP1) p1,_)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2),2>::create(f,p0,p1,_$); };
    template<typename R,typename O,typename TP1,typename TP2,typename TP3> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3),2> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3),TPP(O) p0,TPP(TP1) p1,_,TPP(TP3) p3)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3),2>::create(f,p0,p1,_$,p3); };
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4),2> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4),TPP(O) p0,TPP(TP1) p1,_,TPP(TP3) p3,TPP(TP4) p4)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4),2>::create(f,p0,p1,_$,p3,p4); };    
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4,TP5),2> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4,TP5),TPP(O) p0,TPP(TP1) p1,_,TPP(TP3) p3,TPP(TP4) p4,TPP(TP5) p5)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4,TP5),2>::create(f,p0,p1,_$,p3,p4,p5); };


    template<typename R,typename O,typename TP1,typename TP2,typename TP3> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3),3> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3),TPP(O) p0,TPP(TP1) p1,TPP(TP2) p2,_)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3),3>::create(f,p0,p1,p2,_$); };
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4),3> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4),TPP(O) p0,TPP(TP1) p1,TPP(TP2) p2,_,TPP(TP4) p4)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4),3>::create(f,p0,p1,p2,_$,p4); };    
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4,TP5),3> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4,TP5),TPP(O) p0,TPP(TP1) p1,TPP(TP2) p2,_,TPP(TP4) p4,TPP(TP5) p5)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4,TP5),3>::create(f,p0,p1,p2,_$,p4,p5); };


    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4),4> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4),TPP(O) p0,TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3,_)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4),4>::create(f,p0,p1,p2,p3,_$); };    
    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4,TP5),4> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4,TP5),TPP(O) p0,TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3,_,TPP(TP5) p5)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4,TP5),4>::create(f,p0,p1,p2,p3,_$,p5); };


    template<typename R,typename O,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(O::*)(TP1,TP2,TP3,TP4,TP5),5> makeUnaryFunction(R(O::*f)(TP1,TP2,TP3,TP4,TP5),TPP(O) p0,TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3,TPP(TP4) p4,_)  { return UnaryFunctionCreater<R(O::*)(TP1,TP2,TP3,TP4,TP5),5>::create(f,p0,p1,p2,p3,p4,_$); };


    //non-member function
    template<typename R,typename TP1> 
    static UnaryFunction<R(*)(TP1),1> makeUnaryFunction(R(*f)(TP1),_)  { return UnaryFunctionCreater<R(*)(TP1),1>::create(f,_$); };
    template<typename R,typename TP1,typename TP2> 
    static UnaryFunction<R(*)(TP1,TP2),1> makeUnaryFunction(R(*f)(TP1,TP2),_,TPP(TP2) p2)  { return UnaryFunctionCreater<R(*)(TP1,TP2),1>::create(f,_$,p2); };
    template<typename R,typename TP1,typename TP2,typename TP3> 
    static UnaryFunction<R(*)(TP1,TP2,TP3),1> makeUnaryFunction(R(*f)(TP1,TP2,TP3),_,TPP(TP2) p2,TPP(TP3) p3)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3),1>::create(f,_$,p2,p3); };
    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4),1> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4),_,TPP(TP2) p2,TPP(TP3) p3,TPP(TP4) p4)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4),1>::create(f,_$,p2,p3,p4); };    
    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4,TP5),1> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4,TP5),_,TPP(TP2) p2,TPP(TP3) p3,TPP(TP4) p4,TPP(TP5) p5)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4,TP5),1>::create(f,_$,p2,p3,p4,p5); };


    template<typename R,typename TP1,typename TP2> 
    static UnaryFunction<R(*)(TP1,TP2),2> makeUnaryFunction(R(*f)(TP1,TP2),TPP(TP1) p1,_)  { return UnaryFunctionCreater<R(*)(TP1,TP2),2>::create(f,p1,_$); };
    template<typename R,typename TP1,typename TP2,typename TP3> 
    static UnaryFunction<R(*)(TP1,TP2,TP3),2> makeUnaryFunction(R(*f)(TP1,TP2,TP3),TPP(TP1) p1,_,TPP(TP3) p3)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3),2>::create(f,p1,_$,p3); };
    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4),2> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4),TPP(TP1) p1,_,TPP(TP3) p3,TPP(TP4) p4)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4),2>::create(f,p1,_$,p3,p4); };    
    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4,TP5),2> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4,TP5),TPP(TP1) p1,_,TPP(TP3) p3,TPP(TP4) p4,TPP(TP5) p5)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4,TP5),2>::create(f,p1,_$,p3,p4,p5); };


    template<typename R,typename TP1,typename TP2,typename TP3> 
    static UnaryFunction<R(*)(TP1,TP2,TP3),3> makeUnaryFunction(R(*f)(TP1,TP2,TP3),TPP(TP1) p1,TPP(TP2) p2,_)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3),3>::create(f,p1,p2,_$); };
    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4),3> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4),TPP(TP1) p1,TPP(TP2) p2,_,TPP(TP4) p4)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4),3>::create(f,p1,p2,_$,p4); };    
    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4,TP5),3> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4,TP5),TPP(TP1) p1,TPP(TP2) p2,_,TPP(TP4) p4,TPP(TP5) p5)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4,TP5),3>::create(f,p1,p2,_$,p4,p5); };


    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4),4> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4),TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3,_)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4),4>::create(f,p1,p2,p3,_$); };    
    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4,TP5),4> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4,TP5),TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3,_,TPP(TP5) p5)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4,TP5),4>::create(f,p1,p2,p3,_$,p5); };


    template<typename R,typename TP1,typename TP2,typename TP3,typename TP4,typename TP5> 
    static UnaryFunction<R(*)(TP1,TP2,TP3,TP4,TP5),5> makeUnaryFunction(R(*f)(TP1,TP2,TP3,TP4,TP5),TPP(TP1) p1,TPP(TP2) p2,TPP(TP3) p3,TPP(TP4) p4,_)  { return UnaryFunctionCreater<R(*)(TP1,TP2,TP3,TP4,TP5),5>::create(f,p1,p2,p3,p4,_$); };


}


#endif // functorCreater_h__

shenxiaolong1976
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在C++泛型编程中如何只特化类的某个成员函数
12-22
我们知道在C++模板编程中如果我们特化或是偏特化某个模板类， 我们需要重写整个模板类中的所有函数， 但是这些代码通常是非常相似的， 甚至在某些情况下可能只有一两个函数会不一样，其他函数都是一样的。...
【MATLAB函数】function定义函数
qq_42053235的博客
01-06 6万+
function [返回变量列表]=函数名（输入变量列表） 输入和返回变量个数分别由nargin和nargout两个MATLAB保留变量给出，只要进入该函数，MATLAB就将自动生成这两个变量。
3) 一元/二元函数抽象function [原创,泛型编程,自由下载转载，需注明出处]
申晓龙的专栏
02-12 1215
function/function object是运行时调用的基础，在模板中，最常用的函数是一元函数及二元函数。 通常一元函数R (*)(TP)是遍历的组件，如果R是bool类型或者进行二次封装（把R由非bool转换为bool），则一元函数R (*)(P)还可以成为测试组件，用于if的条件。 通常二元函数是R (*)(TP1,TP2)是比较/交换的组件，用于比较两个值，其用于if的条件，或者用
函数对象的创建方法——使用function操作符和使用Function构造函数
ch206265的博客
03-30 1151
一、常见函数对象的方法 先理清楚函数对象的几种创建方法： 1、使用function操作符创建 函数声明语法创建 函数表达式创建（匿名函数） 2、使用Function构造函数创建 二、代码示例 下面是不同创建方法对应的代码示例： 1.函数声明语法创建 //使用函数声明语法创建函数对象，最常用 function sum (num1, num2) { return num1 + num2; } ...
matlab二元一次方程求解_2-函数的求解计算
weixin_39776298的博客
12-04 1万+
一、本期介绍函数的求解有两种（1）已知x求y（2）已知y求x1.1已知x求y回想我们上一期，讲了多项式求解的方法，也是已知x求y。想一下，多项式不也是函数的一种吗，所以本期求解的方法同样适用于多项式，只不过比多项式稍微麻烦了一点点点。同学在学完本期内容之后可以对比下上一期。例1、求下列函数x=1,2,3,4,5对应y的值 对函数求解有两种方式：1.1.1创建函数文件这种方法的原理是：（1）构造一个...
遗传算法及其Matlab实现(二元函数实现）
weixin_44293582的博客
07-23 9699
文章目录5. 遗传算法实例6. 基本遗传算法原理解释7.Matlab代码实现 5. 遗传算法实例 参考文献： 1.《遗传算法原理及应用》 2.https://www.cnblogs.com/LoganChen/p/7509702.html 求下列二元函数的最大值： 运算过程如下： （1）个体编码 ​ 将x1，x2的定义域编码为一种符号串，该例题使用二进制编码。将编码后的x1，x2连接在一起形成个体的基因型。 例如：基因型 X = 100 010 ​ 其表现型 x = [4,2] ​ 基因型
matplotlib函数绘制一元二元函数数学建模可用
04-17
使用python 的matplotlib的制图小程序，可以适用于各种函数的绘制，支持三维（二元函数），二维（平面直角坐标）的图形绘制。简单易用，适合数学建模比赛制图。大佬可以无视。效果可以参见我之后的教学博客。
泛型<编程>：转移构造函数
02-22
我想你们知道得很清楚，创建，拷贝，并摧毁临时对象是你的C++编译器爱做的事，临时对象在内部被创建，不幸的是这极大影响到了C++程序的执行效率。实际上，临时对象是C++程序中最大的影响效率因素。这样的代码看上去...
C语言泛型编程实例教程
01-01
本文实例讲述了C语言泛型编程的方法，分享给大家供大家参考之用。具体分析如下： 首先，泛型编程让你编写完全一般化并可重复使用的算法，其效率与针对某特定数据类型而设计的算法相同。在C语言中，可以通过一些手段...
STL中的二元函数binary_function
丰空岛主(Vega Prime,Android,LabWindows,ThreeJS,Python,OpenCV）
06-06 4002
函数对象是重载了operator()的类的一个实例，operator()是函数调用运算符。 标准C++库根据operator()参数个数加以划分，主要有以下几种类型：        1  发生器：一种没有参数且返回一个任意类型值的函数对象，例如随机数发生器。        2  一元函数：一种只有一个任意类型的参数，且返回一个可能不同类型值的函数对象。        3  二元函数：一种有
【python】用numpy随机生成一元（多元）数据；如线性、指数、三角函数，或者多种样式结合
qq_43605229的博客
04-05 980
用numpy随机生成一元（多元）数据；如线性、指数、三角函数，或者多种样式结合（更新中）题目代码结果 题目 1.用numpy随机生成一元（多元）数据；如线性、指数、三角函数，或者多种样式结合； 2.画出数据散点图和模型曲线。 a)设置xy轴的坐标范围； b)散点图和模型曲线用不同颜色 代码 结果 ...
MATLAB求解二元(多元)函数极值
热门推荐
Cantjie
04-22 7万+
matlab求解二元函数极值命令： 1、x=fminsearch(fun,x0)或x=fminunc(fun,x0)求极小值点x，初值选为x0 2、[x,fmin]=fminsearch(fun,x0)或[x,fmin]=fminunc(fun,x0) 3、fminsearch采用单纯形法，fminunc采用牛顿法除了fminsearch和fminunc这两种命令外，建立函数还可以用不同的方法
MATLAB 函数句柄Function handle的用法（Af = @(x) A*x;）
夜空
04-01 2万+
函数句柄（Function handle）是MATLAB的一种数据类型。引入函数句柄是为了使feval及借助于它的泛函指令工作更可靠；使“函数调用”像“变量调用”一样方便灵活；提高函数调用速度，特别在反复调用情况下更显效率；提高软件重用性，扩大子函数和私用函数的可调用范围；迅速获得同名重载函数的位置、类型信息。        MATLAB中函数句柄的使用使得函数也可以成为输入变量，并且能很方便的
一元函数的C语言,遗传算法c语言源代码(一元函数和二元函数)（32页）-原创力文档...
weixin_42363377的博客
05-20 137
C 语言遗传算法代码以下为遗传算法的源代码，计算一元代函数的代码和二元函数的代码 以+++++++++++++++++++++++++++++++++++++为分割 线分割开来，请 自行选择适合的代码，使用时请略看完代码的注释，在要更改的地方更改为自己需要的代码。+++++++++++++++++++++++++++++++一 元 函 数 代 ...
c语言自定义一元函数,[编程入门]自定义函数求一元二次方程-题解(C语言代码)...
weixin_31559919的博客
05-18 269
```javaimport java.text.DecimalFormat;import java.util.Scanner;/*** @author Administrator* @date 2019/11/29 0029上午 11:15*/public class 问题1028自定义函数求一元二次方程 {private static double a, b, c, beita, x1, x2;...
matlab 二元函数的极限,利用MATLAB软件求解一元和二元函数的极值
weixin_31455121的博客
03-20 4447
CourseEducationResearch课程教育研究 2018 年第 40 期 利用 MATLAB 软件求解一元和二元函数的极值 易 强 吕希元 (重庆工商大学融智学院 重庆 400030) 【摘要】本文主要介绍利用 MATLAB 软件在电脑上来求解微积分里的一元和二元函数的极值的计算问题。 【关键词】MATLAB 极值 输入命令 【中图分类号】O172 【文献标识码】A 【文章编号】209...
一元函数对象、二元函数对象、一元谓词函数对象、二元谓词函数对象、lambda表达式、函数适配器binder2nd及其辅助函数bind2nd
ShenHang_的博客
05-07 270
一元函数对象：函数参数1个 二元函数对象：函数参数2个； 一元谓词对象：函数参数1个，函数返回值是bool类型，可以作为一个判断式，谓词可以是一个仿函数，也可以是一个回调函数； 二元谓词对象：函数参数2个，函数返回值是bool类型； 之所以给返回布尔类型的函数对象专门命名，是因为谓词是用来为算法判断服务的。 一元谓词 ...
C++ binary_function与unary_function使用详解
sinat_31608641的博客
11-20 1927
一、unary_function的介绍 unary_function可以作为一个一元函数对象的基类，它只定义了参数和返回值的类型，本身并不重载（）操作符，这个任务应该交由派生类去完成。 源码 template <class Arg, class Result> struct unary_function; template <class Arg, class Result> // 1个参数，一个返回值 struct
函数的创建 function
人生如梦
03-28 1655
函数的创建 函数声明 function demo () { // ... } 函数表达式 var demo = function () { // ... } Function 构造函数 (不常用) var demo = new Function( 'x', 'y', 'return x + y' ); // 等同于 function ...
matlab求一元函数和二元函数相乘的积分
最新发布
03-09
可以使用matlab中的int函数来求解一元函数和二元函数相乘的积分。例如，对于一元函数f(x)和二元函数g(x,y)，可以使用以下代码来求解它们的积分： syms x y; f = x^2; g = exp(-x*y); int(f*g,x,,1) 其中，syms x y...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值