精华内容
下载资源
问答
  • 2021-01-14 07:58:43

    1。 f(1+x)=f(1-x),f(2+x)=f(2-x),函数奇偶性?

    周期函数是指函数值随自变量的变化而呈周期性变化,正弦、余弦函数都是周期函数。表达式是f(x+T)=f(x)(x取任意值),如果一个函数能找到满足这一条件的T,那么这个函数就叫做周期函数,周期为T。

    f(1+x)=f(1-x) (1+x)+(1-x)=2 也就是说在这个函数中如果两个自变量的平均值为1,则它们的函数值相等,也就是此函数关于x=1对称。

    同理,f(2+x)=f(2-x),(2+x)+(2-x)=4 也就是说在这个函数中如果两个自变量的平均值为2,则它们的函数值相等,也就是此函数关于x=2对称。

    如果一个函数同时具备两个对称轴,那么,相临的轴的间距就是函数的半个周期,你可以对照正弦、余弦函数的图像发现这个规律。

    这样,本题的函数周期为2,那么函数必然还关于x=0对称,所以函数是偶函数。

    2。 两个三角函数如不能化为同名函数怎样判断周期性?

    根据定义或者画图象,不过画图象比较麻烦,一般选择用定义

    我来举个例子

    f(x)=|sinx|+|2cosx|的周期

    我们可以才用定义f(x+T)=f(x)来检验

    f(x+2π)=f(x)

    f(x+π)=|-sinx|+|-2cosx|=f(x)

    f(x+π/2)=|cosx|+|2sinx|不等于f(x)

    容易看出最小正周期为π

    周期函数的周期问题是十分复杂的。

    如果,两个函数不能够化成一个函数,一般的可以证明"如果两个函数的周期是可公度的,那么,不同周期的两个函数的和,差,积,商的周期是这两个周期的共同的整数倍。如果这俩函数的周期不可公度的,那么,它们的和,差,积,商不是周期函数。"

    而对待周期相同的两个函数只能具体地分别对待。

    例如:

    y1=(sinx)^2=(1-cos2x)/2。T=π

    y2=(cosx)^2=(1+cos2x)/2。T=π

    y3=y1+y2=1。T是任意实数,但是没有最小正周期。

    y4=sinx/cosx=tanx,T=π。

    y5=sin18x+cos15x。

    T=2π/3=120度是T1=π/9=20度和T2=2π/15=24度的"公倍数"。

    y6=sin2x+sinπx。T1=π和T2=2是不可公度的,因此此函数不是周期函数。

    3。 设f(x)是定义在R上的偶函数,其图象关于x=1对称,对任意的x1,x2属于[0,0。

    5],都有f(x1+x2)=f(x1)*f(x2)。证明f(x)是周期函数?

    对于任意x,由偶函数知f(x)=f(-x);又由图像关于x=1对称,所以f(-x)=f(x+2)=f(x)。由此即证明了f(x)是周期函数。

    全部

    更多相关内容
  • 环形薄板的大挠度计算因为边界条件复杂,仅有少数特殊情形的数值解答这些解均是利用摄动法以某点挠度为摄动参数得到的结果当这点挠度较大或为零,将出现难以解决的困难作者以三次B样条函数为试函数,用配点法计算环形...
  • 实现集合之间的交 并 补 差 对称差

    千次阅读 2021-04-01 12:37:44
    通过使用c++的类 ,容器等相关知识来实现集合间的:交 并 补 差 对称差这五种关系 这里不直接set中有关集合关系的函数 相关数学知识 并集:设A与B是任意两个集合,由至少属于集合A与集合B之一的一切元素构成的集合...

    题目

    通过使用c++的类 ,重载,vector容器等相关知识来实现集合间的:交 并 补 差 对称差这五种关系
    这里不直接set使用有关集合关系的函数

    相关数学知识

    并集:设A与B是任意两个集合,由至少属于集合A与集合B之一的一切元素构成的集合成为A与B的并集,记作A∪B(或B∪A),读作“A并B”(或“B并A”),即A∪B={x|x∈A,或x∈B}。

    交集:对于给定的两个集合A 和 集合B 的交集是指含有所有既属于 A 又属于 B 的元素所构成的集合。由属于A且属于B的相同元素组成的集合,记作A∩B(或B∩A)读作“A交B”(或“B交A”),即A∩B={x|x∈A,且x∈B}。

    差集:设A与B是任意两个集合,由属于A但不属于B的一切元数构成的集合称为A与B的差集,记为A\B或A-B,即A\B={x|x∈A且x∉B}。

    补集:设S是一个集合,A是S的一个真子集,由S中所有不属于A的元素组成的集合,叫做子集A在S中的补集,于集也称为补集,记作CsA或Ac或A’。即Ac=S\A。

    对称差:两个集合的对称差是只属于其中一个集合,而不属于另一个集合的元素组成的集合。设A与B是任意两个集合,集合 A 和 B 的对称差可记为 AΔB,对称差相当于两个相对补集的并集,即AΔB=(A-B)∪(B-A)。也可以表示为两个集合的并集减去它们的交集,即AΔB=(A∪B)-(B∩A)。

    功能实现

    通过创建两个类,一个学生类,一个学生集合类,分别代表元素和集合,将学生类里面的数据放在一个vector的容器中可以在学生集合类里进行储存及使用。

    头文件以及实现

    学生类

    创建一个学生类

    class Student
    {
    private:
    	int m_uiId;
    public:
    	Student();
    	Student(int id);
    	Student(const Student& student);
    	Student& operator=(const Student& student);
    	bool operator==(const Student& student) const;
    	bool operator!=(const Student& student) const;
    	int GetID() const { return m_uiId; }
    };
    

    学生类实现

    默认构造:为其赋初值,在使用rand () 函数在使用时是已经固定的值,所以创建一个随机种子来改变其值,同时用srand(time(NULL))实现随机种子,根据时间变化而产生学号,这个可以避免学号创建出来是一样的情况

    Student::Student(){
    	srand((unsigned int)time(NULL));
     	m_uiId = rand() % 20 + 1;
    }
    

    随机产生学生学号范围在1-20之间

     rand() % 20 + 1;
    

    有参构造
    实现参数id保证传入的参数的准确性

    Student::Student(int id){
      m_uiId=id;
    }
    

    拷贝构造函数
    传入进来的是一个对象,通过引用的方式进行传入,并的将传进来的对象的m_uiId赋值给本身的m_uiId进而来实现拷贝效果

    Student::Student(const Student & student){
      m_uiId=student.m_uiId;
    }
    

    重载赋值运算符
    这个重载赋值和拷贝函数很像,在返回值上有区别,要实现一个链式编程的思想,为了将重载赋值运算符可以链式的使用下去,所以我们需要将其返回一个指针的形式

    Student &Student::operator=(const Student &student){
       m_uiId=student.m_uiId;
       return *this;
    }
    

    重载关系运算符
    是一个bool类型的函数,判断是否相等,相等则返回true,否则返回false类型

    bool Student::operator==(const Student &student)const{
         if(student.m_uiId==m_uiId) return true;
         return false;
    }
    bool Student::operator!=(const Student &student)const{
         if(student.m_uiId!=m_uiId) return true;
         return false;
    }
    

    学生集合类

    接着创建 学生集合类 在学生集合类里面实现相应函数
    我们创建一个Student类型的容器去存放数据

    在创建学生集合类时使用了vector容器,需要加入头文件#include<vector>

    class StudentSet
    {
    private:
    	vector<Student>m_vecData;
    public:
    	StudentSet();
    	StudentSet(const StudentSet&studentset);
    	StudentSet& operator=(const StudentSet&studentset);
    	bool Insert(const Student student);
    	bool Remove(const int id);
    	StudentSet Union(const StudentSet&studentset) const;
    	StudentSet InterSect(const StudentSet&studentset) const;
    	StudentSet Difference(const StudentSet&studentset) const;
    	StudentSet Complement() const;
    	StudentSet SymDifference(const StudentSet&studentset) const;
    	bool IsEmpty() const;
    	void Clear();
    	void Output() const;
    };
    

    学生集合类实现

    学生集合类的三个构造函数和学生类的一样,在学生集合类中,默认构造函数让其清空
    注意在重载赋值函数中,要清空函数,否则会保留上一次的数据

    StudentSet::StudentSet(){
       m_vecData.clear();
    }
    StudentSet::StudentSet(const StudentSet &studentset){
       int len=studentset.m_vecData.size();
       for(int i=0;i<len;i++){
        m_vecData.push_back(studentset.m_vecData[i]);
       }
    }
    StudentSet& StudentSet::operator=(const StudentSet & studentset){
    	m_vecData.clear();//清空防止在下一次的使用时仍含有上一次的值
       int len=studentset.m_vecData.size();
       for(int i=0;i<len;i++){
        m_vecData.push_back(studentset.m_vecData[i]);
       }
       return *this;
    }
    
    

    插入和删除函数,是bool类型的函数,需要判断该集合中是否有与我们插入的id重复,如果有,则返回false,没有则返回true,同理删除函数一样
    插入和删除都用到了vector容器里面的push_back函数和erase函数

    判断是否有重复的思路
    所使用的方法:我使用了map容器,通过map容器的两个参数值key和value,是键值对,他们之间有着一一对应的关系,同时在map容器中key 值是没有重复的。将m_vecData[i].GetID()全标记为1,此时m_vecData[i].GetID()就相当于map容器里的key值,标记的1就是相当于value值,这样在通过判断传进来的id的value值是否是1,如果是1,代表有重复的,之没有,没有重复的我们将其插入并返回true。

    删除函数:就是在本身的范围内开始遍历,如果有和传入的id相同的,记录一下当前的遍历的位置,使用m_vecData.erase(m_vecData.begin()+i);的方法删除重复的那个

    注:m_vecData[i].GetID()==id的要注意私有成员函数只能由该类内部成员函数调用

    bool StudentSet::Insert(const Student student){//插入
    	int len =m_vecData.size();
    	map<int ,int >mp;
    	
    	for(int i=0;i<len;i++){
    		mp[m_vecData[i].GetID()]=1;
    	}
    	if(!mp[student.GetID()]){
    		m_vecData.push_back(student);
         	return true;
    	}else {
    		return false;
    	}
    }
    bool StudentSet::Remove(const int id){//删除
         int len=m_vecData.size();
         for(int i=0;i<len;i++){
         if(m_vecData[i].GetID()==id){   ///私有成员函数只能被该类内部成员函数调用
             m_vecData.erase(m_vecData.begin()+i);
             return true;
            }
         }
         return false;
    }
    

    并 交 差 补 对称差

    实现方式和插入函数的逻辑类似都是通过map函数的key值和value值进行判断的

    并集:在本身这个集合内进行遍历将其全部插入到我们创建的的新的集合st里面,并且我们将map函数的key值为那个本身的学号,并将其的value值标记为1
    int len=m_vecData.size(); for(int i=0;i<len;i++){ st.Insert(m_vecData[i]); mp[m_vecData[i].GetID()]=1; }再在传入进来的集合中进行遍历,如果在这个传入的集合中的id(key值)没有等于1的(value值),就意味着传入集合中的元素和我们本身的元素之间没有重复的,那么我们就将其插入进来 ,这样就可以得到我们这个并集了,

    
    StudentSet StudentSet::Union(const StudentSet&studentset) const{//并集
         StudentSet st;
         map<int,int>mp;
         int len=m_vecData.size();
         for(int i=0;i<len;i++){
            st.Insert(m_vecData[i]);
            mp[m_vecData[i].GetID()]=1;
         }
         len=studentset.m_vecData.size();
         for(int i=0;i<len;i++){
            if(!mp[studentset.m_vecData[i].GetID()]){
                st.Insert(studentset.m_vecData[i]);
            }
         }
         return st;
    }
    

    交集: 同样在本身这个集合中进行遍历并将其标记为1,,然后在传入的集合中进行遍历,如果有一样被标记为1的我们就将其插入到我们所新建的那个集合中

    StudentSet StudentSet::InterSect(const StudentSet&studentset) const{//交集
         StudentSet st;
         map<int,int>mp;
         for(int i=0;i<m_vecData.size();i++) {
         	mp[m_vecData[i].GetID()]=1;
    	 }
         for(int i=0;i<studentset.m_vecData.size();i++){
            if(mp[studentset.m_vecData[i].GetID()]) {
            	st.m_vecData.push_back(studentset.m_vecData[i]);
    		}
         }
         return st;
    }
    
    

    差集:在一个集合中把含有另一个集合的元素去除,我们这里是如果没有一样的元素我就插入进来
    在传入的集合中进行遍历并将其标记为1,再在本身这个集合中进行遍历,如果这里面没有等于1的我们就将其插入到我们创建的新的集合中来

    StudentSet StudentSet::Difference(const StudentSet&studentset) const{//差集
         StudentSet st;
         map<int,int>mp;
         int len=studentset.m_vecData.size();
         for(int i=0;i<len;i++) 
         mp[studentset.m_vecData[i].GetID()]=1;
         len=m_vecData.size();
         for(int i=0;i<len;i++){
            if(!mp[m_vecData[i].GetID()])
    		st.m_vecData.push_back(m_vecData[i]);
         }
         return st;
    }
    

    补集:在全集是:IDMAX是0-20之间,求补集,我们在本身这个集合中遍历,并将其标记为1,再在全集中遍历,如果有不等于1的我们就将其插入到我们创建的新集合中来

    StudentSet StudentSet::Complement() const{//补集
         StudentSet st;
         map<int ,int >mp;
         int len=m_vecData.size();
        for(int i=0;i<len;i++) 
    	mp[m_vecData[i].GetID()]=1;
        for(int i=0;i<=IDMAX;i++){
    		if(!mp[i]){
    			Student a(i);
    			st.m_vecData.push_back(a);
        	}
    	}
         return st;
    }
    

    对称差实际上是两个集合的并集和交集再做一下差集
    实现:创建一个新的集合a存放st和传入参数的并集,集合b存放的是st和传入参数的交集,完了再让a和b做差集,这样我们就得到了对称差

    StudentSet StudentSet::SymDifference(const StudentSet&studentset) const{//对称差
         StudentSet st;
         int len=m_vecData.size();
         for(int i=0;i<len;i++) st.m_vecData.push_back(m_vecData[i]);
         StudentSet a=st.Union(studentset);
         StudentSet b=st.InterSect(studentset);
         StudentSet res=a.Difference(b);
         return res;
    }
    

    判断是否为空,清空函数以及输出函数
    是否为空就是看vector.size()==0是否成立

    bool StudentSet::IsEmpty() const{
         if(m_vecData.size()==0) return true;
         return false;
    }
    void StudentSet::Clear(){
         m_vecData.clear();
    }
    void StudentSet::Output() const{
         int len=m_vecData.size();
         for(int i=0;i<len;i++)
    		cout<<m_vecData[i].GetID()<<endl;
    }
    

    主函数

    int main()
    {
    	srand((unsigned int)time(NULL));
    	StudentSet set1, set2, set3;
    	set1.Clear();
    	set2.Clear();
    	set3.Clear();
    	for (unsigned int i = 0; i < 5; i++)
    	{
    		Student tmpstudent(i);
    		set1.Insert(tmpstudent);
    	}
    	set1.Output(); 
    	system("pause");
    	Student tmpstudent1(3);
    	cout << set1.Insert(tmpstudent1) << endl;
    	system("pause");
    	Student tmpstudent2(10);
    	cout << set1.Insert(tmpstudent2) << endl;
    	system("pause");
    	for (unsigned int i = 7; i < 12; i++)
    	{
    		Student tmpstudent(i);
    		set2.Insert(tmpstudent);
    	}
    	set2.Output();
    	system("pause");
    	set3 = set1.Union(set2);
    	set3.Output();
    	system("pause");
    	set3 = set1.InterSect(set2);
    	set3.Output();
    	system("pause");
    	set3 = set1.Difference(set2);
    	set3.Output();
    	system("pause");
    	set3 = set3.Complement();
    	set3.Output();
    	system("pause");
    	set3 = set1.SymDifference(set2);
    	set3.Output();
    	system("pause");
    	return 0;
    }
    

    总结

    这个实验中主要使用的就是vector容器 插入、删除、清空、容量等一系列函数,运算符重载,以及map函数间的key值和value值之间的一一对应关系,以及我们对集合之间关系的掌握与理解.

    注意注意
    map里面有一种插入方法:(这里所有map的插入方式全都是这种)

    map<int ,int>mp;
    mp[1]=10;//key=1;value=10,
    

    map中输出元素:如果是输出该容器内含有的元素,可以正常输出其value值,但是如果输出其中没有的,不会进行报错,会输出是0

    展开全文
  • } /** 交、差、并、对称差运算都是用到了algorithm函数库中的函数 这四个函数的语法都是通用的: 以set_union为例: set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(), ...

    博文首先贴出交集、并集、差集、对称差运算的C++代码以及程序运行结果,然后再进行一个比较完整的构建代码思路解析,整个项目的实现功能如下:
    在这里插入图片描述


    1. 实现代码以及程序运行结果

    代码不太理解的,看下面解析。

    1.1 头文件定义 UFSets.h

    //该文章的原创作者:阿伟加油鸭。首发于CSDN平台,装载请标注博文出处。
    //网址:https://blog.csdn.net/qq_45877524/article/details/106972508
    
    /**
    选择题目一:
    结合离散数学中集合的性质于运算,设计集合类(元素的类型自行定义),并实现集合的基本运算,
    包括:
    ……
    **/
    
    #ifndef UFSETS_H_
    #define UFSETS_H_
    #include<iostream>
    #include<vector>
    #include<algorithm>
    #include<iterator>
    #include<ostream>
    
    using namespace std;
    
    /**
    
    UFSets类的设计思路:
    用STL的容器vector以及algorithm库的算法来进行设计
    
    **/
    class UFSets {
    private:
    /**
    	
    用vector的原因:
    1.vector自带智能指针,不需要进行特殊的删除,所以可以用默认析构函数
    2.vector本身自带了许多检测函数比较方便
    
    **/
    	vector<int> data;            
    	
    
    public:
    	UFSets();                   //构造函数,用来在空集上确定具体的元素
    	~UFSets();                  //析构函数,这里用默认构造函数
    
    	bool isEmpty();             //确定是否为空集
    	bool isContain(int element) const;             //确定是否包含某一个元素
    	bool isEquality( const UFSets& anotherSets);   //判断两个集合是否相等
    	bool isSubSets(const UFSets& anotherSets);    //判断是否为子集
    
    	void add(int element);                          //只是单纯的增加一个元素
    	void addElement(int element[], int length);      //增加一组元素
    	void del(int element);                           //删除一个元素
    
    	UFSets unionSet(const UFSets& anotherSets);          //并集操作
    	UFSets intersectSet(const UFSets& anotherSets);      //交集操作
    	UFSets differenceSet(const UFSets& anotherSets);      //差集操作
    	UFSets symDif(const UFSets& anotherSets);            //全名:Symmetric difference,对称差运算
    
    	int getCount() const;           //返回元素的个数
    	void Print() const;             //打印当前的元素  
    
    
    };
    
    #endif
    

    1.2 抽象基类的实现 UFSets.cpp

    //该文章的原创作者:阿伟加油鸭。首发于CSDN平台,装载请标注博文出处。
    //网址:https://blog.csdn.net/qq_45877524/article/details/106972508
    
    
    #include "UFSets.h"
    
    //首先将vector容器设置为空
    UFSets::UFSets()
    {
    	data = { };
    }
    
    UFSets::~UFSets()
    {
    }
    
    
    bool UFSets::isEmpty()
    {
    	//bool std::vector<int>::empty() const 如果为空返回true,不为空为false
    	if (data.empty() == true)
    		return true;
    	else
    		return false;
    }
    
    bool UFSets::isContain(int element) const
    {
    	//find函数用迭代器找元素,找的到就返回他在vector的位置,找不到就算球
    	if (find(data.begin(), data.end(), element) != data.end())
    		return true;
    	else
    		return false;
    }
    
    
    //其实该函数可以用vector自带的重载运算符==,来进行判断,但是打完才想起来算了
    bool UFSets::isEquality(const UFSets& anotherSets)
    {
    	if (data.size() != anotherSets.data.size()) {        //连长度都不相等,肯定不相等
    		return false;
    	}
    
    	for (int i = 0; i < data.size(); i++) {
    		for(int j = 0;j < anotherSets.data.size();j++)   //一个一个元素进行比较
    		if (data[i] != anotherSets.data[j])
    			return false;
    	}
    
    	return true;
    }
    
    
    //algorithm函数库中的includes函数来判断子集
    bool UFSets::isSubSets(const UFSets& anotherSets)
    {
    	return includes(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end());
    }
    
    //vector语法
    void UFSets::add(int element)
    {
    	data.push_back(element);              //push_back函数为容器后面添加元素
    }
    
    //vector语法
    void UFSets::addElement(int element[], int length)
    {
    	for (int i = 0; i < length; i++)
    		add(element[i]);                 //一个一个往里面添加
    
        sort(data.begin(),data.end());
    }
    
    
    void UFSets::del(int element)
    {
    	if (isContain(element) == false) {
    		cout << "没有这个元素删除个蛇皮" << endl;                   //都不在删除个蛇蛇皮
    		return ;
    	}
    
    	auto location = find(data.begin(), data.end(), element);        //找到特定元素,然后直接删除
    
    	data.erase(location);
    }
    
    /**
    交、差、并、对称差运算都是用到了algorithm函数库中的函数
    这四个函数的语法都是通用的:
    
    以set_union为例:
    set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(),
    		inserter(result.data,result.data.begin()));
    
    前面四个参数都是vector的迭代器,最后一个参数是输出,那么这里在输出那里用inserter函数,将输出的
    结果直接搞到vector容器中
    **/
    UFSets UFSets::unionSet(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(),
    		inserter(result.data,result.data.begin()));
    	return result;
    }
    
    UFSets UFSets::intersectSet(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_intersection(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    	return result;
    }
    
    UFSets UFSets::differenceSet(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    	return result;
    }
    
    UFSets UFSets::symDif(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_symmetric_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    	return result;
    }
    
    
    //元素的个数直接用vector的函数方法
    int UFSets::getCount() const
    {
    	return data.size();
    }
    
    
    //打印元素
    void UFSets::Print() const
    {
    	cout << "当前集合的元素" << endl;
    	for (int i = 0; i < data.size(); i++) {
    		cout << data[i] << " "<<endl;
    	}
    	cout << "完成" << endl;
    }
    
    

    1.3 测试函数以及测试用例 main.cpp

    #include "UFSets.h"
    /**
    
    测试用例:
    set1 = {1 3 5 7 9}
    set2 = {2 4 6 7 9 10}
    
    set2在删除元素2后的预测结果:
    set2 = {4 6 7 9 10}
    
    用set1进行属性测试函数的验证:
    
    预期结果:
    是否为空集              不是
    是否包含元素1           是      
    是否与set2相等          不是
    set1是否为set2的子集    不是
    
    用set1和删除元素2以后的set2进行并,交,差,对称差运算的结果预测:
    并集          1 3 4 5 6 7 9 10
    交集          7 9
    差集          1 3 5
    对称差运算    1 3 4 5 6 10
    
    **/
    
    
    
    int main() {
    	int setOne[] = { 1,3,5,7,9 };
    	int setTwo[] = { 2,4,6,7,9,10 };
    
    	UFSets set1, set2;
    	set1.addElement(setOne, 5);             //增加元素
    	set2.addElement(setTwo, 6);             //增加元素
    
    	//打印这两个东西
    	set1.Print();
    	set2.Print();
    
    	//把2删除试一下
    	set2.del(2);
    	set2.Print();
    
    	//并,交,差,对称差运算
    	cout << "并集" << endl;
    	UFSets UnionSet = set1.unionSet(set2);
    	UnionSet.Print();
    
    	cout << "交集" << endl;
    	UFSets IntersectSet = set1.intersectSet(set2);
    	IntersectSet.Print();
    
    	cout << "差集" << endl;
    	UFSets DifferenceSet = set1.differenceSet(set2);
    	DifferenceSet.Print();
    
    	cout << "对称差运算" << endl;
    	UFSets symdif = set1.symDif(set2);
    	symdif.Print();
    
    	//返回set1的元素个数
    	cout << "接下来都是set1的验证" << endl;
    	cout << set1.getCount() << endl;
    	cout << "是否为空集" << " "<<set1.isEmpty() << endl;
    	cout << "是否包含元素" <<" " <<set1.isContain(1) << endl;
    	cout << "是否相等" <<" "<< set1.isEquality(set2) << endl;
    	cout << "set1是否为set2的子集" <<" "<< set1.isSubSets(set2) << endl;
    
    	return 0;
    }
    

    1.4 代码运行结果

    在这里插入图片描述

    1.5 代码环境

    C++11,运行不成功可能是dev版本过老的问题,反正我用dev和visual stduio 2020都是没有问题的。

    2 代码构建思路

    我的代码构建思路可能不太成熟,望大佬指正。

    设计一个类,首先应该考虑的是用什么东西来存储相应的元素,那么对于设计的需求而言,我要做的是元素(单个数据)与元素(单个数据)之间的交互。所以有两个选择,一个是数组,那么另外一个STL容器的vector(vector容器比较常用,相当于数组的2.0版本)

    考虑到下面两个原因,我选择vector容器:

    1. 在algorithm中本身就有差集、交集、并集和对称差运算的标准函数。它们的用法如下(看不懂的,看下面文章链接,里面有迭代器、vector容器、algorithm的介绍):
    2. vector容器可以进行自我检测,empty之类都有,可以非常方便的运算减少
      当然,在交集、并集、差集、对称差运算这三个学校所谓必须要掌握,实际没个der的程序中,我也会用数组的方法,进行解释。

    这是STL的介绍补充以及vector容器的用法:

    1. CSDN博主禾夕的《STL vector的内部实现原理及基本用法
    2. CSDN博主boke_fengwei的《c+±–vector的使用
    3. CSDN博主yyce的《面向对象程序设计(C++) 示例程序——集合类
    4. CSDN博主 HUST_Miao的《C++中STL用法超详细总结

    3. 交集、并集、差集、对称差运算

    有两种方法进行实现:一种是用到了algorithm函数库里面的函数,一种是直接头铁来弄。

    3.1 运用到了algorithm函数库里面的函数

    其实我这个程序,已经用到了algorithm函数库里面的函数,下面对着来讲一下:

    UFSets UFSets::unionSet(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(),
    		inserter(result.data,result.data.begin()));
    	return result;
    }
    
    UFSets UFSets::intersectSet(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_intersection(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    	return result;
    }
    
    UFSets UFSets::differenceSet(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    	return result;
    }
    
    UFSets UFSets::symDif(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_symmetric_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    	return result;
    }
    

    那么好,对其中起主要作用的四个函数进行分析

    //并集
    set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(),
    		inserter(result.data,result.data.begin()));
    		
    //交集
    set_intersection(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    //差集
    set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    
    //对称差运算
    set_symmetric_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    

    这四个函数的注意事项以及调用方式都是一样,那么以std::set_difference为例,先说函数的调用方式,再说注意事项。

    调用方式:
    template<class InputIterator1,class InputIterator2,class OutputIterator>
    OutputIterator set_difference(InputIterator1 first1,InputIterator1 last1,InputIterator2 first2,InputIterator2 last2,OutputIterator result)
    
    InputIterator = 输入数组的迭代器        OutputIterator = 输出迭代器
    
    示例:
    UFSets UFSets::differenceSet(const UFSets& anotherSets)
    {
    	UFSets result;
    	set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
    		inserter(result.data, result.data.begin()));
    	return result;
    }
    
    InputIterator输入数组迭代器,直接像我这样用,这个比较明白
    
    在调用方式这里,OutputIterator可能有点蒙,我这里推荐用inserter:
    
    inserter(container,pos):返回通用插入型迭代器,内部会调用容器container的insert(pos)方法将数据插入到pos位置。
    
    用法通俗一点:
    
    inserter(你现在用的函数,你要插入的位置)
    
    你可以用ostream但是比较复杂一点,按着例子来吧:
    
    set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(),ostream_iterator<int>(cout," "));
    
    

    set_differene虽然头上带着一个set,而是一个通用函数,STL容器(除了个别容器)有手就行,但是有个条件,传递的容器必须是排序的。因此,我在addElement函数那里加了一个sort把他搞有序了:

    //vector语法
    void UFSets::addElement(int element[], int length)
    {
    	for (int i = 0; i < length; i++)
    		add(element[i]);                 //一个一个往里面添加
    
        sort(data.begin(),data.end());
    }
    

    四个函数非常具体的分析包括底层实现看这里:

    1. CSDN博主Sim0Hayha的《【C++】关于 std::set_intersection( ) 函数用法
    2. CSDN博主清远qingyuan的《C++集合操作之集合差集:std::set_difference
    3. CSDN博主清远qingyuan的《C++集合操作之集合并集:std::set_union
    4. CSDN博主星辰浩宇的《关于C++中使用set_union、set_intersection、set_difference,set_symmetric_difference、merge的总结

    3.2 直接用数组

    篇幅有限,看这里:CSDN博主tx何家科03的《输入两个集合求出它们的交集,并集,相对差与相对补集并判断他们是否相等

    4. 参考资料

    1. CSDN博主Sim0Hayha的《【C++】关于 std::set_intersection( ) 函数用法
    2. CSDN博主禾夕的《STL vector的内部实现原理及基本用法
    3. CSDN博主boke_fengwei的《c+±–vector的使用
    4. CSDN博主yyce的《面向对象程序设计(C++) 示例程序——集合类
    5. CSDN博主 HUST_Miao的《C++中STL用法超详细总结
    6. CSDN博主清远qingyuan的《C++集合操作之集合差集:std::set_difference
    展开全文
  • 这些函数使用高斯平滑和对称差分进行梯度估计。 它们可用于支持例如 Canny 边缘检测器,并可形成许多图像和数据处理操作的初始阶段。 梯度函数接受不同类型的数据: gradients_x: 一个向量 gradients_xy:一个二维...
  • f=sin(x) 在域 (0,2pi) 中的二阶导数,使用 7 点对称模板作为内部点,一侧作为边界点。 这里使用了 for 循环方法。
  • 采用分组合函数搜索目标回波的峰值点, 基于非对称高斯脉冲模型进行高采样率拟合, 对峰值点位置加以校正, 改善定位的精确性。通过仿真选取合适的小波基, 对比不同算法信噪比改善及峰值点定位的性能。在室外高塔...
  • f=sin(x) 在域 (0,2pi) 中的一阶导数,使用 5 点对称模板作为内部点,一侧作为边界点。 这里使用了 for 循环方法。
  • } /*The difference has 3 elements: 5 15 25 */ 对称差 // set_symmetric_difference example #include // cout #include // set_symmetric_difference, std::sort #include // vector using namespace std;...

    交集

    // set_intersection example
    #include <iostream>     // cout
    #include <algorithm>    // set_intersection, sort
    #include <vector>       // vector
    using namespace std;
    int main () {
        int first[] = {5,10,15,20,25};
        int second[] = {50,40,30,20,10};
        vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
        vector<int>::iterator it;
    
        sort (first,first+5);     //  5 10 15 20 25
        sort (second,second+5);   // 10 20 30 40 50
    
        it=set_intersection (first, first+5, second, second+5, v.begin());
                                                   // 10 20 0  0  0  0  0  0  0  0
        v.resize(it-v.begin());                      // 10 20
    
        cout << "The intersection has " << (v.size()) << " elements:\n";
        for (it=v.begin(); it!=v.end(); ++it)
            cout << ' ' << *it;
            cout << '\n';
    
      return 0;
    }/*The intersection has 2 elements:
     10 20
    */
    

    并集

    // set_union example
    #include <iostream>     // cout
    #include <algorithm>    // set_union, sort
    #include <vector>       // vector
    using namespace std;
    int main () {
        int first[] = {5,10,15,20,25};
        int second[] = {50,40,30,20,10};
        vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
        vector<int>::iterator it;
    
        //要用交集函数必须先排序
        sort (first,first+5);     //  5 10 15 20 25
        sort (second,second+5);   // 10 20 30 40 50
    
        it=set_union (first, first+5, second, second+5, v.begin());
                                                   // 5 10 15 20 25 30 40 50  0  0
        v.resize(it-v.begin());                      // 5 10 15 20 25 30 40 50
    
        cout << "The union has " << (v.size()) << " elements:\n";
        for (it=v.begin(); it!=v.end(); ++it)
            cout << ' ' << *it;
            cout << '\n';
    
      return 0;
    }
    /*The union has 8 elements:
     5 10 15 20 25 30 40 50
    */
    

    差集
    在这里插入图片描述

    // set_difference example
    #include <iostream>     // cout
    #include <algorithm>    // set_difference, sort
    #include <vector>       // vector
    using namespace std;
    int main () {
        int first[] = {5,10,15,20,25};
        int second[] = {50,40,30,20,10};
        vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
        vector<int>::iterator it;
    
        sort (first,first+5);     //  5 10 15 20 25
        sort (second,second+5);   // 10 20 30 40 50
    
        it=set_difference (first, first+5, second, second+5, v.begin());
                                                   //  5 15 25  0  0  0  0  0  0  0
        v.resize(it-v.begin());                      //  5 15 25
    
        cout << "The difference has " << (v.size()) << " elements:\n";
        for (it=v.begin(); it!=v.end(); ++it)
            cout << ' ' << *it;
            cout << '\n';
    
        return 0;
    }
    /*The difference has 3 elements:
     5 15 25
    */
    

    对称差
    在这里插入图片描述

    // set_symmetric_difference example
    #include <iostream>     // cout
    #include <algorithm>    // set_symmetric_difference, std::sort
    #include <vector>       // vector
    using namespace std;
    int main () {
        int first[] = {5,10,15,20,25};
        int second[] = {50,40,30,20,10};
        vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
        vector<int>::iterator it;
    
        sort (first,first+5);     //  5 10 15 20 25
        sort (second,second+5);   // 10 20 30 40 50
    
        it=set_symmetric_difference (first, first+5, second, second+5, v.begin());
                                                   //  5 15 25 30 40 50  0  0  0  0
        v.resize(it-v.begin());                      //  5 15 25 30 40 50
    
        cout << "The symmetric difference has " << (v.size()) << " elements:\n";
        for (it=v.begin(); it!=v.end(); ++it)
            cout << ' ' << *it;
            cout << '\n';
    
      return 0;
     
    }
    /*The symmetric difference has 6 elements:
     5 15 25 30 40 50*/
    
    
    展开全文
  • f=tanh(k(x-1)) 在域 (0,5) 中的二阶导数,使用 3 点紧凑对称模板作为内部点,使用一侧显式模板作为边界点。 这里使用了矩阵法。
  • 函数图像三角函数与反三角函数1.正弦函数 sin x, 反正弦函数 arcsin x2.余弦函数 cos x, 反余弦函数 arccos x3.反正弦函数 arcsin x, 反余弦函数 arccos x4.正切函数 tan x, 余切函数 cot x5.反正切函数 arctan ...
  • Matlab图像处理函数大全(建议收藏)

    千次阅读 多人点赞 2020-12-11 20:32:01
    文章目录第1章: 图像显示与图像文件输入输出函数第2章: 图形绘制第3章: 图像类型和类型转换第4章: 图形用户界面工具第5章: 空间变换和图像配准第6章: 图像分析和统计第7章: 图像代数运算第8章: 图像增强第9...
  • 高斯函数

    千次阅读 2021-01-21 17:14:42
    高斯函数广泛应用于统计学领域,用于表述正态分布,在信号处理领域,用于定义高斯滤波器,在图像处理领域,二维高斯核函数常用于高斯模糊,在数学领域,主要用于解决热力方程和扩散方程。 1、高斯函数与正态分布 ...
  • 高斯函数、高斯积分和正态分布

    千次阅读 2022-01-25 10:42:19
    高斯概率分布是反映中心极限定理原理的函数,该定理指出当随机样本足够大时,总体样本将趋向于期望值并且远离期望值的值将不太频繁地出现。高斯积分是高斯函数在整条实数线上的定积分。这三个主题,高斯函数、高斯...
  • 代码是在 2017 年我在柏林时编写的。 目的是建立使用有限分求解偏微分方程的数值方程。... 上述函数用于生成有限分权重的核心函数是 getNonCompactFDMWeights,它适用于任意模板(对称和非对称模板)。 代码的
  • 函数

    千次阅读 2021-03-15 15:41:28
    什么是窗函数? - linmue-谭祥军的文章 - 知乎 https://zhuanlan.zhihu.com/p/24318554 本文首发于公众号《模态空间》。 似乎每次做FFT都需要加窗函数,很少有不加窗函数的时候。那为什么要加窗函数,加窗有什么...
  • 高斯概率密度函数

    千次阅读 2021-09-18 11:52:56
    单变量正态分布概率密度函数定义为: ρ(x)=12πσe−12(x−μσ)2(1) \rho(x)=\frac{1}{\sqrt{2\pi \sigma}} e^{-\frac{1}{2} (\frac{x- \mu}{\sigma})^2} \tag 1 ρ(x)=2πσ​1​e−21​(σx−μ​)2(1) 式中μ\...
  • 补一下数学基础 集合间的数学操作 ... 对称差集: 调用函数symmetric_difference() 或者 ^ ,原集合不发生变化 代码 """ 集合间的数学操作 交集: 调用函数intersection()或者 & ,原集合不发生
  • 证明自相关函数是偶函数

    千次阅读 2020-11-15 17:59:43
    证明自相关函数是偶函数
  • 函数y=Asin(wx+φ)图像和性质

    万次阅读 2021-01-17 17:38:44
    1、函数的图象(1)简谐运动的有关概念简谐运动图象的解析式振幅周期频率相位初期A(2)五点作图法①先确定周期,作出在一个周期内的图象.②令,由X分别取0,,,,,求出对应的x值列表如下:0x0A0-A0③描点画图,再利用...
  • 然后, 基于两者的最大时域分(TD) 误差选取Agent 的行为动作, 并对值函数参数进行更新; 最后, 基于两者的平均常规梯度或增量自然梯度对策略参数进行更新. 理论分析和仿真结果表明, 所提框架具有较好的收敛性和计算...
  • 激活函数的理解及其工作原理

    千次阅读 2021-12-24 15:18:54
    激活函数 接触机器学习大概一年多了,自己对于激活函数感觉还是停留在表面,因此想重新学习一下,加深一下对于“激活函数”的理解。 文章目录激活函数前言激活函数为什么需要激活函数?二、各种激活函数的介绍1....
  • 余弦函数图像(cos余弦函数图像)

    千次阅读 2021-05-23 08:24:57
    记住:原函数与反函数是关于y=x对称的。若要画反三角函数的图像,那么只要画出原三角函数的图像关于y=x对称的图像即可。方法是:在原三角函数图像上取一些点,画.对于正余弦函数图像可用五点作图法 以sinx为例 五点...
  • 对勾函数的图像及其性质1.pptx

    千次阅读 2020-12-31 03:36:38
    函数的定义域函数 y=f(x) 中自变量x的允许值范围:如果对于函数 y=f(x) 的定义域内任意的一个x都有 f(-x)=-f(x) ,则函数叫奇函数.如果对于函数 y=f(x) 的定义域内任意的一个x都有 f(-x)=f(x) ,则函数叫偶函数...
  • 另外,还研究了作为tt系统的速度,横向动量和不变质量的函数的微分电荷不对称性。 第一次在大型强子对撞机上,测量也在顶级夸克对生产减少的基准相空间中进行,积分结果为±0.0035±0.0072(stat)±0.0031±( ...
  • 与冲激函数、阶跃函数的卷积.ppt

    千次阅读 2021-04-22 01:49:33
    与冲激函数、阶跃函数的卷积信号与系统总 复 习 第一章 绪论 1、信号的概念 2、分类:典型的连续时间信号: 指数、正弦、复指数、抽样、钟形、δ(t), u(t), eat, sin(ω0t), Sa(kt) 3、信号的运算: 移位、反褶、...
  • 首先,修正了基于平面对称像差理论的超大视场光学系统的评价函数;然后针对遗传算法在优化超多参量光学系统时,其优化解的鲁棒性较的问题,采用在遗传算法中混入逃逸函数来改善算法的鲁棒性。最后应用改进的算法分别对...
  • 使用激活函数可以实现网络的高度非线性,这对于建模输入和输出之间的复杂关系非常关键,只有加入了非线性激活函数之后,深度神经网络才具备了令人惊异的非线性映射学习能力。 利用损失函数计算损失值,模型就可以...
  • f=tanh(k(x-1)) 在域 (0,5) 中的一阶导数,使用 5 点紧凑对称模板作为内部点,使用一侧显式模板作为边界点。 这里使用了矩阵法。
  • bessel(第一类修正贝塞尔函数)

    千次阅读 2021-04-18 03:55:38
    MATLAB提供了计算贝塞尔函数函数,具体包来括:besselj - 第一类贝塞尔函数,或简称贝塞尔函数;bessely - 第二类贝塞尔函数,又称诺伊曼函数(Neumann .对光纤中传播的电磁场分析发现,其纵向分量可以用贝塞耳函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,621
精华内容 17,848
关键字:

对称差函数