本文将分享NumPy教程的详细内容,并且还将对第14章:数学函数进行详尽解释,此外,我们还将为大家带来关于cocos2d-x数学函数、常用宏粗整理、cocos2d-x数学函数、常用宏粗整理(CC_SY
本文将分享NumPy 教程的详细内容,并且还将对第 14 章:数学函数进行详尽解释,此外,我们还将为大家带来关于cocos2d-x 数学函数、常用宏粗整理、cocos2d-x 数学函数、常用宏粗整理(CC_SYNTHESIZE)、c语言 数学函数 不知道代码错哪儿了、C语言自学《二》下篇---- 类型的转换、字符类型、枚举、数学函数的相关知识,希望对你有所帮助。
本文目录一览:- NumPy 教程(第 14 章):数学函数(numpy函数大全)
- cocos2d-x 数学函数、常用宏粗整理
- cocos2d-x 数学函数、常用宏粗整理(CC_SYNTHESIZE)
- c语言 数学函数 不知道代码错哪儿了
- C语言自学《二》下篇---- 类型的转换、字符类型、枚举、数学函数
NumPy 教程(第 14 章):数学函数(numpy函数大全)
NumPy 包含大量的各种数学运算的函数,包括三角函数,算术运算的函数,复数处理函数等
三角函数
NumPy 提供了标准的三角函数:sin()、cos()、tan()
In [1]: import numpy as np
In [2]: data = np.array([0,30,45,60,90])
In [3]: np.sin(data * np.pi / 180)
Out[3]: array([0.,0.5,0.70710678,0.8660254,1. ])
In [4]: np.cos(data * np.pi / 180)
Out[4]:
array([1.00000000e+00,8.66025404e-01,7.07106781e-01,5.00000000e-01,6.12323400e-17])
In [5]: np.tan(data * np.pi / 180)
Out[5]:
array([0.00000000e+00,5.77350269e-01,1.00000000e+00,1.73205081e+00,1.63312394e+16])
arcsin,arccos,和 arctan 函数返回给定角度的 sin,cos 和 tan 的反三角函数
这些函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度
In [1]: import numpy as np
In [2]: data = np.array([0,90])
In [3]: # 正弦值
In [4]: sin = np.sin(data * np.pi / 180)
In [5]: sin
Out[5]: array([0.,1. ])
In [6]: # 计算角度的反正弦,返回值以弧度为单位
In [7]: inv = np.arcsin(sin)
In [8]: inv
Out[8]: array([0.,0.52359878,0.78539816,1.04719755,1.57079633])
In [9]: # 通过转化为角度制来检查结果
In [10]: np.degrees(inv)
Out[10]: array([ 0.,30.,45.,60.,90.])
In [11]: # arccos 和 arctan 函数行为类似
In [12]: cos = np.cos(data * np.pi / 180)
In [13]: cos
Out[13]:
array([1.00000000e+00,6.12323400e-17])
In [14]: # 反余弦
In [15]: inv = np.arccos(cos)
In [16]: inv
Out[16]: array([0.,1.57079633])
In [17]: # 角度制单位
In [18]: np.degrees(inv)
Out[18]: array([ 0.,90.])
In [19]: # tan 函数
In [20]: tan = np.tan(data * np.pi / 180)
In [21]: tan
Out[21]:
array([0.00000000e+00,1.63312394e+16])
In [22]: # 反正切
In [23]: inv = np.arctan(tan)
In [24]: inv
Out[24]: array([0.,1.57079633])
In [25]: # 角度制单位
In [26]: np.degrees(inv)
Out[26]: array([ 0.,90.])
舍入函数
numpy.around()
函数
返回指定数字的四舍五入值。
numpy.around(arr,decimals)
参数说明:
-
arr: 数组
-
decimals: 舍入的小数位数。 默认值为0。 如果为负,整数将四舍五入到小数点左侧的位置
示例:
In [1]: import numpy as np
In [2]: num = np.array([1.0,5.55,123,0.567,25.532])
In [3]: num
Out[3]: array([ 1.,123.,25.532])
In [4]: np.around(num)
Out[4]: array([ 1.,6.,1.,26.])
In [5]: np.around(num,decimals=1)
Out[5]: array([ 1.,5.6,0.6,25.5])
In [6]: np.around(num,decimals=-1)
Out[6]: array([ 0.,10.,120.,0.,30.])
numpy.floor()
函数
返回数字的下舍整数
In [1]: import numpy as np
In [2]: num = np.array([-1.7,1.5,-0.2,10])
In [3]: num
Out[3]: array([-1.7,10. ])
In [4]: np.floor(num)
Out[4]: array([-2.,-1.,10.])
numpy.ceil()
函数
返回数字的上入整数
In [5]: np.ceil(num)
Out[5]: array([-1.,2.,-0.,10.])
cocos2d-x 数学函数、常用宏粗整理
转载地址:点击打开链接
1.数学类
cocos2d-x 里使用最多的数学类型是CCPoint,一个点,本质上也是一个向量,对于向量和向量之间有很多的数学操作要做,oh我知道要干什么,也许我知道怎么求一个值但是不知道怎么求得高效(或者不知道),怎么办我能偷懒吗?那当然可以。这其实并不是一个懒的标准,因为有一些方法写多了也可能确实稍微有那么点麻烦,所以自然cocos2d提供了一套ccp系列来帮助我们完成很多的工作,也显示一下库程序员照顾开发程序员的懒惰精神(当然他们自己也用,他们也很懒)。
那我们首先创建向量
ccp(x,y); // 以坐标x,y创建一个向量这个大家都知道。 ccpFromSize(s); // 以size s的width为x,height为y创建一个向量
有了ccp很多人就觉得自己已经够懒了,因为C++是可以用CCPoint()创建临时变量的,就是喜欢少打几个字吧。写个ccp(v1.x + v2.x,v1.y + v2.y)也不长……但是,有没有稍微再懒一点的?
——这个可以有。
基本的加法、减法、取负、数乘
ccpAdd(v1,v2); // 等价 ccp(v1.x+v2.x,v1.y+v2.y); ccpsub(v1,v2); // 等价 ccp(v1.x-v2.x,v1.y-v2.y); ccpNeg(v) // 等价 ccp(-v.x,-v.y); ccpMult(v,s); //等价 ccp(v.x * s,v.y * s); s是个浮点数嘛
不错,但是这个写法不是那么符合我们原生C++程序员的习惯,向量运算符呢?可惜cocos2d原本是一套objc的API,没有操作符重载,cocos2d-x也没有像一些原生的C++数学库一样直接重载向量运算符。不过重载一下还是很方便的,我们的项目里声明了一个数学头文件,也就几行代码就好了:
inline cocos2d::CCPoint operator + (const cocos2d::CCPoint& v1,const cocos2d::CCPoint v2) { return ccp(v1.x + v2.x,v1.y + v2.y); } inline cocos2d::CCPoint operator - (const cocos2d::CCPoint& v1,const cocos2d::CCPoint v2) { return ccp(v1.x - v2.x,v1.y - v2.y); } inline cocos2d::CCPoint operator - (const cocos2d::CCPoint& v) { return ccp(-v.x,-v.y); } inline cocos2d::CCPoint operator * (const cocos2d::CCPoint& v1,float scale) { return ccp(v1.x * scale,v1.y * scale); } inline cocos2d::CCPoint operator * (float scale,const cocos2d::CCPoint& v1) { return ccp(v1.x * scale,v1.y * scale); } inline cocos2d::CCPoint operator / (const cocos2d::CCPoint& v1,float scale) { return ccp(v1.x / scale,v1.y / scale); } inline bool operator == (const cocos2d::CCPoint& v1,const cocos2d::CCPoint& v2) { return (v1.x == v2.x) && (v1.y == v2.y); } inline bool operator != (const cocos2d::CCPoint& v1,const cocos2d::CCPoint& v2) { return (v1.x != v2.x) || (v1.y != v2.y); }
顺便还重载了等号和不等号,这样就可以直接用+、-来进行向量加减法,*、 / 进行数乘,==、!=判断是否相等了。程序员,这样才够懒!
什么,你说还有 +=、 -=、 /=、 *= 没重载?哦,改那些必须得修改到cocos2d-x的源代码了,改完还得重新编译一遍,略微有点懒得改吧,至少CCPoint还是能用 = 赋值的。我们还是看看cocos2d-x还提供了什么数学方法吧。
取中点!本来也就一 ccpMult(ccpAdd(v1,v2),0.5f) 的事,开发者说不要,我就是要少打几个字,好吧库程序员就给了一个方法
ccpMidpoint(v1,v2); // 等价 ccp( (v1.x + v2.x)/2,(v1.y + v2.y)/2 );
点乘、叉乘、投影
ccpDot(v1,v2); // 等价 v1.x * v2.x + v1.y * v2.y; ccpCross(v1,v2); // 等价 v1.x * v2.y - v1.y * v2.x; ccpProject(v1,v2) // 返回的是向量v1在向量v2上的投影向量
喜闻乐见求长度、距离和各自的平方值(在仅需要比较两个长度大小时使用长度平方,因为省去了开方这一步,效率要高不少,这就不光是程序员的懒了,懒得要有效率)
ccpLength(v) // 返回向量v的长度,即点v到原点的距离 ccpLengthSQ(v) // 返回向量v的长度的平方,即点v到原点的距离的平方 ccpdistance(v1,v2) // 返回点v1到点v2的距离 ccpdistanceSQ(v1,v2) // 返回点v1到点v2的距离的平方 ccpnormalize(v) // 返回v的标准化向量,就是长度为1
旋转、逆时针90度、顺时针90度(90度的效率当然是更快的。。。同样懒得有效率)
ccpRotate(v1,v2); // 向量v1旋转过向量v2的角度并且乘上向量v2的长度。当v2是一个长度为1的标准向量时就是正常的旋转了,可以配套地用ccpForAngle ccpPerp(v); // 等价于 ccp(-v.y,v.x); (因为opengl坐标系是左下角为原点,所以向量v是逆时针旋转90度) ccpRPerp(v); // 等价于 ccp(v.y,-v.x); 顺时针旋转90度
上面说到ccpRotate,配套的有向量和弧度的转换向量,还有一些角度相关的
ccpForAngle(a); // 返回一个角度为弧度a的标准向量 ccpToAngle(v); // 返回向量v的弧度 ccpAngle(a,b); // 返回a,b向量指示角度的差的弧度值 ccpRotateByAngle(v,pivot,angle) // 返回向量v以pivot为旋转轴点,按逆时针方向旋转angle弧度
线段相交的检测,哦天哪原来库程序员把这些事情都干了!我还在傻傻地想线段相交算法!实在是太勤奋了!
ccpLineIntersect(p1,p2,p3,p4,&s,&t); // 返回p1为起点p2为终点线段1所在直线和p3为起点p4为终点线段2所在的直线是否相交,如果相交,参数s和t将返回交点在线段1、线段2上的比例 // 得到s和t可以通过 p1 + s * (p2 - p1) 或 p3 + t * (p4 - p3) 求得交点。 ccpsegmentIntersect(A,B C,D) // 返回线段A-B和线段C-D是否相交 ccpIntersectPoint(A,B,C,D) // 返回线段A-B和线段C-D的交点
数学方法没有列全,更多请直接查头文件CCPointExtension.h。基本该有的都有了。
当然数学不只有向量,还有一些其他的……这些也很经常用到。小懒一下。
CC_radians_TO_degrees(a); // 弧度转角度 CC_degrees_TO_radians(a); // 角度转弧度 CCRANDOM_0_1(); // 产生0到1之间的随机浮点数 CCRANDOM_MINUS1_1(); // 产生-1到1之间的随机浮点数
2.语句宏
常用的,首先第一个,断言。
CCAssert(cond,msg); // 断言表达式cond为真,如果不为真,则显示字符串msg信息
在这之后,也非常常用的,有遍历CCARRAY、CCDICTIONARY的宏。
CCArray* _array; CCObject* _object; // 用来遍历数组的临时变量 CCARRAY_FOREACH(_array,_object) // 正向遍历 { // todo with _object.... } CCARRAY_FOREACH_REVERSE(_array,_object) // 反向遍历 { // todo with _object.... } CCDictionary* _dict; CCDictElement* _elmt; // 遍历表的临时变量 CCDICT_FOREACH(_dict,_elmt) { // todo with elmt; }
CCArray和CCDictionary都没有实现模版,取得的遍历元素之后还需要强制转换,假如说,嗯,通常数组里的元素都是同一类型的,比如这样
CCArray* _array; CCObject* _object; // 用来遍历数组的临时变量 CCARRAY_FOREACH(_array,_object) // 正向遍历 { CCSprite* _bullet = (CCSprite*)_object; // todo with _bullet.... }
总觉得我好像多定义了一个CCObject* _object,因为它没什么用似的?而且我也懒得多写一句强制转换,可以吗?首先看看CCARRAY_FOREACH怎么定义的
#define CCARRAY_FOREACH(__array__,__object__) \ if ((__array__) && (__array__)->data->num > 0) \ for(CCObject** arr = (__array__)->data->arr,**end = (__array__)->data->arr + (__array__)->data->num-1; \ arr <= end && (((__object__) = *arr) != NULL/* || true*/); \ arr++)
看到那句 (__object__) = *arr 了吗?好,要直接强制转换,就提供一个类型,在这里开刀!
#define CCARRAY_TFOREACH(__array__,__object__,__type__) \ if ((__array__) && (__array__)->data->num > 0) \ for(CCObject** arr = (__array__)->data->arr,**end = (__array__)->data->arr + (__array__)->data->num-1; \ arr <= end && (((__object__) = (__type__)*arr) != NULL/* || true*/); \ arr++)
然后用这个CCARRAY_TFOREACH宏,这样我们的遍历就可以做得更懒一点
CCArray* _array; CCSprite* _bullet; // 用来遍历数组的临时变量 CCARRAY_TFOREACH(_array,_bullet,CCSprite*) // 正向遍历 { // todo with _bullet.... }
舒坦,偷懒改造,完。
在定义类型的时候,经常需要定义一些getter setter,有cocos2d从objc带来的CC_PROPERTY 和 CC_SYNTHESIZE。
class Ship: public cocos2d::CCNode { // 定义一个int类的属性m_energy变量,该变量访问权限是protected。 //后面的方法名Energy,即声明了一个int getEnergy() 和一个 void setEnergy(int value)的方法,具体实现需要自己在cpp中定义 CC_PROPERTY(int,m_energy,Energy); // 基本与上相同,但是get方法传引用,即声明了一个 int& getEnergy(); CC_PROPERTY_PASS_BY_REF(int,Energy); // 同样定义变量,但是只发声明 get 方法,具体实现需要自己在cpp中定义 CC_PROPERTY_READONLY(int,Energy); CC_PROPERTY_READONLY_PASS_BY_REF(int,Energy); // 同样定义变量,并且直接定义默认的get/set方法。相似的也有前4类 CC_SYNTHESIZE(cocos2d::CCObject*,m_weapon,Weapon); CC_SYNTHESIZE_PASS_BY_REF(cocos2d::CCObject*,Weapon); CC_SYNTHESIZE_READONLY(cocos2d::CCObject*,Weapon); CC_SYNTHESIZE_READONLY_PASS_BY_REF(cocos2d::CCObject*,Weapon); // 在setWeapon的时候,调用原有m_weapon的release,并且调用新值的的retain。当然已经排除了意外情况(相等或者NULL之类的)。 CC_SYNTHESIZE_RETAIN(cocos2d::CCObject*,Weapon); };
需要注意的是
1.CC_PROPERTY更适用于快速声明一个值属性,而CC_SYNTHESIZE更适用于声明一个对象。因为CC_SYNTHESIZE提供的默认set没有任何合法性检查对于值属性来说太不实用。
2.这些方法的声明全部都是virtual的,即便是内联,声明为virtual的方法也不会产生内联函数,所以不管是CC_PROPERTY还是CC_SYNTHESIZE,他们的效率都是不高的。
3.CC_PROPERTY的get方法都没有对函数体声明const修饰符,这意味着对const对象,并不能调用CC_PROPERTY声明的get方法(我怎么觉得这是个cocos2d-x的BUG……)。
4.在CC_SYNTHESIZE方法之后直接声明函数或者变量都会变成public:……注意,嗯。
不好用?跳过去看下定义,自己去定义一个呗……懒得看那就算了。
然后还有快捷的CREATE_FUNC,自动生成一个默认的静态create方法。这实在方便了
class Class: public cocos2d::CCNode { public: CREATE_FUNC(Class); // 自动生成一个不带参数的 create 静态方法,返回一个Class*类型指针。自动调用了init和autorelease方法 } //CREATE_FUNC(Class) 等价于与以下 static Class* create() { Class* pRet = new Class(); if (pRet && pRet->init()) { pRet->autorelease(); return pRet; } else { delete pRet; pRet = NULL; return NULL; } }
而且这也是建议的C++构造函数和init方法的使用规范,先分配空间之后立刻初始化,并且由初始化结果确定能否返回一个可用的对象。在定义特定参数的create方法时也应当这样。
说到初始化,就不得不说到析构,还有一些析构相关的宏。我要release一堆对象,挨个都得判断对象是不是NULL?还要把release后的东西赋值NULL?程序员懒得写这么多行代码……
//所谓的safe逻辑都是这样的,先检查指针p是否为NULL,不为NULL,则执行delete p或者p->release等等。 CC_SAFE_DELETE(p); // 当p不为NULL,delete p 并且将 p 赋为 NULL CC_SAFE_DELETE_ARRAY(p); // ...delete[] p.. CC_SAFE_FREE(p); // ...free p ... CC_SAFE_RELEASE(p); // 当p不为NULL,p->release() CC_SAFE_RELEASE_NULL(p); // 当p不为NULL,p->release() 并且将 p 赋为 NULL CC_SAFE_RETAIN(p); // 当p不为NULL,p->retain()
顺便还有交换两个变量的时候,可以都喜欢懒,写个 void swap(int& a,int &b)什么的、再写void swap(float& a,float& b)什么的,再写个 void swap(string& a,string& b)什么的……总感觉你懒都没人家库程序员懒的懒……这里有个CC_SWAP的宏……
CC_SWAP(x,y,type); // 等价于于以下 { type temp = (x); x = y; y = temp; } // 至少x 和 y 不是表达式的时候这个宏都能工作正常,也不用担心temp变量重复
什么?你说你不服?你说你连type都不想声明……?你居然这么懒那你怎么办你怎么能做到这么懒的啊!你说你用模版?
template <typename t> inline void swap<typename t>(t& a,t& b);
好吧你赢了……
还有cocos2d库开发人员很喜欢用的CC_BREAK_IF,这个宏有什么特别的含义吗?难道其实不就是一行的 if(???) break; ?嗯,就是……没区别。但是你不觉得CC_BREAK_IF( ??? );懒地比人家高端吗?现在的IDE都能自动tab出宏耶!还有可以用下面的while(0)循环写还能代替一些if(???) return false;耶!
bool Class::init() { bool bRet = false; do { // do some initialization 1 CC_BREAK_IF(cond); // 当表达式cond为真时候跳出。 // do some more initialization bRet = true; } while(0); return bRet; }
……积小懒,成大懒啊!可见有一些人,是真的真的很懒很懒……
还能更懒一点吗?答案是肯定的。每当写一个.h时,cocos2d的库程序员都要写一个 namespace cocos2d {...} 吧;每当写一个cpp的时候,你也总是要用到using namespace吧?。。他们都懒得多打这几个字母。。
NS_CC_BEGIN // 这是 namespace cocos2d { NS_CC_END // 这是 } !!!! USING_NS_CC; // 这是 using namespace cocos2d; 这可以是常用宏。
cocos2d-x 数学函数、常用宏粗整理(CC_SYNTHESIZE)
程序员需要有多懒 ?- cocos2d-x 数学函数、常用宏粗整理 - by Glede
http://www.cnblogs.com/buaashine/archive/2012/11/12/2765691.html
最近我们的cocos2d-x游戏项目已经进入了正式开发的阶段了,几个dev都辛苦码代码。cocos2d-x还是一套比较方便的api的,什么action啊、director啊、ccpoint啊都蛮便捷的。但是我看到几个dev有时候会很不知道用它们,还是首先自己去写函数……
用一些比较原始、低效率的方法……
甚至是copy / paste……
…………。
……。
这不科学啊!你不能这么勤劳啊!你这么勤劳要出事的啊!每年有多少程序员过劳死啊!程序员一定要是懒骨头才是正道啊!
首先第一个,看到有问题,要写很多代码处理问题,自己动手,丰衣足食——不是一条好路,是一条革命的老路。我们前面有那么多前任程序员的尸体,要学会翻烂它们……然后本文也是菜笔写的,仅简整理一下自己用的比较多一些cocos2d-x的util,帮助大家提高效率,要变懒,会偷懒,没有最懒,只有更懒。
1.数学类
cocos2d-x 里使用最多的数学类型是CCPoint,一个点,本质上也是一个向量,对于向量和向量之间有很多的数学操作要做,oh我知道要干什么,也许我知道怎么求一个值但是不知道怎么求得高效(或者不知道),怎么办我能偷懒吗?那当然可以。这其实并不是一个懒的标准,因为有一些方法写多了也可能确实稍微有那么点麻烦,所以自然cocos2d提供了一套ccp系列来帮助我们完成很多的工作,也显示一下库程序员照顾开发程序员的懒惰精神(当然他们自己也用,他们也很懒)。
那我们首先创建向量
ccp(x,y); // 以坐标x,y创建一个向量这个大家都知道。 ccpFromSize(s); // 以size s的width为x,height为y创建一个向量
有了ccp很多人就觉得自己已经够懒了,因为C++是可以用CCPoint()创建临时变量的,就是喜欢少打几个字吧。写个ccp(v1.x + v2.x,v1.y + v2.y)也不长……但是,有没有稍微再懒一点的?
——这个可以有。
基本的加法、减法、取负、数乘
ccpAdd(v1,v2); // 等价 ccp(v1.x+v2.x,v1.y+v2.y); ccpsub(v1,v2); // 等价 ccp(v1.x-v2.x,v1.y-v2.y); ccpNeg(v) // 等价 ccp(-v.x,-v.y); ccpMult(v,s); //等价 ccp(v.x * s,v.y * s); s是个浮点数嘛
不错,但是这个写法不是那么符合我们原生C++程序员的习惯,向量运算符呢?可惜cocos2d原本是一套objc的API,没有操作符重载,cocos2d-x也没有像一些原生的C++数学库一样直接重载向量运算符。不过重载一下还是很方便的,我们的项目里声明了一个数学头文件,也就几行代码就好了:
inline cocos2d::CCPoint operator + (const cocos2d::CCPoint& v1,const cocos2d::CCPoint v2) { return ccp(v1.x + v2.x,v1.y + v2.y); } inline cocos2d::CCPoint operator - (const cocos2d::CCPoint& v1,const cocos2d::CCPoint v2) { return ccp(v1.x - v2.x,v1.y - v2.y); } inline cocos2d::CCPoint operator - (const cocos2d::CCPoint& v) { return ccp(-v.x,-v.y); } inline cocos2d::CCPoint operator * (const cocos2d::CCPoint& v1,float scale) { return ccp(v1.x * scale,v1.y * scale); } inline cocos2d::CCPoint operator * (float scale,const cocos2d::CCPoint& v1) { return ccp(v1.x * scale,v1.y * scale); } inline cocos2d::CCPoint operator / (const cocos2d::CCPoint& v1,float scale) { return ccp(v1.x / scale,v1.y / scale); } inline bool operator == (const cocos2d::CCPoint& v1,const cocos2d::CCPoint& v2) { return (v1.x == v2.x) && (v1.y == v2.y); } inline bool operator != (const cocos2d::CCPoint& v1,const cocos2d::CCPoint& v2) { return (v1.x != v2.x) || (v1.y != v2.y); }
顺便还重载了等号和不等号,这样就可以直接用+、-来进行向量加减法,*、 / 进行数乘,==、!=判断是否相等了。程序员,这样才够懒!
什么,你说还有 +=、 -=、 /=、 *= 没重载?哦,改那些必须得修改到cocos2d-x的源代码了,改完还得重新编译一遍,略微有点懒得改吧,至少CCPoint还是能用 = 赋值的。我们还是看看cocos2d-x还提供了什么数学方法吧。
取中点!本来也就一 ccpMult(ccpAdd(v1,v2),0.5f) 的事,开发者说不要,我就是要少打几个字,好吧库程序员就给了一个方法
ccpMidpoint(v1,v2); // 等价 ccp( (v1.x + v2.x)/2,(v1.y + v2.y)/2 );
点乘、叉乘、投影
ccpDot(v1,v2); // 等价 v1.x * v2.x + v1.y * v2.y; ccpCross(v1,v2); // 等价 v1.x * v2.y - v1.y * v2.x; ccpProject(v1,v2) // 返回的是向量v1在向量v2上的投影向量
喜闻乐见求长度、距离和各自的平方值(在仅需要比较两个长度大小时使用长度平方,因为省去了开方这一步,效率要高不少,这就不光是程序员的懒了,懒得要有效率)
ccpLength(v) // 返回向量v的长度,即点v到原点的距离 ccpLengthSQ(v) // 返回向量v的长度的平方,即点v到原点的距离的平方 ccpdistance(v1,v2) // 返回点v1到点v2的距离 ccpdistanceSQ(v1,v2) // 返回点v1到点v2的距离的平方 ccpnormalize(v) // 返回v的标准化向量,就是长度为1
旋转、逆时针90度、顺时针90度(90度的效率当然是更快的。。。同样懒得有效率)
ccpRotate(v1,v2); // 向量v1旋转过向量v2的角度并且乘上向量v2的长度。当v2是一个长度为1的标准向量时就是正常的旋转了,可以配套地用ccpForAngle ccpPerp(v); // 等价于 ccp(-v.y,v.x); (因为opengl坐标系是左下角为原点,所以向量v是逆时针旋转90度) ccpRPerp(v); // 等价于 ccp(v.y,-v.x); 顺时针旋转90度
上面说到ccpRotate,配套的有向量和弧度的转换向量,还有一些角度相关的
ccpForAngle(a); // 返回一个角度为弧度a的标准向量 ccpToAngle(v); // 返回向量v的弧度 ccpAngle(a,b); // 返回a,b向量指示角度的差的弧度值 ccpRotateByAngle(v,pivot,angle) // 返回向量v以pivot为旋转轴点,按逆时针方向旋转angle弧度
线段相交的检测,哦天哪原来库程序员把这些事情都干了!我还在傻傻地想线段相交算法!实在是太勤奋了!
ccpLineIntersect(p1,p2,p3,p4,&s,&t); // 返回p1为起点p2为终点线段1所在直线和p3为起点p4为终点线段2所在的直线是否相交,如果相交,参数s和t将返回交点在线段1、线段2上的比例 // 得到s和t可以通过 p1 + s * (p2 - p1) 或 p3 + t * (p4 - p3) 求得交点。 ccpsegmentIntersect(A,B C,D) // 返回线段A-B和线段C-D是否相交 ccpIntersectPoint(A,B,C,D) // 返回线段A-B和线段C-D的交点
数学方法没有列全,更多请直接查头文件CCPointExtension.h。基本该有的都有了。
当然数学不只有向量,还有一些其他的……这些也很经常用到。小懒一下。
CC_radians_TO_degrees(a); // 弧度转角度 CC_degrees_TO_radians(a); // 角度转弧度 CCRANDOM_0_1(); // 产生0到1之间的随机浮点数 CCRANDOM_MINUS1_1(); // 产生-1到1之间的随机浮点数
2.语句宏
常用的,首先第一个,断言。
CCAssert(cond,msg); // 断言表达式cond为真,如果不为真,则显示字符串msg信息
在这之后,也非常常用的,有遍历CCARRAY、CCDICTIONARY的宏。
CCArray* _array; CCObject* _object; // 用来遍历数组的临时变量 CCARRAY_FOREACH(_array,_object) // 正向遍历 { // todo with _object.... } CCARRAY_FOREACH_REVERSE(_array,_object) // 反向遍历 { // todo with _object.... } CCDictionary* _dict; CCDictElement* _elmt; // 遍历表的临时变量 CCDICT_FOREACH(_dict,_elmt) { // todo with elmt; }
CCArray和CCDictionary都没有实现模版,取得的遍历元素之后还需要强制转换,假如说,嗯,通常数组里的元素都是同一类型的,比如这样
CCArray* _array; CCObject* _object; // 用来遍历数组的临时变量 CCARRAY_FOREACH(_array,_object) // 正向遍历 { CCSprite* _bullet = (CCSprite*)_object; // todo with _bullet.... }
总觉得我好像多定义了一个CCObject* _object,因为它没什么用似的?而且我也懒得多写一句强制转换,可以吗?首先看看CCARRAY_FOREACH怎么定义的
#define CCARRAY_FOREACH(__array__,__object__) \ if ((__array__) && (__array__)->data->num > 0) \ for(CCObject** arr = (__array__)->data->arr,**end = (__array__)->data->arr + (__array__)->data->num-1; \ arr <= end && (((__object__) = *arr) != NULL/* || true*/); \ arr++)
看到那句 (__object__) = *arr 了吗?好,要直接强制转换,就提供一个类型,在这里开刀!
#define CCARRAY_TFOREACH(__array__,__object__,__type__) \ if ((__array__) && (__array__)->data->num > 0) \ for(CCObject** arr = (__array__)->data->arr,**end = (__array__)->data->arr + (__array__)->data->num-1; \ arr <= end && (((__object__) = (__type__)*arr) != NULL/* || true*/); \ arr++)
然后用这个CCARRAY_TFOREACH宏,这样我们的遍历就可以做得更懒一点
CCArray* _array; CCSprite* _bullet; // 用来遍历数组的临时变量 CCARRAY_TFOREACH(_array,_bullet,CCSprite*) // 正向遍历 { // todo with _bullet.... }
舒坦,偷懒改造,完。
在定义类型的时候,经常需要定义一些getter setter,有cocos2d从objc带来的CC_PROPERTY 和 CC_SYNTHESIZE。
class Ship: public cocos2d::CCNode { // 定义一个int类的属性m_energy变量,该变量访问权限是protected。 //后面的方法名Energy,即声明了一个int getEnergy() 和一个 void setEnergy(int value)的方法,具体实现需要自己在cpp中定义 CC_PROPERTY(int,m_energy,Energy); // 基本与上相同,但是get方法传引用,即声明了一个 int& getEnergy(); CC_PROPERTY_PASS_BY_REF(int,Energy); // 同样定义变量,但是只发声明 get 方法,具体实现需要自己在cpp中定义 CC_PROPERTY_READONLY(int,Energy); CC_PROPERTY_READONLY_PASS_BY_REF(int,Energy); // 同样定义变量,并且直接定义默认的get/set方法。相似的也有前4类 CC_SYNTHESIZE(cocos2d::CCObject*,m_weapon,Weapon); CC_SYNTHESIZE_PASS_BY_REF(cocos2d::CCObject*,Weapon); CC_SYNTHESIZE_READONLY(cocos2d::CCObject*,Weapon); CC_SYNTHESIZE_READONLY_PASS_BY_REF(cocos2d::CCObject*,Weapon); // 在setWeapon的时候,调用原有m_weapon的release,并且调用新值的的retain。当然已经排除了意外情况(相等或者NULL之类的)。 CC_SYNTHESIZE_RETAIN(cocos2d::CCObject*,Weapon); };
需要注意的是
1.CC_PROPERTY更适用于快速声明一个值属性,而CC_SYNTHESIZE更适用于声明一个对象。因为CC_SYNTHESIZE提供的默认set没有任何合法性检查对于值属性来说太不实用。
2.这些方法的声明全部都是virtual的,即便是内联,声明为virtual的方法也不会产生内联函数,所以不管是CC_PROPERTY还是CC_SYNTHESIZE,他们的效率都是不高的。
3.CC_PROPERTY的get方法都没有对函数体声明const修饰符,这意味着对const对象,并不能调用CC_PROPERTY声明的get方法(我怎么觉得这是个cocos2d-x的BUG……)。
4.在CC_SYNTHESIZE方法之后直接声明函数或者变量都会变成public:……注意,嗯。
不好用?跳过去看下定义,自己去定义一个呗……懒得看那就算了。
然后还有快捷的CREATE_FUNC,自动生成一个默认的静态create方法。这实在方便了
class Class: public cocos2d::CCNode { public: CREATE_FUNC(Class); // 自动生成一个不带参数的 create 静态方法,返回一个Class*类型指针。自动调用了init和autorelease方法 } //CREATE_FUNC(Class) 等价于与以下 static Class* create() { Class* pRet = new Class(); if (pRet && pRet->init()) { pRet->autorelease(); return pRet; } else { delete pRet; pRet = NULL; return NULL; } }
而且这也是建议的C++构造函数和init方法的使用规范,先分配空间之后立刻初始化,并且由初始化结果确定能否返回一个可用的对象。在定义特定参数的create方法时也应当这样。
说到初始化,就不得不说到析构,还有一些析构相关的宏。我要release一堆对象,挨个都得判断对象是不是NULL?还要把release后的东西赋值NULL?程序员懒得写这么多行代码……
//所谓的safe逻辑都是这样的,先检查指针p是否为NULL,不为NULL,则执行delete p或者p->release等等。 CC_SAFE_DELETE(p); // 当p不为NULL,delete p 并且将 p 赋为 NULL CC_SAFE_DELETE_ARRAY(p); // ...delete[] p.. CC_SAFE_FREE(p); // ...free p ... CC_SAFE_RELEASE(p); // 当p不为NULL,p->release() CC_SAFE_RELEASE_NULL(p); // 当p不为NULL,p->release() 并且将 p 赋为 NULL CC_SAFE_RETAIN(p); // 当p不为NULL,p->retain()
顺便还有交换两个变量的时候,可以都喜欢懒,写个 void swap(int& a,int &b)什么的、再写void swap(float& a,float& b)什么的,再写个 void swap(string& a,string& b)什么的……总感觉你懒都没人家库程序员懒的懒……这里有个CC_SWAP的宏……
CC_SWAP(x,y,type); // 等价于于以下 { type temp = (x); x = y; y = temp; } // 至少x 和 y 不是表达式的时候这个宏都能工作正常,也不用担心temp变量重复
什么?你说你不服?你说你连type都不想声明……?你居然这么懒那你怎么办你怎么能做到这么懒的啊!你说你用模版?
template <typename t> inline void swap<typename t>(t& a,t& b);
好吧你赢了……
还有cocos2d库开发人员很喜欢用的CC_BREAK_IF,这个宏有什么特别的含义吗?难道其实不就是一行的 if(???) break; ?嗯,就是……没区别。但是你不觉得CC_BREAK_IF( ??? );懒地比人家高端吗?现在的IDE都能自动tab出宏耶!还有可以用下面的while(0)循环写还能代替一些if(???) return false;耶!
bool Class::init() { bool bRet = false; do { // do some initialization 1 CC_BREAK_IF(cond); // 当表达式cond为真时候跳出。 // do some more initialization bRet = true; } while(0); return bRet; }
……积小懒,成大懒啊!可见有一些人,是真的真的很懒很懒……
还能更懒一点吗?答案是肯定的。每当写一个.h时,cocos2d的库程序员都要写一个 namespace cocos2d {...} 吧;每当写一个cpp的时候,你也总是要用到using namespace吧?。。他们都懒得多打这几个字母。。
NS_CC_BEGIN // 这是 namespace cocos2d { NS_CC_END // 这是 } !!!! USING_NS_CC; // 这是 using namespace cocos2d; 这可以是常用宏。
哦什么?你看到程序员用'NS_CC_END' —— 9个字符串代替了原来的 '{'—— 一个字符!天哪这还是懒到骨头里的程序员吗?难道偷懒也能本末倒置?
其实,嗯,不是这样的,程序员是需要懒惰的,但是有时候,也还是要有节操的,只有一个BEGIN没有END,怎么说,也太看不过去了,懒也要懒得优雅、整洁、高端……
所以懒可以没有极限,但是不能没有节操……
……所以有没有觉得懒一点还是不错的?
没有……?
那我懒得接着写了。
c语言 数学函数 不知道代码错哪儿了
有段代码我不知道错哪儿了,请高手指教,谢谢了
#include<stdio.h>#include<math.h>
main(void)
{
double x;
double y;
scanf("%f%f",x,y);
y=acos(x);
printf("acos(%f)=%f\n",x,y);
}
C语言自学《二》下篇---- 类型的转换、字符类型、枚举、数学函数
类型的转换
下面是一个错误的输出,不过通过注释给出了解决办法,就是通过编译器自动类型转换
<!-- lang: cpp -->
int main(void){
//定义了一个float浮点型常量
const float Revenue_Per_150 = 4.5f;
short JanSold = 23500;
short FebSold = 19300;
short MarSold = 21600;
float RevQuarter = 0.0f;
//错误一:总销量的值为64400,这个值超出了short类型的最大取值范围
//short最大取值范围为32767
unsigned long QuarterSold = JanSold + FebSold + MarSold; //错误!输出为负数!
//输出每月分别的销量
printf("Stock sold in\nJan:%hd\nFeb:%hd\nMar:%hd\n",JanSold,FebSold,MarSold);
//输出一个季度的销量
printf("Total stock sold in first quarter: %ld\n",QuarterSold);
//比实际结果值少了1.50
//由于QuarterSold是一个整数,所以计算机将除以150后的结果429.333四舍五入
//所以发生了错误,丢失了精度
//解决此问题的第一个方法:改变下面的运算表达式顺序为:
//RevQuarter = Revenue_Per_150 * QuarterSold / 150; 这样计算就正确了
//第二种解决办法:把150.0作为除数,如下:
//RevQuarter = QuarterSold / 150.0 * Revenue_Per_150;
RevQuarter = QuarterSold / 150 * Revenue_Per_150; //错误!输出为$1930.50!
printf("Sales revenue this quarter is:$%.2f\n",RevQuarter);
}
####强制类型转换 像上面的实例,如果可以把QuarterSold的值转换为float类型,该表达式就会议浮点数的方式计算,问题就解决了
要把变量从一种类型转换为另一种类型,应该把目标类型放在变量前面的括号中,这种显示的转换称为强制类型转换。
下面是表达式和普通强制转换类型的例子
<!-- lang: cpp -->
//经过像下面这样修改,进行强制的类型转换
//经过修改后的表达式,在正确的地方使用正确类型的变量
//当希望保留除法结果的小数部分时,不应使用整数运算
RevQuarter = (float)QuarterSold / 150 * Revenue_Per_150;
//也可以把表达式的结果从一种类型强转为另一种类型,像下面这样:
double result = 0.0;
int a = 5;
int b = 8;
result = (double)(a + b) / 2 - (a + b) / (double)(a * a + b * b);
####自动类型转换
编译器在处理设计不同类型的值操作时,会按照一定规则吧其中一个操作数的类型转换为另一个操作数的类型,这称为隐式类型转换(implicit conversion)
还是这个例子
<!-- lang: cpp -->
//下面的二元运算就进行了隐式自动转换,可以分解成下面的样子
//QuarterSold(64400 int) / 150(int) = 429(四舍五入,舍去了小数部分)
// 429(int) * Revenue_Per_150(4.5 float) = 1930.5(float)
// 在上个步骤中,由于int类型的值域小于float类型,所以自动将int转为float类型
RevQuarter = QuarterSold / 150 * Revenue_Per_150;
#####隐式类型转换规则 基本规则是:将值较小的操作数类型转换为另一个操作数类型,但在一些情况下,两个操作数都要转换类型
以下的规则从高到低排列
- 如果是
long double
,就把另一个操作数转换为long double
- 否则,如果是
double
,就把另一个操作数转换为double
- 否则,如果是
float
,就把另一个操作数转换为float
- 否则,如果两个操作数的类型
都是带符号或无符号
的整数,就把级别较低的操作数转换为另一个操作数类型- 从左到右从低到高(无符号和有符号级别一样): char,short,int,long,long long
- 否则,如果带符号整数类型的操作数级别低于无符号整数类型的级别,就把带符号整数类型的操作数转换为无符号整数类型
- 否则,如果带符号整数类型的值域包含了无符号整数类型所表示的值,就把无符号整数类型转换为带符号整数类型
- 否则,两个操作数都转换为带符号整数类型对应的无符号整数类型
#####赋值语句中的隐式类型转换
下面的例子表示了赋值语句的隐式转换
<!-- lang: cpp -->
int main(void){
//好吧,别看下面一大长串,其实按照上面的规则很简单就能看清是如何隐式转换的
//首先count(long)转换为double类型,ship_cost(float)也转换为double类型
//然后discount(int)转换为long类型,long类型再转换为float类型
//经过两个括号中的计算与转换,现在是下面这样的类型表达式
//long double = double * float
//然后float转换为double
//最后double转换为long double
//因为long double包含double,所以没有丢失精度
double price = 10.0;
long count = 5L;
float ship_cost = 2.5F;
int discount = 15;
long double total_cost = (count * price + ship_cost) * ((100L - discount) / 100.0F);
}
###字符类型
####字符的类型定义及赋值
在所有数据类型中,char类型占用的内存空间最少,它可以存储单个字符,它也只能存储一个整数,所以被看成为整数类型,也可以在算术运算中使用它,它的区间是0~255(signed)或者-128~127(unsigned) 单引号内的字符代码,实际的代码值取决于计算机环境,但最常见的是美国标准信息交换吗(ASCII)
代码示例:
<!-- lang: cpp -->
//下面是给char类型变量指定字符常量,用'' ''单引号括起来
char letter = ''A'';
char digit = ''9'';
char exclamation = ''!'';
//也可以使用转义序列指定字符常量
char newline = ''\n'';
char tab = ''\t'';
char single_quote = ''\'';
//还可以用整数值初始化char类型变量
char character = 74; //解释为J
//使用char进行算术计算
char letter = ''C'';
letter += 3;
####字符的输入输出
使用
scanf()
函数和格式说明符%c
,可以从键盘上读取单个字符 同样用%c
可以输出字符,用%d
输出字符对应的整数
代码示例:
<!-- lang: cpp -->
#include <stdio.h>
int main(){
char ch = 0;
scanf("%c",&ch); //获取键盘输入为字符类型,存储到ch字符变量中
//下面的输出分别为一个字符和一个数值
printf("The character is %c and the code value is %d\n", ch, ch);
}
如果要转换字符的大小写,可以使用标准库<ctype.h>
头文件提供的toupper()
和tolower()
函数
###枚举
####定义枚举类型和枚举变量
利用枚举,可以定义一个新的整数类型,该类型变量的值域是我们指定的几个可能值,下面语句定义了枚举类型
代码示例:
<!-- lang: cpp -->
//下面这个语句定义了一个类型,而不是变量,新类型的名称为Weekday,称为枚举的标记
//大括号中的值称为枚举常量或者叫做枚举器,枚举是一个整数类型,默认从0开始,比如Monday的值就是0,然后逐个递增
enum Weekday {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};
//可以声明Weekday类型的一个新变量,并初始化它,如下所示:
//today的值为2
enum Weekday today = Wednesday;
//或者像下面这样,定义枚举类型时,声明该类型的变量
enum Weekday {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday} today, tomorrow;
//当然也可以直接初始化
enum Weekday {Monday, Tuesday, Wednesday, Thursday,
Friday, Saturday, Sunday} today=Monday, tomorrow=Tuesday;
//由于是整数类型,所以也可以在算术表达式中使用
//要确保给定的枚举类型使用有效的枚举值
enum Weekday {Monday, Tuesday, Wednesday, Thursday,
Friday, Saturday, Sunday} today=Monday, tomorrow = today + 1;
####未命名的枚举类型
未命名枚举类型的主要限制是,必须在定义该类型的语句中声明它的所有变量,由于没有类型标记名,因此无法在代码的后面定义该类型的其他变量
代码示例:
<!-- lang: cpp -->
enum {red, orange, yellow, green, blue, indigo, violet} shirt_color;
shirt_color = blue;
###存储布尔值变量
_Bool类型存储布尔值,它由true或false组成,前者为1后者为0,所以_Bool类型也被看为整数类型 也可以用bool作为类型名称,这看起来更简洁,但是要包含
<stdbool.h>
头文件
代码示例:
<!-- lang: cpp -->
#include <stdbool.h>
int main(){
_Bool valid = 1; //true
_Bool valid = 0; //false
_Bool valid = true;
_Bool valid = false;
bool valid = 1;
bool valid = 0;
bool valid = true;
bool valid = false;
}
###数学函数
<math.h>
头文件包含各种数学函数的声明,所有的函数都返回一个double类型 不过通过在函数后面添加l
或f
,分别可以返回long double
或float
类型 这里就不详细列举数学函数了,用时再查找
我们今天的关于NumPy 教程和第 14 章:数学函数的分享已经告一段落,感谢您的关注,如果您想了解更多关于cocos2d-x 数学函数、常用宏粗整理、cocos2d-x 数学函数、常用宏粗整理(CC_SYNTHESIZE)、c语言 数学函数 不知道代码错哪儿了、C语言自学《二》下篇---- 类型的转换、字符类型、枚举、数学函数的相关信息,请在本站查询。
本文标签: