精华内容
下载资源
问答
  • 前一篇文章里,我们分析了64位游戏坐标,并得到一个存放坐标基地址,但是这个基地址并不能作为最终的数据结果进行记录。为什么要这么说呢?其实这个坐标值也不是不能用,只是他周围没有其他有用信息,那么也...

    前一篇文章里,我们分析了64位的游戏坐标,并得到一个存放坐标的基地址,但是这个基地址并不能作为最终的数据结果进行记录。为什么要这么说呢?其实这个坐标值也不是不能用,只是他的周围没有其他有用的信息,那么也就是说我们在定位这个基地址之后只能得到一套坐标,其他的信息还是需要单独的分析,并且单独记录,这对整体数据的效率是有一些影响的。

    下面我们将继续分析这个基地址中数值的来源,找到真正的角色坐标的公式,以及附近一些其他的有用的信息。

    首先我们来到之前得到基地址的代码处(如图)

    a0db732c0092734a41b1cf1549fba2ae.png

    向上分析,我们发现一条movss dword ptr [0x434c430], xmm0

    说明其实基地址里的值是从这个浮点寄存器写入的,这里有人会说,为什么看完之前的帖子后发现,浮点数数寄存器显示的并不是浮点数而是十六进制呢?这是xdbg相对于od扩展的一个功能。当你在浮点数寄存器上点击右键是会出现选择用什么什么数据类型去查看,而一般的od是没有这个功能的(如图)

    d42d8cf922f07493ce419574f0415436.png

    那么我们继续向上分析,xmm0来源于[rsp+20](如图)

    20d1aad2babe9fb8250f15536d26cf7c.png

    而[rsp+20]在上面的标记处被清零了,这说明xmm0的值其实是在下面的某个call中写入的。于是我们在mov qword ptr [rsp + 0x20], 0处下F2断点,并单步到call里去观察被写入的来源。这里有一个简单的方法,就是在数据窗口中跟随rsp+20,然后在单步执行时观察里面数值的变化,可以很容易的找到写入的来源。

    经过单步执行,我们在经过的第一个call内部找到了写入的来源(如图)

    0e8fa435f8a64d0e3d7f30f73a79b299.png

    对于浮点数寄存器的写入,我们时刻要注意写入的数据类型和长度,很明显虽然xmm1里面有/字节的数值,但是我们只传入了低位的4个字节。

    接下来我们继续分析这个xmm1的来源。并在上面得到了movsd xmm1, qword ptr [rax]。而rax则来源于call qword ptr [rax + 0x1d0]。我们退到函数外面,重新下断,再次来到这个位置,单步步入到函数内部继续分析(如图)

    b5a9f9890566f8ef1aecf33919a26198.png

    函数内部得到了两个偏移,并得到公式[rcx+120]+9C

    点击减号,单步后退到函数外继续分析rcx,可以得到rax+510偏移,并得到来源于rcx(如图)

    0e0c5d00dc8f1e9e8b393ab2a80a2a9c.png

    整理公式更新为[[rax+510]+120]+9C

    返回到最初进入的函数处继续分析,得到一个偏移0E8和基地址,这里没有什么难点,可以轻易的搞定(如图)

    fa642db85fef218c6bc6f48c1181fd97.png

    这样我们就得到了最终的公式,整理后如下

    [[[[0x40a5740]+0E8]+510]+120]+9C X坐标 FLOAT

    [[[[0x40a5740]+0E8]+510]+120]+0A0 Y坐标 FLOAT

    [[[[0x40a5740]+0E8]+510]+120]+0A4 Z坐标 FLOAT

    而在[[[[0x40a5740]+0E8]+510]+120]这个对象下,我们可以得到很多的浮点数,比如角色视角朝向,人物朝向等等(如图)

    c1d435c7b2b9db601052d7cc84118214.png

    而当我们对朝向或者坐标进行修改时,都可以代表本地的一些人物朝向或者位置,当然这通常都是一个假象,是要被修正的(如图)

    2a73ea23af96ca59103b06e9010dc2c5.png

    浮点数的一些运算以及汇编指令我们就先讲到这里,在后面的文章或者视频中我们在逐渐深入学习和完善。

    展开全文
  • 一、原码 反码 补码 正数的原码,反码,补码,移码都等于原码 负数的反码=原码取反 ...但是计算机中都是用补码进行运算的 有符号数(算术移位): 正数 不管左移右移都是补0(左移末尾补0 右移高位补和符号位 即0) 负

    位运算使用的数据类型是整型和字符型
    注意单个字符也能进行异或运算 本质也是ASCII二进制码的异或
    异或结果的最终解释要看结果变量的类型
    不仅整型之间、字符型可以异或 整型和字符串型之间也可以异或

    在这里插入图片描述

    一、原码 反码 补码

    正数的原码,反码,补码,移码都等于原码
    负数的反码=原码取反 (符号不变)
    负数的补码=反码+1
    负数的移码=补码的符号位取反

    二、位运算原理

    对转换成二进制的数字进行每一位上的0、1的运算,:
    与(&),或(|),异或(^),左移(<<),右移(>>)

    在计算机组成原理中移位运算如下(无符号数左右逻辑移都是补充0

    在这里插入图片描述

    但是计算机中都是用补码进行运算的 有符号数(算术移位):
    正数 不管左移右移都是补0(左移末尾补0 右移高位补和符号位 即0)
    负数 左0右1(左移末尾补0 右移高位补和符号位 即1)
    按照移动规则括号里面的叙述 那么有符号数不管正数负数的移动规则都是一样的 左移末尾补0 右移高位补和符号位 因此在写代码时并不影响代码的实现

    m>>n m 右移n位
    m<<n m 左移n位
    有符号数移位运算等价于2的幂次乘除法运算

    无符号数:左移右移都是补0(逻辑移位)

    如在某些语言(如 Java)中,没有无符号整数类型。在这种情况下,若要求将一个无符号数的二进制位反转后输出,输入和输出都将被指定为有符号整数类型,因为无论整数是有符号的还是无符号的,其内部的二进制表示形式都是相同的,只是最后编译器会根据声明的变量是有股好还是无符号去解释数据为十进制输出给人看,十进制的结果的解释最终是由于编译器去做这件事的,见leetcode例题无符号数的二进制位反转后输出的几种方法

    位运算的规律:
    1.进行位运算时都是用数据的补码进行运算。
    2.运算后得到的结果也是补码,需要将它转换成原码才能得到结果。

    其实不光位运算计算机中所有运算都遵循补码运算 结果为负要减1求反这个规则
    如果运算后得到的二进制串是一个正数(最高位为0)可以不转因为正数的补码和原码相同;如果为负数 减1再求反

    #include <iostream>
    void main()
    {
     	//-----------正数按位运算-----------
    	//按位右移  >> 往右移一位 
    	//0000 0000 0000 1010
    	//0 0000 0000 0000 101
    	short sValue1 = 10 >> 1;
    	printf("sValue1=%d\n", sValue1);  //5
     
    	//按位左移  << 往左移一位 
    	//0000 0000 0000 1010
    	//000 0000 0000 1010 0
    	short sValue2 = 10 << 1;
    	printf("sValue2=%d\n", sValue2); //20
    
    	//按位或 |
    	//0000 0000 0000 1111
    	//0000 0000 0000 1010
    	//0000 0000 0000 1111
    	short sValue3 = 15 | 10;
    	printf("sValue3=%d\n", sValue3);//15
    	
    	//按位与 & 
    	//0000 0000 0000 1111
    	//0000 0000 0000 1010
    	//0000 0000 0000 1010
    	short sValue4 = 15 & 10;
    	printf("sValue4=%d\n", sValue4); //10
    	
    	//按位异或  ^ 
    	//0000 0000 0000 1111
    	//0000 0000 0000 1010
    	//0000 0000 0000 0101
    	short sValue5 = 15 ^ 10;
    	printf("sValue5=%d\n", sValue5);//5
    	
    	//按位非 ~  
    	//0000 0000 0000 1010          
    	//1111 1111 1111 0101(结果为负数 且是计算机中是补码表示)
    	//需要补码转原码
    	//->1111 1111 1111 0100(减1得反码)->1000 0000 0000 1011(求反得原码)
    	short sValue6 = ~10;
    	printf("sValue6=%d\n", sValue6);//11
     
        
     
    	//-----------负数安位运算-----------//
    	//负数用补码来运算
     
    	//按位或  |  
    	//1000 0000 0000 1111(-15原码)
    	//->1111 1111 1111 0000(反码)
    	//->1111 1111 1111 0001(补码)
    	
    	//1111 1111 1111 0001
    	//0000 0000 0000 1010          
    	//1111 1111 1111 1011(补码)
    	//结果为负的补码 减1求再求反
    	//->1111 1111 1111 1010(反码)->1000 0000 0000 0101(原码)
    	short sValue7 = -15 | 10;
    	printf("sValue7=%d\n", sValue7);//-5
     
    	//按位与 &
    	//1000 0000 0000 1111(-15原码)
    	//->1111 1111 1111 0000(反码)
    	//->1111 1111 1111 0001(补码)
    	
    	//1111 1111 1111 0001
    	//0000 0000 0001 0100
    	//0000 0000 0001 0000(补码)
    	//结果为正的补码 不用再转
    	short sValue8 = -15 & 20;
    	printf("sValue8=%d\n", sValue8);//16
    
    	//按位非 ~           
    	//1111 1111 1111 0001
    	//0000 0000 0000 1110  (正的补码)
    	short sValue10 = ~-15;
    	printf("sValue10=%d\n", sValue10);//14
     
    	//按位右移  >> 往右移一位  最高位补上和符号位相同的数 即1
    	//1000 0000 0000 1010  (原码)
    	//->1111 1111 1111 0101(反码)
    	//->1111 1111 1111 0110(补码) 
    	
    	//1111 1111 1111 0110
    	//1 1111 1111 1111 011(结果为负的补码 减1再求反)
    	//->1111 1111 1111 1010 (反码)
    	//->  1000 0000 0000 0101 (原码)
    	short sValue11 = -10 >> 1;
    	printf("sValue11=%d\n", sValue11);// -5
    	
    	//按位左移  << 往左移一位  最末位补0
    	//1111 1111 1111 0110 (补码)
    	//111 1111 1111 0110 0 (结果为负的补码 减1再求反补码)
    	//->1111 1111 1110 1011 (反码)
    	//->1000 0000 0001 0100(原码)
    	short sValue12 = -10 << 1;
    	printf("sValue12=%d\n", sValue12);//-20
    	system("pause");
    }
    

    三、位运算的巧妙运用

    与 &的应用
    1 、清零:A&0(也可指定清零某些位)
    2 、取指定位 
    3 、 判断奇偶性 :只根据最末位是0还是1判断整数的奇偶性如整数n

    if((n & 1) == 0)来判断 比用 if(n%2==0) 判断奇偶性效率高。
    将int型变量a的第k位清0,即a=a&~(1<<k)int型变量a的第k位置1,即a=a|(1<<k)
    

    异或^ 的应用
    1、特定位翻转 要使哪几位翻转就将其和相应位为1的数进行∧运算
    2、数据交换,交换两个值不用临时变量.

    void swap(int &a, int &b)
    {
        if (a != b){
            a ^= b;//a=(a^b);
            b ^= a;//^运算满足交换律,b=b^(a^b)=b^b^a=a
            a ^= b;//a=a^b=(a^b)^a=a^a^b=b
        }
    }
    

    3、变换符号 :x 的 相反数为 (~x+1)
    正负号变换只需将原数的二进制取反后加1

    short a = 11;  //a的补码0000 1011
    short b=~a     //b的补码 1111 0100 位运算的结果为负的补码
    				// 减1->1111 0011(反码)
                    //求反->1000 1100(原码)-12
                    
    short c=b+1;   //c的补码 1111 0101 结果为负的补码 
                   //  减1->1111 0100
                   // 求反->1000 1011(原码)-11
     //其实求c的时候已经是short型数据的四则运算 但是计算机中仍然是以补码加法来算的
    printf("%d\n", c)//a c 符号相反
    
    short d = -11;  //d的原码1000 1011 补码1111 0101
    short e=~d     //e的补码 0000 1010 即10
    short f=e+1;   //f的补码 0000 1011 即11
    printf("%d\n", f)//d f 符号相反
    

    同时求反再加一还有一个妙用 :仅保留二进制串里面最右边的那一个1: (x & -x)
    检测室2的幂次: (x & -x)==x
    去除最右边的1检测2 的幂次:(x & (x-1))== 0
    在这里插入图片描述
    在这里插入图片描述

    4、求绝对值(与负数交换符号原理相同)

    int abs( int x )
    {
        int y ;
        y = x >> 31 ;
        return (x^y)-y ;        //or: (x+y)^y
        y就是x的符号位 
        假如x为正 y=0320 正数移位是补0 解释出来仍是十进制0(x^y)-y=x-0=x 
        假如x为负 y=-1
        (这里是指十进制-1 在机器中取出来的符号位那一位仍然是1 y的二进制是321)
        (为负数时在计算机中是补码右移补1 结果为负要转成原码 321转成原码十进制是-1)
     
        (x^y)即二进制串与全1求异或 相当于对二进制按位求反再减-1即
        求反再加1 (x^y)-y就等于求反再加1  
    }
    

    5、高低位互换
    16位的无符号整数。称这个二进制数的前8位为“高位”,后8位为“低位”。例如,数34520用二进制表示为:10000110 11011000
    将它的高低位进行交换,我们得到了一个新的二进制数:11011000 10000110它即是十进制的55430。

    设x=34520=10000110 11011000 由于x为无符号数,右移时会执行逻辑右移即高位补0,因此x右移8位将得到00000000 10000110。而x左移8位将得到11011000 00000000。可以发现只要将x>>8与x<<8这两个数相或 就可以得到1101100010000110。
    基于这个原理可以采用分治对对任意二进制串逆序,只是这种方法需要自己去手动计算哪些位做与运算(实际上就是每次互换的那些位取1 其他位取0) 不过不用任何循环完全只用位运算就可以实现*

    我们可以通过以下步骤实现32 位翻转:
    首先,我们将原来的 32 位分为 216 位的块。
    然后我们将 16 位块分成 28 位的块。
    然后我们继续将这些块分成更小的块,直到达到 1 位的块。
    在上述每个步骤中,我们将中间结果合并为一个整数,作为下一步的输入。
    
        uint32_t reverseBits(uint32_t n) {16位和第16位互换后的n
            n = (n >> 16) | (n << 16);
            
            现在将216位的块中各自的高80xff00和低80x00ff互换后合并
            n = ((n & 0xff00ff00) >> 8) | ((n & 0x00ff00ff) << 8);
            
            现在将48位的块中各自的高40xf0和低40x0f互换后合并
            n = ((n & 0xf0f0f0f0) >> 4) | ((n & 0x0f0f0f0f) << 4);
            
            现在将84位的块中各自的高211000xc和低200110xc互换后合并
            n = ((n & 0xcccccccc) >> 2) | ((n & 0x33333333) << 2);
            
            现在将162位的块中各自的高110 和低101互换后合并
            相邻两个2位的块组成一个4位的块 即1010=0xa 或者0101=0x0584位的块
            n = ((n & 0xaaaaaaaa) >> 1) | ((n & 0x55555555) << 1);
            return n;1610000110 110110008位和低8位互换后
    ->11011000 10000110
    ->(11011000 10000110 & 11110000 11110000)>>4|取各自的高四位 并左移
      (11011000 10000110 & 00001111 00001111)<<4 取各自的低四位 并右移
    ->11010000 10000000>>4 |00001000 00000110<<4
    ->00001101 00001000 | 10000000 01100000
    ->10001101 0110100011011000 10000110 相比各自的8位中高四位和低四位已经互换
      难点就是自己要去算与的那个数是哪些位取1实际上就是每次互换的那些位取1 其他位取0
        }
    

    6、判断一个整数是不是2的整数次方
    如果一个整数是2的整数次方,那么它的二进制标识中一定有且只有一位是1,而其他所有位均为0. 解决方案:
    把这个整数减去1之后再和本身做与运算,这个整数中唯一的一个1就会变成0.所以只要判断是不是等于0即可。

    位运算的优先级超级超级超级低 尽量都打括号

    
        bool isPowerOfTwo(int n) {
              
             if(n==INT_MIN||n<0) return false;
             if(( n & (n-1))==0 && (n!=0)) return true;
             else return false;
             
    不能是 n & (n-1)==0 会先赋值 
    
    计算机中是补码表示负数,负数时可能会溢出int型范围 [-2^31,2^31-1] n=-2^31时n-1就溢出因此需要判断n==INT_MIN 又有任何数的幂次都大于00和任何数与都等于0 因此可直接n<=0false
      
    
        }
    

    7、循环移位

    int型变量循环左移k次,即a=a<<k|a>>16-k   (sizeof(int)=16)int型变量a循环右移k次,即a=a>>k|a<<16-k  (sizeof(int)=16)
    

    8、2幂次的取模运算转化成位运算 (在不产生溢出的情况下)

       a % (2^n) 等价于 a & (2^n - 1)
       
       也就是求对应位后面为1的那些
       如42%8 = 2 =42 & 7
       0010 1010 & ( 0000 1000 -1) =
       0010 1010 & 0000 0111 =
       0000 0010
       -42%8= 6 =-42 & 7 注意余数一定是正数
       1010 1010-42的原码) 求反加1 ->1101 0110-42的补码)
       1101 0110 & 0000 0111=0000 0110 =6
    

    求输入是一个无符号整数的二进制表达式中数字位数为 ‘1’ 的个数(也被称为汉明重量)。
    每次把最后一个一翻转 计数加一 直到n变成0
    在这里插入图片描述

    public int hammingWeight(int n) {
        int sum = 0;
        while (n != 0) {// 并不是去扫描n的每一位
            sum++;
            n &= (n - 1);
        }
        return sum;
    }
    
    展开全文
  • 运算符:常量和变量进行操作的符号称为运算符操作数:参与运算的数据称为操作数用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。不同运算符连接的式子体现的是不同类型的表达式。举例:int a ...

    1 运算符

    • 运算:对常量和变量进行操作的过程称为运算。

    • 运算符:对常量和变量进行操作的符号称为运算符

    • 操作数:参与运算的数据称为操作数

    • 用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。
      不同运算符连接的式子体现的是不同类型的表达式。

    举例:int a = 3 + 4;
    这是做了一个加法运算,+就是运算符,是算术运算符,我们还有其他很多的运算符,3和4就是参与运算的操作数据,3 + 4整体其实就是一个算数表达式

    2 算术运算符

    a42c05946fe2507e44cf8c13afc37fd5.png
    算术运算符

    除法的时候要注意一个问题,整数相除,只能得到整数,要想得到小数,可以*1.0

    • ++和--的应用
      单独使用:放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
      参与运算使用:放在操作数的前面,先自增或者自减,然后再参与运算;放在操作数的后面,先参与运算,再自增或者自减。
      作用:就是对变量进行自增1或者自减1。

    • +的用法:加法,正号,字符串连接符

    • 运算符的优先级(由高到低)

    df6379efcd320f22f5d636f3cd696e7e.png
    运算符的优先级

    3 赋值运算符

    基本的赋值运算符:=,把=右边的数据赋值给左边。
    扩展的赋值运算符:+=、-=,*=,/=,%=,+= 把左边和右边做加法,然后赋值给左边。

    4 关系运算符

    ba8596433d441a7226a78950bce8641b.png
    关系运算符
    • 比较运算符的结果都是boolean型,也就是要么是true,要么是false。

    • 比较运算符“==”不能误写成“=”

    5 逻辑运算符

    28d768b7ae28b145c855868248c55e40.png
    逻辑运算符
    • 逻辑运算符用于连接布尔型表达式,在Java中不可以写成 `3

      3 & x<6 。

    • “&”和“&&”的区别

    • 单&时,左边无论真假,右边都进行运算

    • 双&时,如果左边为真,右边参与运算,如果左边为假,那么右边不参与运算

    • “|”和“||”的区别同理,双或时,左边为真,右边不参与运算

    • 异或( ^ )与或( | )的不同之处是:当左右都为true时,结果为false

    6 位运算符

    位运算是直接对二进制进行运算

    e1e6e4a5a6675c20a3ac7e99af043463.png
    位运算符
    6a661ae4c6b4fe35dcb58398dab6ab4e.png
    位运算符的细节
    /*
        位运算符:
            &,|,^,~
            <>,>>>
        注意:
            要做位运算,首先要把数据转换为二进制。
    */

    class OperatorDemo {
        public static void main(String[] args) {
            //&,|,^,~

            int a = 3;
            int b = 4;

            System.out.println(3 & 4);
            System.out.println(3 | 4);
            System.out.println(3 ^ 4);
            System.out.println(~3);
        }
    }
    /*
        分析:因为是位运算,所以我们必须先把数据换算成二进制。
        3的二进制:11
            00000000 00000000 00000000 00000011
        4的二进制:100
            00000000 00000000 00000000 00000100
        &位与运算:有0则0。
            00000000 00000000 00000000 00000011
            &00000000 00000000 00000000 00000100
            -----------------------------------
            00000000 00000000 00000000 00000000
            结果是:0
        |位或运算:有1则1。
            00000000 00000000 00000000 00000011
            |00000000 00000000 00000000 00000100
            -----------------------------------
            00000000 00000000 00000000 00000111
            结果是:7
        ^位异或运算:相同则0,不同则1。
            00000000 00000000 00000000 00000011
            &00000000 00000000 00000000 00000100
            -----------------------------------
            00000000 00000000 00000000 00000111
            结果是:7
        ~按位取反运算符:0变1,1变0
            00000000 00000000 00000000 00000011
           ~11111111 11111111 11111111 11111100 (补码)
           补码:11111111 11111111 11111111 11111100
           反码:11111111 11111111 11111111 11111011
           原码:10000000 00000000 00000000 00000100
           结果是:-4
    */

    7 三目运算符

    • 格式:(关系表达式)?表达式1:表达式2;

    • 如果条件为true,运算后的结果是表达式1;

    • 如果条件为false,运算后的结果是表达式2;

    • 示例:获取两个数中大数。

    int x=3,y=4,z;
    z = (x>y)?x:y;//z变量存储的就是两个数的大数。

    8 运算符的优先级

    在对一些比较复杂的表达式进行运算时,要明确表达式中所有运算符参与运算的先后顺序,把这种顺序称作运算符的优先级。

    39ba717ac652effdbceaeb53e1417abc.png
    1500703686246

    9 Math

    Math类提供了常用的一些数学函数,如:三角函数、对数、指数等。一个数学公式如果想用代码表示,则可以将其拆分然后套用Math类下的方法即可。

    Math.abs(12.3);                 //12.3 返回这个数的绝对值  
    Math.abs(-12.3);                //12.3  

    Math.copySign(1.23, -12.3);     //-1.23,返回第一个参数的量值和第二个参数的符号  
    Math.copySign(-12.31.23);     //12.3  

    Math.signum(x);                 //如果x大于0则返回1.0,小于0则返回-1.0,等于0则返回0  
    Math.signum(12.3);              //1.0  
    Math.signum(-12.3);             //-1.0  
    Math.signum(0);                 //0.0  

    指数

    //指数  
    Math.exp(x);                    //e的x次幂  
    Math.expm1(x);                  //e的x次幂 - 1  

    Math.scalb(x, y);               //x*(2的y次幂)  
    Math.scalb(12.33);            //12.3*2³  

    取整

    //取整  
    Math.ceil(12.3);                //返回最近的且大于这个数的整数13.0  
    Math.ceil(-12.3);               //-12.0  

    Math.floor(12.3);               //返回最近的且小于这个数的整数12.0  
    Math.floor(-12.3);              //-13.0  

    平方根立方更

    //x和y平方和的二次方根  
    Math.hypot(x, y);               //√(x²+y²)  

    //返回概述的二次方根  
    Math.sqrt(x);                   //√(x) x的二次方根  
    Math.sqrt(9);                   //3.0  
    Math.sqrt(16);                  //4.0  

    //返回该数的立方根  
    Math.cbrt(27.0);                //3   
    Math.cbrt(-125.0);              //-5  

    最大最小值

    //返回较大值和较小值  
    Math.max(x, y);                 //返回x、y中较大的那个数  
    Math.min(x, y);                 //返回x、y中较小的那个数  

    对数与幂

    //对数函数  
    Math.log(e);                    //1 以e为底的对数  
    Math.log10(100);                //10 以10为底的对数  
    Math.log1p(x);                  //Ln(x+ 1)  



    //返回 x的y次幂  
    Math.pow(x, y);                   
    Math.pow(23);                 //即2³ 即返回:8  

    随机

    //随机返回[0,1)之间的无符号double值  
    Math.random();                    

    //返回最接近这个数的整数,如果刚好居中,则取偶数  
    Math.rint(12.3);                //12.0   
    Math.rint(-12.3);               //-12.0  
    Math.rint(78.9);                //79.0  
    Math.rint(-78.9);               //-79.0  
    Math.rint(34.5);                //34.0  
    Math.rint(35.5);                //36.0  

    Math.round(12.3);               //与rint相似,返回值为long  

    三角函数与角度

    //三角函数  
    Math.sin(α);                    //sin(α)的值  
    Math.cos(α);                    //cos(α)的值  
    Math.tan(α);                    //tan(α)的值  

    //求角  
    Math.asin(x/z);                 //返回角度值[-π/2,π/2]  arc sin(x/z)  
    Math.acos(y/z);                 //返回角度值[0~π]   arc cos(y/z)  
    Math.atan(y/x);                 //返回角度值[-π/2,π/2]  
    Math.atan2(y-y0, x-x0);         //同上,返回经过点(x,y)与原点的的直线和经过点(x0,y0)与原点的直线之间所成的夹角  

    Math.sinh(x);                   //双曲正弦函数sinh(x)=(exp(x) - exp(-x)) / 2.0;  
    Math.cosh(x);                   //双曲余弦函数cosh(x)=(exp(x) + exp(-x)) / 2.0;  
    Math.tanh(x);                   //tanh(x) = sinh(x) / cosh(x);  

    //角度弧度互换  360°角=2π弧度
    Math.toDegrees(angrad);         //角度转换成弧度,返回:angrad * 180d / PI  

    Math.toRadians(angdeg);         //弧度转换成角度,返回:angdeg / 180d * PI  

    Math.PI

    更多好文

    java精品入门系列

    1. java精品入门-0基础第一篇

    2. JDK、JRE、JVM的区别与联系

    3. 变量与数据类型 java基础03

    99bace4709609f9fb506c87f43388b24.png

    2991de3dd93709d842519826543d3952.png

    f5bd403f26721c8f22985df888a43da2.png

    亲,需要你的“分享”“在看”

    84eefd5fbcea0280e4bfb585073eefc5.png

    IT入门 感谢关注

    程序员题库→程序员用的单词表→练习地址:www.520mg.com/it
    展开全文
  • 数据的表示总结

    2017-02-23 11:07:42
    1.原、反、补、移码 整数原、反、补还是自己(符号位为0); 负数原码:符号位1+负数本身的绝对值;...首先阶(原则是小阶想大阶看齐),然后阶码小位数右移(大阶-小阶)位,最后进行相应计算。 3.

    1.原、反、补、移码

    整数的原、反、补还是自己(符号位为0);

    负数的原码:符号位1+负数本身的绝对值;反码:除去符号位负数本身绝对值对应的数按位取反;补码:反码+1;

    移码:对补码的符号位取反,只用于表示浮点数的阶码,即只用于整数。

    2.浮点数运算

    首先对阶(原则是小阶想大阶看齐),然后阶码小的数的位数右移(大阶-小阶)位,最后进行相应的计算,将结果格式化。


    展开全文
  • Octave矩阵计算数据

    2019-04-24 01:28:24
    操作两个矩阵 ...exp(N) 矩阵N内元素进行以e为底元素为指数运算 abs(N) 矩阵内元素全部去绝对值 骚操作加法 求A转置 取矩阵中元素最大值 max(A) 下图中ind是获得索引 当为矩阵,返...
  • 类型间可进行混合运算,结果为最宽类型 abs(x)绝对值 divmod(x,y)商余,同时输出商和余数 pow(x,y,[z]) z可省略。表示(xy)%z round(x,d)X四舍五入,d是小数截取位数 max(…)取最大值 min()
  • Java 运算符概述

    2020-06-23 21:55:43
    1、运算符:就是常量和变量进行操作符号。 2、运算符分类: 算数运算符 赋值运算符 比较(关系或条件)运算符 逻辑运算符 位运算符 三目(元)运算符 3、算数运算符有哪些:+ - * / % ++ -- 4、注意事项: ...
  • D0822-API01

    2020-08-27 23:32:26
    Math类中包含一些对数据进行数学运算的方法,而该类中的方法全都是静态的。像这样的类称之为工具类 public static int abs(int a) //对一个数据求绝对值 public static double ceil(double n) //对一个小数向上取整 ...
  • 数据结构题

    2012-12-27 16:58:40
    6.下列陈述中正确的是( ) A.二叉树是度为2的有序树 B.二叉树中结点只有一个孩子时无左右之分 C.二叉树中必有度为2的结点D.二叉树中最多只有两棵子树,并且有左右之分 7.n个叶子的霍夫曼树结点总数为( ) A.2n B.2n...
  • Math类中包含一些对数据进行数学运算的方法,而该类中的方法全都是静态的。像这样的类称之为工具类 public static int abs(int a) 对一个数据求绝对值 public static double ceil(double n) 对一个小数向上取整 ...
  • 什么是原码?

    2021-01-24 21:26:32
    原码什么是原码?什么是符号位?原码有多长?如何求解原码?举例 什么是原码? 答:原码:是一连串 加了一位符号位二进制数 ...对于负数:先该负数取绝对值,然后计算二进制数,之后每一个数进行取反,然后加一
  • 原码,、反码、补码计算

    千次阅读 2018-07-20 06:31:51
    所有数据的运算都是采用补码进行的。 原码:原码就是符号位加上真值的绝对值,即最高位为符号位,“0”表示正,“1”表示负,其余位表示数值大小。 +3 = 00000011 -3 = 10000011 1 2 反码:正数反码与其...
  • **A、**首先,通过传感数据的观察,如上图所示,可以看出,这些数据绝对值小于1有符号小数;并且,其小数点位置是不发生变化,所以可采用定点小数来表示。且在DSP中,定点小数运算,实际上就是用整数来...
  • 二叉排序树与平衡二叉树实现

    热门讨论 2010-12-26 15:25:31
    35% 04 综合运用知识能力 10 能运用所学知识和技能去发现与解决实际问题,能正确处理实验数据,能课题进行理论分析,得出有价值结论。 05 应用文献能力 5 能独立查阅相关文献和从事其他调研;能提出并较...
  • C++头文件整理

    2021-02-08 11:51:06
    iostream iostream 头文件主要包含了系统标准输入输出函数以及数据的声明和定义 cstdio cstdio使用流来操作物理设备如键盘,打印机,终端或者系统支持其它类型文件,也...顾名思义进行数学运算,有取绝对值,取整
  • Python内置函数 任何一门编程语言的核心操作都是操作内存...2、数学运算的函数 abs():求绝对值 round() 浮点数进行近似取值,保留几位小数 注意:这里不完全是按照四舍五入或者四舍六入五成双来进行取值的,取值和
  • LINGO软件学习

    2009-08-08 22:36:50
    注意如果派生集B父集是另外派生集A,那么上面所说原始父集是集A向前回溯到最终原始集,其顺序保持不变,并且派生集A过滤器派生集B仍然有效。因此,派生集索引个数是最终原始父集个数,索引取值是...
  • 一、ufunc:numpy 模块中 ndarray 中数据进行快速元素级运算的函数,也可以看做是简单的函数(接受一个或多个标量值,并产生一个或多个标量值)的矢量化包装器。 二、一元函数: 一元ufunc 描述 ...
  • 现有判定方法有从某个结点出发后借助有向图正向和逆向深度优先搜索来进行的,有通过求其可达矩阵来判定,有将有向图中形成回路结点进行收缩方法来判断等。从降低时间复杂度和空间复杂度考虑,找出结点较多...
  • java常用工具类使用

    热门讨论 2012-03-19 20:11:37
    比如一个数组进行排序,程序员可以写如下排序算法: 代码演示:数组排序 public static void sort(int[] arrs) { boolean isSwap = false; for (int i = 0; i ; i++) { isSwap = false; for (int j = arrs....
  • Math类用实现了很多数学运算的方法,如求三角函数值、求指数、求对数、求绝对值等,这里仅列出方法描述的表格,请有需要的同学自行测试。剩余的其他三个类,我将直接呈现测试的代码,在注释中穿插解释。 当然,这次...
  • 三个问题

    2017-10-21 11:04:35
    即取该数绝对值二进制数,计算机中对数据的存储是按补码形式存储 那么就要把原码先转换成反码 即按位取反得到-0=(11111111)反码 再把反码加1得到补码 ,所以-0=(00000000)补码。 2: int i = -20; ...
  • python-全局函数

    2020-10-23 17:56:48
    全局函数 Python有很多内置方法,以下都全局可用: ...4.bool() 进行布尔运算,一般 None、空字符串、空列表、空元组、空集合、空字典、0等空元素和空数据结构为False,其他为True (1) 5.all() 可迭代对象
  • “+” “-“操作符进行数学运算时与数学上正负运算符几乎没有什么差别,需要注意一点是:由于带有符号的数据类型其最大值,最小值在绝对值上不对称,所以,如果”+” "-"操作符运用不当,就有可能会造成值溢出。...
  • crc校验易语言模块

    2013-04-15 10:35:59
    CRC的本质是进行XOR运算,运算的过程我们不用管它,因为运算过程最后的结果没有意义;我们真正感兴趣的只是最终得到的余数,这个余数就是CRC值。 易语言用户林子深提供了一个CRC32.EC的易模块,这个模块可以在论坛...
  • VBSCRIP5 -ASP用法详解

    2010-09-23 17:15:46
    通过信息进行分组,可以使您方便地研究 Visual Basic 脚本各个主题。 可以在“字母顺序关键字列表”中找到 VBScript 语言所有主题。如果只需要查看某个主题(例如对象),则有该主题进行详细说明章节可供...
  • ABS ABS(X) 求X的绝对值 Pow Pow(X, Y) 求XY次方 Sqr Sqr(X) 求X平方 Sqt Sqrt(X) 求X平方根值 Log Log(Base, Exp) 求以Base为底对数 Log2 Log(2, Exp) 求以2为底对数 Log10 Log(10, Exp) 求以10为底...
  • 面试题36:数组中逆序对:这道题可以这么想,我们要找到数组中逆序对,可以看做对数据进行排序,需要交换数组中元素次数,但是防止相同大小元素发生交换,因此需要选择一个稳定排序方法,记录发生交换...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

对数据进行绝对值运算的是