精华内容
下载资源
问答
  • Android中MathMath.floor()、Math.round()及Math.ceil()等方法的使用
    2021-05-26 13:36:58

    1、Math.floor()

    先看定义:

    /**

    * Returns the double conversion of the most positive (closest to positive

    * infinity) integer value less than or equal to the argument.

    *

    * Special cases:

    *

    *

    {@code floor(+0.0) = +0.0}

    *

    {@code floor(-0.0) = -0.0}

    *

    {@code floor(+infinity) = +infinity}

    *

    {@code floor(-infinity) = -infinity}

    *

    {@code floor(NaN) = NaN}

    *

    */

    public static native double floor(double d);

    由定义可知:Math.floor()表示向下取整。,即小于或等于double型参数的整数位的数字。

    比如:Math.floor(18.7)的结果是18.0,Math.floor(-18.3)的结果-19.0,下面再列出几组:

    Math.floor(-1.1): -2.0

    Math.floor(-1.5): -2.0

    Math.floor(-1.6): -2.0

    Math.floor(0.1): 0.0

    Math.floor(0.5): 0.0

    Math.floor(0.6): 0.0

    Math.floor(1.1): 1.0

    Math.floor(1.5): 1.0

    Math.floor(1.6): 1.0

    2、Math.round()

    接下来看Math.round()的定义:

    /**

    * Returns the result of rounding the argument to an integer. The result is

    * equivalent to {@code (int) Math.floor(f+0.5)}.

    *

    * Special cases:

    *

    *

    {@code round(+0.0) = +0.0}

    *

    {@code round(-0.0) = +0.0}

    *

    {@code round((anything > Integer.MAX_VALUE) = Integer.MAX_VALUE}

    *

    {@code round((anything < Integer.MIN_VALUE) = Integer.MIN_VALUE}

    *

    {@code round(+infinity) = Integer.MAX_VALUE}

    *

    {@code round(-infinity) = Integer.MIN_VALUE}

    *

    {@code round(NaN) = +0.0}

    *

    *

    * @param f

    * the value to be rounded.

    * @return the closest integer to the argument.

    */

    public static int round(float f) {

    // check for NaN

    if (f != f) {

    return 0;

    }

    return (int) floor(f + 0.5f);

    }

    由定义可以很清楚的知道:Math.round()方法表示的是“四舍五入”的计算。

    算法为Math.floor(f+0.5),即将原来的数字加上0.5后再向下取整

    Math.round(18.5)的结果为19,Math.round(-18.5)的结果为-18。下面再列出几组:

    Math.round(-1.1): -1

    Math.round(-1.5): -1

    Math.round(-1.6): -2

    Math.round(0.1): 0

    Math.round(0.5): 1

    Math.round(0.6): 1

    Math.round(1.1): 1

    Math.round(1.5): 2

    Math.round(1.6): 2

    3、Math.ceil()

    Math.ceil的定义为:

    /**

    * Returns the double conversion of the most negative (closest to negative

    * infinity) integer value greater than or equal to the argument.

    *

    * Special cases:

    *

    *

    {@code ceil(+0.0) = +0.0}

    *

    {@code ceil(-0.0) = -0.0}

    *

    {@code ceil((anything in range (-1,0)) = -0.0}

    *

    {@code ceil(+infinity) = +infinity}

    *

    {@code ceil(-infinity) = -infinity}

    *

    {@code ceil(NaN) = NaN}

    *

    */

    public static native double ceil(double d);

    由定义也可知:Math.ceil()方法就表示向上取整。即大于或等于double型参数的整数位的数字。

    比如:Math.ceil(18.3)的结果是19.0,Math.ceil(-18.7)的结果-18.0。再看看一组:

    Math.ceil(-1.1): -1.0

    Math.ceil(-1.5): -1.0

    Math.ceil(-1.6): -1.0

    Math.ceil(0.1): 1.0

    Math.ceil(0.5): 1.0

    Math.ceil(0.6): 1.0

    Math.ceil(1.1): 2.0

    Math.ceil(1.5): 2.0

    Math.ceil(1.6): 2.0

    4、Math.rint()

    Math.rint()的定义:

    /**

    * Returns the double conversion of the result of rounding the argument to

    * an integer. Tie breaks are rounded towards even.

    *

    * Special cases:

    *

    *

    {@code rint(+0.0) = +0.0}

    *

    {@code rint(-0.0) = -0.0}

    *

    {@code rint(+infinity) = +infinity}

    *

    {@code rint(-infinity) = -infinity}

    *

    {@code rint(NaN) = NaN}

    *

    *

    *@param d

    * the value to be rounded.

    *@return the closest integer to the argument (as a double).

    */

    public static native double rint(double d);

    Math.ring()返回double值最接近参数的值,并等于某个整数。如果两个double值跟整数都同样接近,结果是整数值是偶数。特殊情况:

    如果参数值已经等于某个整数,那么结果跟参数一样。

    如果参数为NaN或无穷大,正零或负零,那么结果和参数一样。

    比如例子:

    Math.rint(-1.1): -1.0

    Math.rint(-1.5): -2.0

    Math.rint(-1.6): -2.0

    Math.rint(0.1): 0.0

    Math.rint(0.5): 0.0

    Math.rint(0.6): 1.0

    Math.rint(1.1): 1.0

    Math.rint(1.5): 2.0

    Math.rint(1.6): 2.0

    更多相关内容
  • Math.floor() method rounds a number DOWNWARDS to the nearest integer, and returns the result. (小于等于 x,且与 x 最接近的整数。)其实返回值就是该数的整数位:Math.floor(0.666) –> 0Math.floor(39.2783...
  • 主要介绍了Java Math.round(),Math.ceil(),Math.floor()的区别详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Math.floor( x ) ; 下面是参数的详细信息: x : 一个数字 返回值: 返回比最大的整数小于或等于一个数x 例子: <html> <head> <title>JavaScript Math floor() Method</title> </head&...
  • 首先还是看看[removed] The Definitive Guide, 4th Edition中对三个函数的定义。 Math.ceil(): round a number up ...Math.floor(): round a number down Arguments: Any numeric value or expressi
  • Math是一个对象,不是一个构造函数,所以不能new Math 一、返回0到1之间的随机数值,但不包含1,包含零。顾头不顾尾。一般零出现的概率极小,可以忽略不计。 <div class="bg" @click="cssChange"> </div&...

    、、、、、、、、、、、仅对以前所学做复习记录使用、、、、、、、、、

    Math是一个对象,不是一个构造函数,所以不能new Math

    一、返回0到1之间的随机数值,但不包含1,包含零。顾头不顾尾。一般零出现的概率极小,可以忽略不计。

    <div class="bg" @click="cssChange"> </div>
    
    cssChange(){					
    		console.log(Math.random());
    	}
    

    在这里插入图片描述

    Math.random()*10的意思:因为random的取值范围是[0,1),所以0x10=0,1x10=10;取的是0-10之间的数字。

    在这里插入图片描述

    二、Math.floor()是向下取整数(向越小的值方向取值),即将小数点后面的数字全部省去;如果是个整数就取它本身的值:

    // 向越小的值方向取值
    Math.floor(1.222)       // 1
    Math.floor(1.9999999)  // 1
    Math.floor(1)          // 1
    Math.floor(-1)        // -1
    Math.floor(-1.222)    // -2
    

    三、获取x到y的随机整数,包含xy,用Math.round(),公式:

    Math.round(Math.random()*(y-x)+x);

    例如获取0-10

    <div class="bg" @click="cssChange"> </div>
    
    cssChange(){					
    		console.log(Math.round(Math.random()*(10-0)+0));
    		
    	}
    

    在这里插入图片描述

    四、用Math.floor()取x到y的值,包含xy,公式:

    Math.floor(y+1-Math.random()*(y+1-x))

    例如:取5-7

    methods:{
    				cssChange(){										
    					console.log(Math.floor(8-Math.random()*(8-5)));
    				}
    			}
    

    在这里插入图片描述

    展开全文
  • Math.round() 就是数学中的四舍五入,举例: System.out.println("Math.round(1.2)="+Math.round(1.2)); System.out.println("Math.round(1.5)="+Math.round(1.5)); System.out.println("Math.round(1.7)="+Math....

    Math.round()
    就是数学中的四舍五入,举例:

    System.out.println("Math.round(1.2)="+Math.round(1.2));
    System.out.println("Math.round(1.5)="+Math.round(1.5)); 
    System.out.println("Math.round(1.7)="+Math.round(1.7));
    System.out.println("Math.round(-1.2)="+Math.round(-1.2));
    System.out.println("Math.round(-1.5)="+Math.round(-1.5));
    System.out.println("Math.round(-1.7)="+Math.round(-1.7));
    

    结果输出为:

    Math.round(1.2)=1
    Math.round(1.5)=2
    Math.round(1.7)=2
    Math.round(-1.2)=-1
    Math.round(-1.5)=-1
    Math.round(-1.7)=-2
    

    Math.ceil()
    ceil英文是天花板的意思,就是对上取整,举例:

    System.out.println("Math.ceil(1.2)="+Math.ceil(1.2));
    System.out.println("Math.ceil(1.5)="+Math.ceil(1.5));
    System.out.println("Math.ceil(1.7)="+Math.ceil(1.7));
    System.out.println("Math.ceil(-1.2)="+Math.ceil(-1.2));
    System.out.println("Math.ceil(-1.5)="+Math.ceil(-1.5));
    System.out.println("Math.ceil(-1.7)="+Math.ceil(-1.7));
    

    结果输出为:

    Math.ceil(1.2)=2.0
    Math.ceil(1.5)=2.0
    Math.ceil(1.7)=2.0
    Math.ceil(-1.2)=-1.0
    Math.ceil(-1.5)=-1.0
    Math.ceil(-1.7)=-1.0
    

    Math.floor()
    floor就是地板的意思,就是对下取整,举例:

    System.out.println("Math.floor(1.2)="+Math.floor(1.2));
    System.out.println("Math.floor(1.5)="+Math.floor(1.5));
    System.out.println("Math.floor(1.7)="+Math.floor(1.7));
    System.out.println("Math.floor(-1.2)="+Math.floor(-1.2));
    System.out.println("Math.floor(-1.5)="+Math.floor(-1.5));
    System.out.println("Math.floor(-1.7)="+Math.floor(-1.7));
    

    结果输出为:

    Math.floor(1.2)=1.0
    Math.floor(1.5)=1.0
    Math.floor(1.7)=1.0
    Math.floor(-1.2)=-2.0
    Math.floor(-1.5)=-2.0
    Math.floor(-1.7)=-2.0
    

    Math.abs()
    在数学中是指取绝对值,举例:

    System.out.println("Math.abs(1.2)="+Math.abs(1.2));
    System.out.println("Math.abs(1.5)="+Math.abs(1.5));
    System.out.println("Math.abs(1.7)="+Math.abs(1.7));
    System.out.println("Math.abs(-1.2)="+Math.abs(-1.2));
    System.out.println("Math.abs(-1.5)="+Math.abs(-1.5));
    System.out.println("Math.abs(-1.7)="+Math.abs(-1.7));
    

    结果输出为:

    Math.abs(1.2)=1.2
    Math.abs(1.5)=1.5
    Math.abs(1.7)=1.7
    Math.abs(-1.2)=1.2
    Math.abs(-1.5)=1.5
    Math.abs(-1.7)=1.7
    
    展开全文
  • .NET中的Math.Floor()和Math.Truncate()什么区别?

    .NET中的Math.Floor()Math.Truncate()什么区别?


    #1楼

    Math.Floor()符合IEEE标准754第4节“向负无穷大” Math.Floor()

    Math.Truncate()Math.Truncate()入到最接近零的整数”。


    #2楼

    Math.Floor() :返回小于或等于指定的双精度浮点数的最大整数。

    Math.Round() :将值舍入为最接近的整数或指定的小数位数。


    #3楼

    一些例子:

    Round(1.5) = 2
    Round(2.5) = 2
    Round(1.5, MidpointRounding.AwayFromZero) = 2
    Round(2.5, MidpointRounding.AwayFromZero) = 3
    Round(1.55, 1) = 1.6
    Round(1.65, 1) = 1.6
    Round(1.55, 1, MidpointRounding.AwayFromZero) = 1.6
    Round(1.65, 1, MidpointRounding.AwayFromZero) = 1.7
    
    Truncate(2.10) = 2
    Truncate(2.00) = 2
    Truncate(1.90) = 1
    Truncate(1.80) = 1
    

    #4楼

    它们在功能上等同于正数。 不同之处在于它们如何处理负数。

    例如:

    Math.Floor(2.5) = 2
    Math.Truncate(2.5) = 2
    
    Math.Floor(-2.5) = -3
    Math.Truncate(-2.5) = -2
    

    MSDN链接: - Math.Floor方法 - Math.Truncate方法

    PS小心Math.Round它可能不是你所期望的。

    要获得“标准”舍入结果,请使用:

    float myFloat = 4.5;
    Console.WriteLine( Math.Round(myFloat) ); // writes 4
    Console.WriteLine( Math.Round(myFloat, 0, MidpointRounding.AwayFromZero) ) //writes 5
    Console.WriteLine( myFloat.ToString("F0") ); // writes 5
    

    #5楼

    Math.Floor向下Math.CeilingMath.Ceiling向上Math.FloorMath.Ceiling向下Math.Ceiling Math.Truncate为零。 因此, Math.Truncate就像Math.Floor为正数,和类似Math.Ceiling为负数。 这是参考

    为了完整性, Math.Round入到最接近的整数。 如果数字正好位于两个整数之间,那么它将朝向偶数。 参考。

    另见: Pax Diablo的回答 。 强烈推荐!


    #6楼

    math.floor()

    返回小于或等于指定数字的最大整数。

    MSDN system.math.floor

    math.truncate()

    计算数字的整数部分。

    MSDN system.math.truncate

    Math.Floor(2.56) = 2
    Math.Floor(3.22) = 3
    Math.Floor(-2.56) = -3
    Math.Floor(-3.26) = -4
    
    Math.Truncate(2.56) = 2
    Math.Truncate(2.00) = 2
    Math.Truncate(1.20) = 1
    Math.Truncate(-3.26) = -3
    Math.Truncate(-3.96) = -3
    

    另外Math.Round()

       Math.Round(1.6) = 2
       Math.Round(-8.56) = -9
       Math.Round(8.16) = 8
       Math.Round(8.50) = 8
       Math.Round(8.51) = 9
    

    #7楼

    左边是Math.floor sliiiide ...
    Math.ceil sliiiide向右...
    Math.truncate criiiiss crooooss(地板/ ceil始终朝向0)
    Math.round cha cha,真正流畅...(转到最近的一侧)

    我们去上班吧! (⌐□□_)

    在左边...... Math.floor
    把它收回你们现在... --
    这次两次跳...... -=2

    每个人都拍手✋✋

    你有多低? 你可以低调吗? 一路到floor

    if (this == "wrong")
        return "i don't wanna be right";
    

    Math.truncate(x)也与int(x)相同。
    通过删除正或负分数,您总是朝0。


    #8楼

    Mat.floor()将始终向下舍入,即。,它返回LESSER整数。 而round()将返回NEAREST整数


    #9楼

    请按照以下链接获取MSDN描述:

    • Math.Floor ,向下Math.Floor负无穷大。
    • Math.Ceiling ,向正无穷大四舍五入。
    • Math.Truncate ,向上或向下Math.Truncate为零。
    • Math.RoundMath.Round入到最接近的整数或指定的小数位数。 您可以指定行为,如果它在两种可能性之间完全等距,例如舍入使得最后一位数是偶数(“ Round(2.5,MidpointRounding.ToEven) ”变为2)或者它更远离零(“ Round(2.5,MidpointRounding.AwayFromZero) “成为3)。

    以下图表和表格可能会有所帮助:

    -3        -2        -1         0         1         2         3
     +--|------+---------+----|----+--|------+----|----+-------|-+
        a                     b       c           d            e
    
                           a=-2.7  b=-0.5  c=0.3  d=1.5  e=2.8
                           ======  ======  =====  =====  =====
    Floor                    -3      -1      0      1      2
    Ceiling                  -2       0      1      2      3
    Truncate                 -2       0      0      1      2
    Round (ToEven)           -3       0      0      2      3
    Round (AwayFromZero)     -3      -1      0      2      3
    

    请注意, Round比它看起来更强大,只是因为它可以舍入到特定的小数位数。 所有其他的总是小数点零。 例如:

    n = 3.145;
    a = System.Math.Round (n, 2, MidpointRounding.ToEven);       // 3.14
    b = System.Math.Round (n, 2, MidpointRounding.AwayFromZero); // 3.15
    

    使用其他函数,您必须使用乘法/除法技巧来实现相同的效果:

    c = System.Math.Truncate (n * 100) / 100;                    // 3.14
    d = System.Math.Ceiling (n * 100) / 100;                     // 3.15
    

    #10楼

    Math.Floor()向负无穷大Math.Floor()

    Math.Truncate向上或向下Math.Truncate为零。

    例如:

    Math.Floor(-3.4)     = -4
    Math.Truncate(-3.4)  = -3
    

    Math.Floor(3.4)     = 3
    Math.Truncate(3.4)  = 3
    
    展开全文
  • Math.floorMath.ceil

    2021-02-13 08:44:29
    Math.floor():舍去小数,仅取整数部分 Math.ceil(12.1)=12 Math.ceil(12.8)=12 Math.ceil(12.0)=12 123 Math.ceil():将小数部分一律向整数部分进位 简单来说,当小数部分为非0值时,进为1.0 Math.ceil(12.1...
  • math.floor javascript

    2022-04-07 17:05:44
    Math.floor() 返回小于或等于一个给定数字的最大整数。语法 Math.floor(x) 参数x 一个数字。 返回值 一个表示小于或等于指定数字的最大整数的数字。 由于 floorMath的一个静态方法,你总是应该像这样使用...
  • 今天遇到一个问题:如何随机生成50-100之间的保留两位小数的数字。 所以打算总结一下 一、定义 函数 含义 形式 Math.ceil() 向上取整数,即返回大于... Math.floor() 向下取整,即返回小于等于(...
  • 1、Math.ceil()ceil表示“天花板”,向上取整;相当于水平数轴,向左取整... //-2.0 ceil天花板 水平数轴向左取整2、Math.floor()floor表示“地板”,向下取整;相当于水平数轴,向右取整Math.floor(2.6); //2.0 ...
  • JavaScript Math.floor 方法 Math.floor 方法用于对数值向下取整,即得到小于或等于该数值的最大整数。语法如下: Math.floor(x) 参数说明: 参数 说明 x 必需。必须是一个数值。 提示:该方法与 Math.ceil ...
  • Math.round(),Math.ceil(),Math.floor()的区别

    万次阅读 多人点赞 2019-07-23 11:49:42
    1、Math.round() “四舍五入”,该函数返回的是一个四舍五入后的的整数 double d = 3.1415926; double d2 = 18.58; double d3 = -15.23; double d4 = -16.85; long round1 = Math.round(d); //...
  • Java Math.floor() 方法

    2021-02-12 16:18:13
    Java Math.floor() 方法java.lang.Math.floor() 返回最大的(最接近正无穷大)double值,该值小于或等于参数,并等于某个整数。1 语法public static double floor(double a)2 参数x :参数值3 返回值返回最大的(最接近...
  • 问题出现: 在项目中之前完成的一个精灵汇总属性展示的需求,今天测试突然提了个bug: 如 某A号精灵 攻击力为 :20.50 某B号精灵 攻击力为 :17.98 ...local num2 = math.floor(num1 * 100)/100 print("num2 = "..num2)
  • Math.round(Math.random()*100000)=66666 1.Math.random():得到0~1之间的随机数 2.Math.round():四舍五入 例: 小数点后第一位<5 正数:Math.round(10.46)=10 负数:Math.round(-10.46)=-10 小数点后第一位>...
  • 1. Math.Ceiling(),只要有小数就加1(小数部分不为0) 例如: Math.Ceiling(0.0) -> 0 Math.Ceiling(0.1) -> 1 Math.Ceiling(0.2) -> 1 Math.Ceiling(0.3) -> 1 Math.Ceiling(0.4) -> 1 Math.Ceiling...
  • JavaScript 的 Math.floor() 函数

    千次阅读 2021-09-11 20:10:06
    Math.floor()返回小于或等于一个给定数字的最大整数。 可以理解Math.floor()为向下取整。 与其相对的是Math.ceil(),这个是向上取整。 如下面的代码: Math.floor( 45.95); // 45 Math.floor( 45.05); // 45 ...
  • math.floor用法

    千次阅读 2021-05-23 14:15:58
    math.floor:取数字的近似值 代码示例: import math print('-3.88的近似值',math.floor(-3.88)) print('3.88的近似值:',math.floor(3.88)) 输出: -3.88的近似值 -4 3.88的近似值: 3
  • 带有Python示例的math.floor()方法

    千次阅读 2021-03-17 01:46:04
    Python math.floor() 方法math.floor()方法是数学模块的库方法,用于获取给定数字的下限值,用于获取数字的下限值,它接受数字/数字表达式并返回最大整数(整数)值,不大于数字。注意:如果数字是整数值,则对于浮点...
  • Math.floor()、Math.ceil()和Math.round()都是对浮点数取整(floor和ceil返回不带小数的double,round返回long) floor字面意思为地板,返回的是小于或等于该数值的最大的整数 ceil字面意思是天花板,返回的是大于...
  • methods:{ changeMood(){ const arr = ['happy','sad','normal'] this.mood = arr[Math.floor(Math.random()*3)] } },
  • math.floor()和math.ceil()的使用 math.floor是向下取整数: math.ceil是向上取整数:
  • Math.Floor()符合IEEE标准754第4节“向负无穷大”Math.Floor()。 Math.Truncate()“Math.Truncate()入到最接近零的整数”。
  • 理解math.floor(math.random() * (max - min + 1)) + min的含义 math.floor:向下取整 math.random:伪随机数在范围从0到小于1,也就是说,从0(包括0)往上,但是不包括1(排除1)。简化 0≤math.random<1 。 ...
  • Math.round可以简单地理解为“四舍六入”,例如: Math.round(10.45)=10 Math.round(10.65)=11 Math.round(-10.45)=10 Math.round(-10.65)=11 但是当赋值数小数点后第一位为5时,即x.5时,正数整数位+1,负数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 172,777
精华内容 69,110
关键字:

math.floor