C++ 求 f(x) = sin x / x 的函数极限

Python： 

import sympy
from sympy import oo #注意无究符号表示形式为两个小定字母o
import numpy as np
x = sympy.Symbol('x') #注意Symbol首字母大写

f = sympy.sin(x) / x   # 定义极限表达式

lim = sympy.limit(f,x,oo)
print(lim)

输出：

0
 
C++

#include "X:\Work\Share\CCode\CPlatform\MathExt\_MathExt_out.h"
 
using namespace lf;
using namespace std;
  
int main()
{
       
    _Variable x;
     
    _function  f;
    

    //设置 x 趋向于正无穷大
    x.SetLimitsTo(_LimitsTo::PositiveInfinity);

    //这句其实没什么意义，只是为更像于数学表达式
    //相当于 f = x;
    f(x) = _sin(x) / x;

    _cout << f.limit() << "\n";        
     
}

输出：

0

主要源码：

_Variable _sin(const _Variable& x)
{
    _Variable vResult;
          
    if (x._limit == _LimitsTo::PositiveInfinity || x._limit == _LimitsTo::NegativeInfinity)
    {
        vResult._fixedMax = 1;
        vResult._fixedMin = -1;
    }

    return vResult;
}

_Variable _Variable::operator/(const _Variable& vRight) const
{
    //_cout << _t("_Variable _Variable::operator/(const _Variable& vRight) const");


    //有最大值边界
    if (this->_fixedMax._t != _ValueType::Null || this->_fixedLimitMax._t != _ValueType::Null)
    {
        //也有最小值边界
        if (this->_fixedMin._t != _ValueType::Null || this->_fixedLimitMin._t != _ValueType::Null)
        {
            //有最大值边界的数 /  正无穷或负无穷 = 0
            if (vRight._limit == _LimitsTo::PositiveInfinity || vRight._limit == _LimitsTo::NegativeInfinity)
            {
                return (_Variable)0;
            }
        }

    }
 
    
    return _Variable();
}

有兴趣的朋友自己去完善。 

头文件：

/// <summary>
/// 取值范围，趋向于。
/// </summary>
/// 创建时间： 2024-05-03     最后一修改时间：2024-05-03  
enum class _LimitsTo
{
	/// <summary>
	/// 正无穷大
	/// </summary>
	PositiveInfinity,

	/// <summary>
	/// 负无穷小
	/// </summary>
	NegativeInfinity,
	 
	/// <summary>
	/// 区间值
	/// </summary>
	IntervalValue,

	/// <summary>
	/// 固定值
	/// </summary>
	FixedValue,
	 
	/// <summary>
	/// 任意值
	/// </summary>
	AnyValue,
};


/// <summary>
/// 值类型
/// </summary>
/// 创建时间： 2024-05-03     最后一修改时间：2024-05-03
enum class _ValueType
{
	Null,
	Int,
	Double,


};



/// <summary>
/// 
/// </summary>
/// 创建时间： 2024-05-03     最后一修改时间：2024-05-03
class _Value : public _Object
{
public:
	/// <summary>
	/// 保存固定值的内存区域
	/// </summary>
	_Array<_byte> _m;

	_ValueType _t;

public:
	_Value();
	_Value(const int& i);
	_Value(const double& d);
	~_Value();

public: //--------------------------------重写
	virtual _string ToSplitString(const _string& sSplitString) const;
};


/// <summary>
/// _Variable实际描述的是一个集合
/// </summary>
/// 创建时间： 2024-04-14     最后一修改时间：2024-05-03
class _Variable  : public _Object
{
public:
	/// <summary>
	/// 所属数集数型
	/// </summary>
	_ManifoldType _mt;

	/// <summary>
	/// 固定值
	/// </summary>
	_Value _fixed;
	 
	/// <summary>
	/// 最大极限的固定值
	/// </summary>
	_Value _fixedLimitMax;

	/// <summary>
	/// 最小极限的固定值
	/// </summary>
	_Value _fixedLimitMin;


	/// <summary>
	/// 最大固定值
	/// </summary>
	_Value _fixedMax;


	/// <summary>
	/// 最小固定值
	/// </summary>
	_Value _fixedMin;

	/// <summary>
	/// 取值范围，趋向于。
	/// </summary>
	_LimitsTo _limit;
	 
	/// <summary>
	/// 符号名
	/// </summary>
	_string _symbolName; 

public: //构造函数与析构函数
	_Variable();
	~_Variable();


	_Variable(const _Variable& v);


	/// <summary>
	/// _Variable x = 5;  //相当于 _Variable x(5);
	/// 此时调用是 _Variable(const int& iValue)
	/// </summary>
	/// <param name="iValue"></param>
	/// 创建时间： 2024-04-14     最后一修改时间：2024-04-14  
	explicit _Variable(const int& i);


	/// <summary>
	/// 
	/// </summary>
	/// <param name="d"></param>
	/// 创建时间： 2024-04-15     最后一修改时间：2024-04-15  
	explicit _Variable(const double& d);

public:  //-------------------------------------运算符重载	 

	/// <summary>
	/// _Variable x;
	/// x = 5;  此时调用是operator=
	/// </summary>
	/// <param name="n"></param>
	/// <returns></returns>
	/// 创建时间： 2024-04-14     最后一修改时间：2024-04-14  
	_Variable operator=(const int& iValue);

	explicit operator int() const;	 


	_Variable operator-(const int& n) const;
	_Variable operator+(const int& n) const;

	_Variable operator/(const int& n) const;
	_Variable operator/(const _Variable& vRight) const;

	friend _Variable operator/(const int& iLeft, const _Variable& vRight);

	// 重载加法运算符
	_Variable operator+(const _Variable& other) const;

	_Variable operator*(const _Variable& other) const;

	_Variable operator^(const _Variable& other) const;

	_Variable operator^(const size_t& nPower) const;

public:  //--------------------------------功能函数
	/// <summary>
	/// 
	/// </summary>
	/// <param name="lim"></param>
	/// 创建时间： 2024-05-03     最后一修改时间：2024-05-03 
	void SetLimitsTo(const _LimitsTo& lim);



	/// <summary>
	/// 获取最大值，当取值范围在区间内存才有最大值，最小值。
	/// 例如闭区间 [0,1] 中的 1 , 没有返回NULL。
	/// </summary>
	/// <returns></returns>
	/// 创建时间： 2024-05-03     最后一修改时间：2024-05-03 
	_Variable GetMaxValue()const;


	/// <summary>
	/// 获取最小值，当取值范围在区间内才有最大值，最小值。
	/// 例如闭区间 [0,1) 中的 0 , 没有返回NULL。
	/// </summary>
	/// <returns></returns>
	/// 创建时间： 2024-05-03     最后一修改时间：2024-05-03 
	_Variable GetMinValue()const;


	/// <summary>
	/// 永远达不到又永远迫近的那个值。
	/// 例如开区间（0,1) 中的 0 和 1，没有返回NULL。
	/// </summary>
	/// <returns></returns>
	_Variable GetLimitValue()const;

public: //--------------------------------重写
	virtual _string ToSplitString(const _string& sSplitString) const;
private:

};

 





class _function : public _Object
{
private:
	_Variable _resultVar;

public:
	_function(const _Variable& v);
	_function();

	_Variable& operator()(const _Variable& other);

	_Variable& limit();
	 
};


/// <summary>
/// 
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
/// 创建时间： 2024-05-03     最后一修改时间：2024-05-03  
_Variable _sin(const _Variable& x);

源文件：


/************************************************************************

						_Variable


***********************************************************************/

_Variable::_Variable() : _mt(_ManifoldType::实数), _limit(_LimitsTo::AnyValue)
{
 
}
 

_Variable::_Variable(const int& i)
{

	_fixed = i;

	_mt = _ManifoldType::整数;
	_limit = _LimitsTo::FixedValue;
}

_Variable::_Variable(const double& d)
{
	_fixed = d;

	_mt = _ManifoldType::有理数;
}

_Variable::~_Variable()
{
	
}

_Variable::_Variable(const _Variable& v)
{
	_mt = v._mt;  // 所属数集数型

	 
	_fixed = v._fixed; // 固定值

 
	_fixedLimitMax = v._fixedLimitMax; // 最大极限的固定值

 
	_fixedLimitMin = v._fixedLimitMin;// 最小极限的固定值


	 
	_fixedMax = v._fixedMax; // 最大固定值


	 
	_fixedMin = v._fixedMin; // 最小固定值

	 
	_limit = v._limit;

	 
	_symbolName = v._symbolName;// 符号名
	  
}

_Variable _Variable::operator=(const int& iValue)
{
	_cout << _t("_Variable _Variable::operator=(const int& iValue)\n");

	_fixed = iValue;

	_mt = _ManifoldType::整数;

	return *this;	 
}
 
_Variable::operator int() const
{
	//const int* pint =
	return *((int*)(_fixed._m.DataConst));
}
 
 
_Variable _Variable::operator-(const int& n) const
{
	_cout << _t("_Variable _Variable::operator-\n");
	return _Variable();
}

_Variable _Variable::operator+(const int& n) const
{
	_cout << _t("_Variable _Variable::operator+\n");
	return _Variable();
}

_Variable _Variable::operator/(const int& n) const
{
	_Variable vResult = *this;

	_cout << _t("Variable _Variable::operator/\n");

	if (_limit == _LimitsTo::PositiveInfinity) //正无穷 /  整数
	{
		if (n > 0)
			return vResult;
		else //正无穷  /  负数 = 负无穷
		{			 
			vResult._limit = _LimitsTo::NegativeInfinity;
		}
	}
	else if(_limit == _LimitsTo::PositiveInfinity) //负无穷 /  整数
	{
		if (n > 0)
			return vResult;
		else //负无穷  /  负数 = 正无穷
		{
			vResult._limit = _LimitsTo::PositiveInfinity;
		}
	}
	return vResult;
}

_Variable _Variable::operator/(const _Variable& vRight) const
{
	//_cout << _t("_Variable _Variable::operator/(const _Variable& vRight) const");


	//有最大值边界
	if (this->_fixedMax._t != _ValueType::Null || this->_fixedLimitMax._t != _ValueType::Null)
	{
		//也有最小值边界
		if (this->_fixedMin._t != _ValueType::Null || this->_fixedLimitMin._t != _ValueType::Null)
		{
			//有最大值边界的数 /  正无穷或负无穷 = 0
			if (vRight._limit == _LimitsTo::PositiveInfinity || vRight._limit == _LimitsTo::NegativeInfinity)
			{
				return (_Variable)0;
			}
		}

	}
 
	
	return _Variable();
}

_Variable _Variable::operator+(const _Variable& other) const
{
	_cout << _t("_Variable _Variable::operator+\n");
	return _Variable();
}

_Variable _Variable::operator*(const _Variable& other) const
{
	_cout << _t("_Variable _Variable::operator*\n");
	return _Variable();
}

 
_Variable _Variable::operator^(const _Variable& other) const
{
	_cout << _t("_Variable::operator^\n");
	return _Variable();
}
 

_Variable _Variable::operator^(const size_t& nPower) const
{
	if (_mt == _ManifoldType::整数)
	{
		int i = *((int*)_fixed._m.DataConst);

		return  _Variable(_Math::pow(i, nPower));
	}
	else if (_mt == _ManifoldType::有理数)
	{
		int d = *((double*)_fixed._m.DataConst);
		return _Variable(_Math::pow(d, nPower));
 
	}
	else
	{
		_cout << "_Variable _Variable::operator^(const size_t& nPower) const";

		throw "未完成。";
	}




}

void _Variable::SetLimitsTo(const _LimitsTo& lim)
{
	_limit = lim;
}

_string _Variable::ToSplitString(const _string& sSplitString) const
{

	//_cout << "_string _Variable::ToSplitString(const _string& sSplitString) const";



	if (_fixed._t != _ValueType::Null)
	{
		return _fixed.ToString();
	}
 

	


	return _t("未完成！");
}




_function::_function(const _Variable& v)
{
}

_function::_function()
{
}

_Variable& _function::operator()(const _Variable& other)
{
	//_cout << _t("_function::operator()\n");
	return  _resultVar;
}

_Variable& _function::limit() 
{
	//_cout << _t("这里求函数极限！\n");
	
	return _resultVar;
}

 


_Variable operator/(const int& iLeft, const _Variable& vRight)
{
	if (vRight._mt == _ManifoldType::整数)
	{
		double d1 = iLeft;
		double d2 = *((int*)vRight._fixed._m.DataConst);
		
		return _Variable(d1 / d2);
	}
	_cout << _t("_Variable operator/(const int& iLeft, const _Variable& vRight)");
}



/// <summary>
/// 参考：https://baike.baidu.com/item/%E4%B8%89%E8%A7%92%E5%87%BD%E6%95%B0/1652457?fr=aladdin
/// 
/// 一般地，在直角坐标系中，给定单位圆，对任意角α，使角α的顶点与原点重合，
/// 始边与x轴非负半轴重合，终边与单位圆交于点P（u，v），那么点P的纵坐标v叫
/// 作角α的正弦函数，记作v=sinα。通常，用x表示自变量，即x表示角的大小，用y
/// 表示函数值，这样就定义了任意角的三角函数y=sin x，它的定义域为全体实数，
/// 值域为[-1,1]。表达式：f(x) = Asin(ωx + φ)
/// 
/// 定义域和值域
/// sin（x），cos（x）的定义域为R，值域为[-1, 1]。
/// tan（x）的定义域为x不等于π / 2 + kπ（k∈Z），值域为R。
/// cot（x）的定义域为x不等于kπ（k∈Z）, 值域为R。
/// y = a·sin（x） + b·cos（x） + c的值域为[c - √（a² + b²）, c + √（a² + b²）]
/// 周期T = 2π / ω
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
_Variable _sin(const _Variable& x)
{
	_Variable vResult;
	 	 
	if (x._limit == _LimitsTo::PositiveInfinity || x._limit == _LimitsTo::NegativeInfinity)
	{
		vResult._fixedMax = 1;
		vResult._fixedMin = -1;
	}

	return vResult;
}

_LF_END_

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/642686.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

计网（部分在session学习章）

计网（部分在session学习章）

TCP/UDP TCP：面向连接，先三次握手建立连接，可靠传输。 UDP：无连接，不可靠，传递的快。 TCP可靠传输 1.分块编号传输； 2.校验和，校验首部和数据的检验和，检测数据在传输中的变化； 3.丢弃重复数据； 4.流量控制，TCP 利⽤滑动窗⼝实现流量控制。TCP的拥塞控制采⽤…
阅读更多...
数据可视化第9天（利用wordcloud和jieba分析蝙蝠侠评论的关键字）

数据可视化第9天（利用wordcloud和jieba分析蝙蝠侠评论的关键字）

数据可以在这里下载 https://github.com/harkbox/DataAnalyseStudy WordCloud wordcloud可以很方便的生成词云图&#xff0c;方便的提供可视化可以直接使用pip install wordcloud进行安装如果使用的是Anaconda,可以使用conda install进行安装 下面看一个简单的例子 txt &qu…
阅读更多...
在linux下的ROS中下载超级终端Terminator ROS开发得力助手

在linux下的ROS中下载超级终端Terminator ROS开发得力助手

在一般我们运行机器人包时要打开三个终端来运行&#xff0c;关闭时还要一个一个关闭&#xff08;ctrlc&#xff09;过于麻烦 现在下载用了terminator后&#xff0c;就支持一键关闭多个终端了&#xff0c;很方便&#xff0c;具体操作如下&#xff1a; sudo apt install termin…
阅读更多...
第十三期Big Demo Day聚焦Web3前沿，FaceN.AI项目路演揭幕创新技术

第十三期Big Demo Day聚焦Web3前沿，FaceN.AI项目路演揭幕创新技术

第十三期Big Demo Day活动即将于2024年5月28日在香港数码港的CyberArena隆重举行。FaceN.AI将亮相本次Big Demo Day&#xff0c;参与精彩的项目路演&#xff0c;展示其在跨链去中心化数字身份、On-chain to Off-chain数据应用、DIDFi探索以及元宇宙与AIGC人格化发展等领域的领先…
阅读更多...
Gb 2024-05-22开源项目日报Top10

Gb 2024-05-22开源项目日报Top10

根据Github Trendings的统计，今日(2024-05-22统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下： 开发语言项目数量Python项目3非开发语言项目2Jupyter Notebook项目2Rust项目2JavaScript项目1Lua项目1编程面试大学：成为软件工程师的全面学习计划 创建周期：2…
阅读更多...
talib 安装

talib 安装

这里写自定义目录标题 talib 安装出错 talib 安装出错 https://github.com/cgohlke/talib-build/releases 这里找到轮子 直接装。
阅读更多...
BUUCTF [GUET-CTF2019]zips 1

BUUCTF [GUET-CTF2019]zips 1

BUUCTF:https://buuoj.cn/challenges 题目描述&#xff1a; 得到的 flag 请包上 flag{} 提交。 密文&#xff1a; 得到一个attachment.zip文件 解题思路&#xff1a; 1、解压attachment.zip&#xff0c;得到222.zip文件。尝试解压需要密码&#xff0c;使用Ziperello爆破密码…
阅读更多...
java连接ldap实现查询

java连接ldap实现查询

文章目录 一、项目背景二、准备工作三、验证结果四、易错点讲解易错点1&#xff1a;java: 无法访问org.springframework.ldap.core.LdapTemplate易错点2&#xff1a;java: 无法访问org.springframework.context.ConfigurableApplicationContext易错点3&#xff1a;[LDAP: error…
阅读更多...
WGCAT工单系统如何配置通知

WGCAT工单系统如何配置通知

WGCAT工单系统可以配置邮件通知 只要配置了邮件通知&#xff0c;那么一旦我们账号有新的工单需要处理&#xff0c;就会接受到邮件通知 除了邮件之外&#xff0c;还可以配置其他方式的通知&#xff0c;比如微信钉钉短信等方式&#xff0c;参考如下 https://www.wgstart.com/wgc…
阅读更多...
RDD介绍

RDD介绍

RDD设计背景 在实际应用中,存在许多迭代式计算,这些应用场景的共同之处是 : 不同计算阶段之间会重用中间结果,即一个阶段的输出结果会作为下一个阶段的输入. 而目前的MapReduce框架都是把中间结果写入到HDFS中,带来了大量的数据复制、磁盘IO和序列化开销; 如果能将结果保存在内…
阅读更多...
Docker安装、入门及VSCode链接（地平线OE docker镜像）

Docker安装、入门及VSCode链接（地平线OE docker镜像）

最近在地平线的SDK X3上做开发&#xff0c;有高手做了一些编译方法的对比&#xff1a; [X3容器应用开发探索-0]开篇&#xff1a;从裸机编译到交叉编译 X86 Qemu for Hobot X3 PI(AARCH64) vs Hobot X3 PI 这里想借助Docker编译提速&#xff0c;做个笔记&#xff1a; 目录 一、…
阅读更多...
算法刷题笔记 高精度乘法（C++实现）

算法刷题笔记 高精度乘法（C++实现）

文章目录 题目描述解题思路解题代码 题目描述 给定两个非负整数&#xff08;不含前导0&#xff09;A和B&#xff0c;请你计算 AB的值。 输入格式 共两行&#xff0c;第一行包含整数 A&#xff0c;第二行包含整数 B。 输出格式 共一行&#xff0c;包含AB的值。 数据范围 …
阅读更多...
最新文章合集

最新文章合集

GitHub宝藏项目&#xff1a;每天一个&#xff0c;让你的技术库增值不停&#xff01; STORM、SuperMemory、Awesome Chinese LLM、AI写作助手、资料搜集、文章生成、视角问题引导、模拟对话策略、内容导入、浏览器插件、资源库、开源微调模型 开发者必看&#xff1a;Linux终端…
阅读更多...
开关电源AC-DC（15W 3-18V可调）

开关电源AC-DC（15W 3-18V可调）

简介： 该模块使用PI的TNY268PN电源芯片制作的开关电源，实现最大功率15W 3-18V可调输出（更改反馈电阻）隔离式反激电源； 简介：该模块使用PI的TNY268PN电源芯片制作的开关电源，实现最大功率15W 3-18V可调输出（更改反馈电阻，现电路图输出5V）隔离式反激电源； 一、产品简…
阅读更多...
leecode 1206｜跳表的设计

leecode 1206｜跳表的设计

跳表 跳表&#xff0c;一种链表数据结构&#xff0c;其增删改茶的效率能和平衡树相媲美 leecode1206 可以看上面的那个动画&#xff0c;动画效果很贴切。 我简单讲讲它的机制吧&#xff0c;每个节点不单单是一个&#xff0c;测试好几层&#xff0c;然后同一层的节点和统一节点…
阅读更多...
力扣96. 不同的二叉搜索树

力扣96. 不同的二叉搜索树

Problem: 96. 不同的二叉搜索树 文章目录 题目描述思路复杂度Code 题目描述 思路 一个数字做根节点的话可能的结果为&#xff1a;其左边数字做子树的组合数字乘以其右边数字做子树的个数之积 1.创建备忘录memo&#xff1b; 2.递归分别求取当前数字左边和右边数字做子树的数量&…
阅读更多...
Putty： 随心御剑——远程启动服务工具plink

Putty： 随心御剑——远程启动服务工具plink

一、引言：如何远程控制 也许你会有这样的场景，交互程序（以下简称UI程序）跑在windows端，而控制程序跑在Linux上。我们想要通过windows端 UI程序来启动Linux下面的服务，来一场酣畅淋漓的御剑飞行咋办，难道要自己十年磨一剑，在Linux下编写一个受控服务程序么.计算机科技发…
阅读更多...
Stable Diffusion【艺术特效】【霓虹灯】：霓虹灯像素化马赛克特效

Stable Diffusion【艺术特效】【霓虹灯】：霓虹灯像素化马赛克特效

提示词 Neon pixelated mosaic of [Subject Description],highly detailed [主题]的霓虹灯像素化马赛克&#xff0c;高度详细 参数设置 大模型&#xff1a;万享XL_超写实摄影V8.2 采样器&#xff1a;Euler a 采样迭代步数&#xff1a;25 CFG&#xff1a;3 反向提示词&#x…
阅读更多...
GmSSL3.X编译iOS和Android动态库

GmSSL3.X编译iOS和Android动态库

一、环境准备 我用的Mac电脑编译&#xff0c;Xcode版本15.2&#xff0c;安卓的NDK版本是android-ndk-r21e。 1.1、下载国密源码 下载最新的国密SDK源码到本地。 1.2、安装Xcode 前往Mac系统的AppStore下载安装最新Xcode。 1.3、安卓NDK下载 下载NDK到本地&#xff0c;选…
阅读更多...
微服务可用性之隔离

微服务可用性之隔离

摘要 ​ 本文主要微服务场景下服务的可用性保障之隔离。隔离又分为几种情况&#xff0c;动静隔离、读写隔离、热点隔离、资源隔离等场景。 为什么要隔离 ​ 本质上是对资源进行分割确保在出现故障的时候服务只是部分不可用&#xff0c;不至于系统陷入整体性瘫痪&#xff0c;…
阅读更多...
最新文章

Copyright @ 2022~2023