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

news2025/1/13 13:48:35

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_

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Windows系统安装dlib及face_recognition搭建人脸识别环境

Windows系统安装dlib及face_recognition搭建人脸识别环境

关于face_recognition face_recognition被称为世界上最简洁的人脸识别库&#xff0c;借助face_recognition库&#xff0c;我们可以使用Python和命令行提取、识别、操作人脸。 face_recognition的人脸识别是基于业内领先的C开源库 dlib中的深度学习模型&#xff0c;用Labeled …
阅读更多...
Centos 7.9 使用 iso 搭建本地 YUM 源

Centos 7.9 使用 iso 搭建本地 YUM 源

Centos 7.9 使用 iso 搭建本地 YUM 源 1 建立挂载点 [rootlocalhost ~]# mkdir -p /media/cdrom/ 2 创建光盘存储路径 [rootlocalhost ~]# mkdir -p /mnt/cdrom/ 3 上传 CentOS-7-x86_64-Everything-2207-02.iso 到 光盘存储路径 [rootlocalhost ~]# ls /mnt/cdrom/ CentOS-…
阅读更多...
基于SSM的“酒店管理系统”的设计与实现（源码+数据库+文档)

基于SSM的“酒店管理系统”的设计与实现（源码+数据库+文档)

基于SSM的“酒店管理系统”的设计与实现&#xff08;源码数据库文档) 开发语言&#xff1a;Java 数据库&#xff1a;MySQL 技术&#xff1a;SSM 工具&#xff1a;IDEA/Ecilpse、Navicat、Maven 系统展示 首页 管理员登录页面 用户管理页面 客房信息查询 酒店详细信息 后台…
阅读更多...
Java学习路线思维导图

Java学习路线思维导图

目录 Java学习流程1.学习大纲2.Java开发中常用的DOS命令 Java入门学习思维导图 Java学习流程 通过大纲了解学习的重点&#xff0c;通过目录依次深入【注&#xff1a;Java环境的搭建百度&#xff0c;提升自己百度的能力】 1.学习大纲 学习流程如下&#xff1a; Java基础语法 …
阅读更多...
【Python】用于发送电子邮件的标准库smtplib和构建邮件主体、添加附件、设置收件人的email

【Python】用于发送电子邮件的标准库smtplib和构建邮件主体、添加附件、设置收件人的email

欢迎来到《小5讲堂》 这是《Python》系列文章&#xff0c;每篇文章将以博主理解的角度展开讲解。 温馨提示&#xff1a;博主能力有限&#xff0c;理解水平有限&#xff0c;若有不对之处望指正&#xff01; 目录 插件介绍邮件代码扩展知识点文章推荐 插件介绍 smtplib 是 Pytho…
阅读更多...
内存函数详解与模拟实现

内存函数详解与模拟实现

目录 1.memcpy函数 1.1memmcpy函数的模拟使用 2.memmove函数 2.1memmove 函数的模拟使用 3.memcmp 3.1memcmp函数的模拟实现 4.memset (内存设置) 4.1memset函数的模拟实现 1.memcpy函数 void* memcpy(void* destination, const void* source, size_t num);//之所以是v…
阅读更多...
工业4.0 企业级云MES全套源码，支持app、小程序、H5、台后管理端

工业4.0 企业级云MES全套源码，支持app、小程序、H5、台后管理端

工业4.0 企业级云MES全套源码&#xff0c;支持app、小程序、H5、台后管理端 采用javaspringboot-vue.jsuniapp开发 随着工业4.0的快速发展&#xff0c;制造执行系统&#xff08;MES&#xff09;成为了智能制造的核心。今天&#xff0c;将为大家介绍一款开源的MES系统——MES管…
阅读更多...
一个基于HOOK机制的微信机器人

一个基于HOOK机制的微信机器人

一个基于✨HOOK机制的微信机器人&#xff0c;支持&#x1f331;安全新闻定时推送【FreeBuf&#xff0c;先知&#xff0c;安全客&#xff0c;奇安信攻防社区】&#xff0c;&#x1f46f;Kfc文案&#xff0c;⚡备案查询&#xff0c;⚡手机号归属地查询&#xff0c;⚡WHOIS信息查询…
阅读更多...
家政保洁服务小程序怎么做？家政公司快速搭建专属小程序

家政保洁服务小程序怎么做？家政公司快速搭建专属小程序

在数字化时代背景下&#xff0c;家政保洁服务行业也迎来了线上转型的新机遇。家政保洁服务小程序&#xff0c;作为一种新型的线上服务平台&#xff0c;不仅能够提升家政公司的服务效率&#xff0c;还能为顾客提供更加便捷的预约上门服务体验。那么家政保洁服务小程序怎么做呢&a…
阅读更多...
java智慧工厂制造生产管理MES系统saas模式Java+ idea+ uniapp全套MES系统源码，多端展示

java智慧工厂制造生产管理MES系统saas模式Java+ idea+ uniapp全套MES系统源码，多端展示

java智慧工厂制造生产管理MES系统saas模式Java idea uniapp全套MES系统源码&#xff0c;多端展示 MES 系统源码&#xff08;生产制造执行系统&#xff09;能够帮助企业实现全生产过程的可视化&#xff0c;数据分析智能化、构建高效智能工厂&#xff0c;MES系统通过控制指令、人…
阅读更多...
工作学习的电脑定时关机，定时重启，定时提醒

工作学习的电脑定时关机，定时重启，定时提醒

可以直接下载工具&#xff1a; 定时自动关机 大家好&#xff0c;&#xff01; 在我们学习与工作时&#xff0c;经常会遇到想要在完成一个任务后&#xff0c;再关闭电脑或对电脑重启&#xff0c;但这个时间点&#xff0c;操作电脑的人可能不能在电脑旁边&#xff0c;这样就需要…
阅读更多...
Docker快速部署Seata的TC服务以及微服务引入Seata教程

Docker快速部署Seata的TC服务以及微服务引入Seata教程

目录 一、使用docker部署Seata的TC服务 1、拉取TC服务镜像 2、创建并运行容器 ​3、修改配置文件 4、在Nacos中添加TC服务的配置 5、重启TC服务 二、微服务集成Seata 1、引入依赖 2、修改配置文件 Seata是阿里的一个开源的分布式事务解决方案&#xff0c;能够为分布…
阅读更多...
2024年5月计算机视觉论文推荐:包括扩散模型、视觉语言模型、图像编辑和生成、视频处理和生成以及图像识别等各个主题

2024年5月计算机视觉论文推荐:包括扩散模型、视觉语言模型、图像编辑和生成、视频处理和生成以及图像识别等各个主题

我们今天总结下2024年5月发表的最重要的论文&#xff0c;重点介绍了计算机视觉领域的最新研究和进展&#xff0c;包括扩散模型、视觉语言模型、图像编辑和生成、视频处理和生成以及图像识别等各个主题。 Diffusion Models 1、Dual3D: Efficient and Consistent Text-to-3D Ge…
阅读更多...
mysql中text,longtext,mediumtext区别

mysql中text,longtext,mediumtext区别

文章目录 一.概览二、字节限制不同三、I/O 不同四、行迁移不同 一.概览 在 MySQL 中&#xff0c;text、mediumtext 和 longtext 都是用来存储大量文本数据的数据类型。 TEXT&#xff1a;TEXT 数据类型可以用来存储最大长度为 65,535(2^16-1)个字符的文本数据。如果存储的数据…
阅读更多...
SwiftUI中的手势（MagnificationGesture、 RotationGesture）

SwiftUI中的手势（MagnificationGesture、 RotationGesture）

通过前两篇文章的探索&#xff0c;手势的基本使用规则已经较深的了解&#xff0c;本篇文章主要看看放缩手势MagnificationGesture和旋转手势RotationGesture。 MagnificationGesture 放缩手势 放缩手势在App中用的也比较广泛&#xff0c;下面先看一个示例效果&#xff1a; 上…
阅读更多...
Mybatis Cache（二）MybatisCache+Redis

Mybatis Cache（二）MybatisCache+Redis

前面提到了&#xff0c;使用mybatis cache&#xff0c;一般是结合redis使用。 一、demo 1、数据表 create table demo.t_address (id int auto_incrementprimary key,address_name varchar(200) null,address_code varchar(20) null,address_type int n…
阅读更多...
鸿蒙系统与OpenHarmony：中国科技行业的新动力与就业前景

鸿蒙系统与OpenHarmony：中国科技行业的新动力与就业前景

背景 经历近年来的迅猛发展&#xff0c;鸿蒙原生应用数量已突破4000款&#xff0c;生态设备数量超过8亿台&#xff0c;开发者群体壮大至220万人。更为显著的是&#xff0c;鸿蒙系统在中国市场的份额已经超过了15%&#xff0c;稳居第三大操作系统&#xff0c;其生态之树已然枝繁…
阅读更多...
牛客NC236 最大差值【simple 动态规划 Java/Go/PHP】

牛客NC236 最大差值【simple 动态规划 Java/Go/PHP】

题目 题目链接&#xff1a; https://www.nowcoder.com/practice/a01abbdc52ba4d5f8777fb5dae91b204 思路 不难看出该题可以使用动态规划的方式解题。 在循环数组的过程中&#xff0c;记录截止到当前位置-1的最小值&#xff0c; 然后用当前的值去计算最大的差值。Java代码 im…
阅读更多...
【软件设计师】下午题总结-数据流图、数据库、统一建模语言

【软件设计师】下午题总结-数据流图、数据库、统一建模语言

下午题总结 1 试题一1.1 结构化语言 2 试题二弱实体增加权限增加实体间联系和联系的类型 3 试题三3.1 UML关系例子 3.2 例子&#xff08;2016上半年&#xff09;3.3 设计类分类3.3.1 接口类3.3.2 控制类3.3.3 实体类 3.4 简答题3.4.1 简要说明选择候选类的原则3.4.2 某个类必须…
阅读更多...
【NOIP2014普及组复赛】题4：子矩阵

【NOIP2014普及组复赛】题4：子矩阵

题3&#xff1a;子矩阵 【题目描述】 给出如下定义&#xff1a; 1.子矩阵&#xff1a;从一个矩阵当中选取某些行和某些列交叉位置所组成的新矩阵&#xff08;保持行与列的相对顺序&#xff09;被称为原矩阵的一个子矩阵。 例如&#xff0c;下面左图中选取第 2 、 4 2、4 2、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023