精华内容
下载资源
问答
  • JAVA Math函数向上取整和向下取整

    万次阅读 2017-11-02 13:31:57
    JAVA Math函数向上取整和向下取整,向上取整用Math.ceil(double a)向下取整Math.floor(double a)举例:double a=35; double b=20; double c = a/b; System.out.println(“c===>”+c); //1.75 System.out....

    JAVA Math函数向上取整和向下取整,

    向上取整用Math.ceil(double a)

    向下取整用Math.floor(double a)

    举例:

    double a=35;
    double b=20;
    double c = a/b;
    System.out.println(“c===>”+c); //1.75
    System.out.println(“c===>”+Math.ceil(c)); //2.0
    System.out.println(Math.floor(c)); //1.0

    展开全文
  • 写在前面,最最常用几个方法:绝对值:Math.abs(x)最大值:Math.max([x[, y[, …]]])最小值:Math.min([x[, y[, …]]])随机值:Math.random()向上取整:Math.ceil(x)向下取整Math.floor(x)四舍五入:Math.round(x)...

    写在前面,最最常用几个方法:

    绝对值:Math.abs(x)

    最大值:Math.max([x[, y[, …]]])

    最小值:Math.min([x[, y[, …]]])

    随机值:Math.random()

    向上取整:Math.ceil(x)

    向下取整:Math.floor(x)

    四舍五入:Math.round(x)

    1.概述

    Math是一个内置对象,它拥有一些数学常数属性和数学函数方法。Math 不是一个函数对象。Math 用于 Number 类型。

    Math 不是一个构造器。Math 的所有属性与方法都是静态的。Math 的常量是使用 JavaScript 中的全精度浮点数来定义的。

    2.方法

    需要注意的是,三角函数 sin()、cos()、tan()、asin()、acos()、atan() 和 atan2()返回的值是弧度而非角度。

    若要转换,弧度除以 (Math.PI / 180) 即可转换为角度,同理,角度乘以这个数则能转换为弧度。

    很多 Math 函数都有一个精度,而且这个精度在不同实现中也是不相同的。这意味着不同的浏览器会给出不同的结果,甚至,在不同的系统或架构下,相同的 JS 引擎也会给出不同的结果!

    2.1 常用方法

    Math.abs(x)   返回一个数的绝对值。

    Math.abs('-1');     // 1

    Math.abs(-2);       // 2

    Math.abs(null);     // 0

    Math.abs("string"); // NaN

    Math.abs();         // NaN

    Math.ceil(x)   返回大于一个数的最小整数,即一个数向上取整后的值。

    Math.ceil(.95);        // expected output: 1

    Math.ceil(4);        // expected output: 4

    Math.ceil(7.004);    // expected output: 8

    Math.ceil(-7.004);    // expected output: -7

    Math.floor(x)   返回小于一个数的最大整数,即一个数向下取整后的值。

    Math.floor( 45.95);     // 45

    Math.floor( 45.05);        // 45

    Math.floor( 4 );         // 4

    Math.floor(-45.05);     // -46

    Math.floor(-45.95);     // -46

    Math.max([x[, y[, …]]])   返回零到多个数值中最大值。

    Math.max(10, 20);   //  20

    Math.max(-10, -20); // -10

    Math.max(-10, 20);  //  20

    Math.min([x[, y[, …]]])   返回零到多个数值中最小值。

    Math.max(10, 20);   //  10

    Math.max(-10, -20); // -20

    Math.max(-10, 20);  //  -10

    Math.random()   返回一个 0 到 1 ([0, 1))之间的伪随机数。

    Math.random();            // eg:0.3807786079066584

    Math.round(x)   返回四舍五入后的整数。

    Math.round(20.49);        // 20

    Math.round(20.5);        // 21

    Math.round(-20.5);        // -20

    Math.round(-20.51);        // -21

    2.2 其余方法

    Math.acos(x)   返回一个数的反余弦值。

    Math.acos(-2);  // NaN

    Math.acos(-1);  // 3.141592653589793

    Math.acos(0);   // 1.5707963267948966

    Math.acos(0.5); // 1.0471975511965979

    Math.acos(1);   // 0

    Math.acos(2);   // NaN

    对于小于 -1 或大于 1 的值,Math.acos 返回 NaN。

    Math.acosh(x)   返回一个数的反双曲余弦值。

    Math.acosh(0.5); // NaN

    Math.acosh(1);   // 0

    Math.acosh(2);   // 1.3169578969248166

    当参数小于1时, Math.acosh()将返回NaN。

    Math.asin(x)   返回一个数的反正弦值。

    Math.asin(-2);  // NaN

    Math.asin(-1);  // -1.5707963267948966 (-pi/2)

    Math.asin(0);   // 0

    Math.asin(0.5); // 0.5235987755982989

    Math.asin(1);   // 1.570796326794897 (pi/2)

    Math.asin(2);   // NaN

    对于小于 -1 或大于 1 的参数值,Math.asin 返回 NaN。

    Math.asinh(x)   返回一个数的反双曲正弦值。

    Math.asinh(1);  // 0.881373587019543

    Math.asinh(0);  // 0

    Math.atan(x)   返回一个数的反正切值。

    Math.atan(1);  // 0.7853981633974483

    Math.atan(0);  // 0

    Math.atanh(x)   返回一个数的反双曲正切值。

    Math.atanh(-2);  // NaN

    Math.atanh(-1);  // -Infinity

    Math.atanh(0);   // 0

    Math.atanh(0.5); // 0.5493061443340548

    Math.atanh(1);   // Infinity

    Math.atanh(2);   // NaN

    对于大于1或是小于-1的值,函数返回 NaN 。

    Math.atan2(y, x)   返回 y/x 的反正切值。

    Math.atan2(90, 15) // 1.4056476493802699

    Math.atan2(15, 90) // 0.16514867741462683

    Math.atan2( ±0, -0 )               // ±PI.

    Math.atan2( ±0, +0 )               // ±0.

    Math.atan2( ±0, -x )               // ±PI for x > 0.

    Math.atan2( ±0, x )                // ±0 for x > 0.

    Math.atan2( -y, ±0 )               // -PI/2 for y > 0.

    Math.atan2( y, ±0 )                // PI/2 for y > 0.

    Math.atan2( ±y, -Infinity )        // ±PI for finite y > 0.

    Math.atan2( ±y, +Infinity )        // ±0 for finite y > 0.

    Math.atan2( ±Infinity, x )         // ±PI/2 for finite x.

    Math.atan2( ±Infinity, -Infinity ) // ±3*PI/4.

    Math.atan2( ±Infinity, +Infinity ) // ±PI/4.

    Math.cbrt(x)   返回一个数的立方根。cbrt 是 “cube root” 的缩写, 意思是立方根。

    Math.cbrt(NaN); // NaN

    Math.cbrt(-1); // -1

    Math.cbrt(-0); // -0

    Math.cbrt(-Infinity); // -Infinity

    Math.cbrt(0); // 0

    Math.cbrt(1); // 1

    Math.cbrt(Infinity); // Infinity

    Math.cbrt(null); // 0

    Math.cbrt(2);  // 1.2599210498948734

    Math.clz32(x) 返回一个 32 位整数的前导零的数量。

    Math.clz32(1)                // 31

    Math.clz32(1000)             // 22

    Math.clz32()                 // 32

    [NaN, Infinity, -Infinity, 0, -0, null, undefined, "foo", {}, []].filter(function (n) {

    return Math.clz32(n) !== 32

    })                           // []

    Math.clz32(true)             // 31

    Math.clz32(3.5)

    Math.cos(x) 返回一个数的余弦值。

    Math.cos(0);           // 1

    Math.cos(1);           // 0.5403023058681398

    Math.cos(Math.PI);     // -1

    Math.cos(2 * Math.PI); // 1

    Math.cosh(x) 返回一个数的双曲余弦值。可通过函数模拟实现:

    Math.cosh = Math.cosh || function(x) {

    var y = Math.exp(x);

    return (y + 1 / y) / 2;

    };

    Math.cosh(0);  // 1

    Math.cosh(1);  // 1.5430806348152437

    Math.cosh(-1); // 1.543080634815243

    Math.exp(x) 返回欧拉常数的参数次方,Ex,其中 x 为参数,E 是欧拉常数(2.718…,自然对数的底数)。

    Math.exp(-1); // 0.36787944117144233

    Math.exp(0);  // 1

    Math.exp(1);  // 2.718281828459045

    Math.expm1(x) 返回 exp(x) - 1 的值。其中 x 是该函数的参数, E 是自然对数的底数 2.718281828459045.

    Math.expm1(1)     // 1.7182818284590453

    Math.expm1(-38)   // -1

    Math.expm1("-38") // -1

    Math.expm1("foo") // NaN

    Math.fround(x)   返回最接近一个数的单精度浮点型表示。

    数字1.5可以在二进制数字系统中精确表示,32位和64位的值相同:

    Math.fround(1.5); // 1.5

    Math.fround(1.5) === 1.5; // true

    但是,数字1.337却无法在二进制数字系统中精确表示,所以32位和64位的值是不同的:

    Math.fround(1.337); // 1.3370000123977661

    Math.fround(1.337) === 1.337; // false

    在某些精度不高的场合下,可以通过将二个浮点数转换成32位浮点数进行比较,以解决64位浮点数比较结果不正确的问题:

    0.1 + 0.2 == 0.3;    //false

    function equal(v1, v2) {

    return Math.fround(v1) == Math.fround(v2);

    }

    equal(0.1 + 0.2, 0.3);   //true

    Math.hypot([x[, y[, …]]])   返回其所有参数平方和的平方根。

    Math.hypot(3, 4);        // 5

    Math.hypot(3, 4, 5);     // 7.0710678118654755

    Math.hypot();            // 0

    Math.hypot(NaN);         // NaN

    Math.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN

    Math.hypot(3, 4, '5');   // 7.0710678118654755, +'5' => 5

    Math.hypot(-3);          // 3, the same as Math.abs(-3)

    Math.imul(x, y)   返回 32 位整数乘法的结果。

    Math.log(x)   返回一个数的自然对数(㏒e,即 ㏑)。

    Math.log(-1); // NaN, out of range

    Math.log(0); // -Infinity

    Math.log(1); // 0

    Math.log(10); // 2.302585092994046

    Math.log1p(x)   返回一个数加 1 的和的自然对数(㏒e,即 ㏑)。

    Math.log1p(Math.E-1)  // 1

    Math.log1p(0)         // 0

    Math.log1p("0")       // 0

    Math.log1p(-1)        // -Infinity

    Math.log1p(-2)        // NaN

    Math.log1p("foo")     // NaN

    如果参数的值小于 -1, 则返回 NaN。

    Math.log10(x)   返回一个数以 10 为底数的对数。

    Math.log10(10)   // 1

    Math.log10(100)  // 2

    Math.log10("100")// 2

    Math.log10(1)    // 0

    Math.log10(0)    // -Infinity

    Math.log10(-2)   // NaN

    Math.log10("foo")// NaN

    Math.log2(x)   返回一个数以 2 为底数的对数。

    Math.log2(2)     // 1

    Math.log2(1024)  // 10

    Math.log2(1)     // 0

    Math.log2(0)     // -Infinity

    Math.log2(-2)    // NaN

    Math.log2("1024")// 10

    Math.log2("foo") // NaN

    Math.pow(x, y)   返回一个数的 y 次幂。

    Math.pow(7, 3);        // 343

    Math.pow(4, 0.5);    // 2

    Math.pow(7, -2);    // 0.02040816326530612 (1/49)

    Math.pow(-7, 0.5);    // NaN

    Math.random()   返回一个 0 到 1 ([0, 1))之间的伪随机数。

    Math.random();            // eg:0.3807786079066584

    Math.sign(x)   返回一个数的符号,得知一个数是正数、负数还是 0。此函数共有5种返回值, 分别是 1, -1, 0, -0, NaN. 代表的各是正数, 负数, 正零, 负零, NaN。

    Math.sign(3);     //  1

    Math.sign(-3);    // -1

    Math.sign("-3");  // -1

    Math.sign(0);     //  0

    Math.sign(-0);    // -0

    Math.sign(NaN);   // NaN

    Math.sign("foo"); // NaN

    Math.sign();      // NaN

    Math.sin(x)   返回一个数的正弦值。

    Math.sin(0);           // 0

    Math.sin(1);           // 0.8414709848078965

    Math.sin(Math.PI / 2); // 1

    Math.sinh(x)   返回一个数的双曲正弦值。 双曲正弦的图像如下:

    Math.sinh(0)      // 0

    Math.sinh(1)      // 1.1752011936438014

    Math.sinh("-1")   // -1.1752011936438014

    Math.sinh("foo")  // NaN

    Math.sqrt(x)   返回一个数的平方根。

    Math.sqrt(9); // 3

    Math.sqrt(2); // 1.414213562373095

    Math.sqrt(1);  // 1

    Math.sqrt(0);  // 0

    Math.sqrt(-1); // NaN

    Math.sqrt(-0); // -0

    Math.tan(x) 返回一个数的正切值。 Math.tanh(x)   返回一个数的双曲正切值。

    Math.tanh(0);        // 0

    Math.tanh(Infinity); // 1

    Math.tanh(1);        // 0.7615941559557649

    Math.toSource()   返回字符串 “Math”。 Math.trunc(x)   返回一个数的整数部分,仅仅是删除掉数字的小数部分和小数点,不管参数是正数还是负数。传入该方法的参数会被隐式转换成数字类型。

    Math.trunc(13.37)    // 13

    Math.trunc(42.84)    // 42

    Math.trunc(0.123)    //  0

    Math.trunc(-0.123)   // -0

    Math.trunc("-1.123") // -1

    Math.trunc(NaN)      // NaN

    Math.trunc("foo")    // NaN

    Math.trunc()         // NaN

    3.属性

    Math.E   欧拉常数,也是自然对数的底数,约等于 2.718。 Math.LN2   2 的自然对数,约等于 0.693。 Math.LN10   10 的自然对数,约等于 2.303。 Math.LOG2E   以 2 为底的 E 的对数,约等于 1.443。 Math.LOG10E   以 10 为底的 E 的对数,约等于 0.434。 Math.PI   圆周率,一个圆的周长和直径之比,约等于 3.14159。 Math.SQRT1_2   二分之一 ½ 的平方根,同时也是 2 的平方根的倒数,约等于 0.707。 Math.SQRT2   2 的平方根,约等于 1.414。

    展开全文
  • 关于数字的处理(四舍五入,向上取整,向下取整。。)在vue项目中可以新建一个filter.js的文件 在文件中将这些过滤全部写进去,再在页面进行引用1、时分秒的显示格式 00:00:00export const timeFilter = val => {...

    关于数字的处理(四舍五入,向上取整,向下取整。。)

    在vue项目中可以新建一个filter.js的文件 在文件中将这些过滤全部写进去,再在页面进行引用

    1、时分秒的显示

    格式 00:00:00

    export const timeFilter = val => {

    function p(t) {

    return t < 10 ? ‘0’ + t: t;

    }

    var h = Math.floor(val/1000/60/60);

    var m = Math.floor(val/1000/60%60);

    var s = Math.floor(val/1000%60);

    var str = p(h) + ‘:’ + p(m) + ‘:’ + p(s);

    return str

    }

    使用:{{timeFilter(fileInfo.needTime) || ‘’}}

    2、向下取整的函数

    Math.floor();

    例如:Math.floor( 23.2222222); // 23

    3、向上取整

    Math.ceil();

    例如: Math.ceil(23.333333); // 24

    4、四舍五入

    Math.round();

    例如:Math.round(23.33333); // 23

    5、四舍五入取n位小数,运算后得到的是字符串

    ().toFixed(n); // 取小数点后n位

    例如:(36.36498524).toFixed(3); // 36.365

    ps:虽然写的是vue,但是不仅仅vue中可以使用哦

    展开全文
  • 废话少叙,直接上code: 首先,不得不提醒大家一个容易被忽视或者搞混的问题——一般的,0.5这种末尾是5的小数...向上取整math.ceil() import math math.ceil(-0.5) &gt;&gt;&gt; 0 math.ceil(-...

    废话少叙,直接上code:

    首先,不得不提醒大家一个容易被忽视或者搞混的问题——一般的,0.5这种末尾是5的小数,四舍五入取整应进位。这个进位的意思是:-0.5 → -1;0.5 → 1.即正负情况不同,都向着远离0,使得绝对值更大的方向进位

    • 向上取整:math.ceil()
      import math
      
      math.ceil(-0.5)
      >>> 0
      
      math.ceil(-0.9)
      >>> 0
      
      math.ceil(0.3)
      >>> 1

      如code所见,math.ceil()严格遵循向上取整,所有小数都是向着数值更大的方向取整,不论正负数都如此

    • 四舍五入:round()

      round(-2.5)
      >>> -2
      
      round(-1.5)
      >>> -2
      
      round(-0.5)
      >>> 0
      
      round(0.5)
      >>> 0
      
      round(1.5)
      >>> 2
      
      round(2.5)
      >>> 2

       如code所示,round()当不传入第二个参数时默认取整,具体就是按照四舍五入来。但值得一提的是这里对小数末尾为5的处理方法:当末尾的5的前一位为奇数:向绝对值更大的方向取整(比如-1.5、1.5处理结果);当末尾的5的前一位为偶数:去尾取整(比如-2.5,-0.5,0.5和2.5的处理结果)。

    • 向下取整:math.floor()

      math.floor(-0.3)
      >>> -1
      
      math.floor(0.9)
      >>> 0

      简单且忠实地向下取整,不再讨论

    • 两个有趣且特殊的Python取整:int()、整除"//"

      • int()

        int(-0.5)
        >>> 0
        
        int(-0.9)
        >>> 0
        
        int(0.5)
        >>> 0
        
        int(0.9)
        >>> 0

        一句话总结:int()函数是“向0取整”,取整方向总是让结果比小数的绝对值更小

      • "//"

        (-1) // 2  # -0.5
        >>> -1
        
        (-3) // 2  # -1.5
        >>> -2
        
        1 // 2    # 0.5 
        >>> 0
        
        3 // 2    # 1.5
        >>> 1

        一句话总结:“整除”符号运算将结果忠实地向下取整,与math.floor()处理结果一样

     

    总结一下:

    1. 向上取整:math.ceil()
    2. 向下取整:math.floor()、整除"//"
    3. 四舍五入:round()——奇数向远离0取整,偶数去尾取整;或言之:奇数进位,偶数去尾
    4. 向0取整:int()

    由于最近在做算法题,许多算法题都要涉及(0-1)/2这类的边界计算,这时候我们想让这个-0.5取整至0,而且想让(4-1)/2的结果1.5取整至1,即正数时向下取整,负数时向上取整,总而言之就是向0取整,这时候我们可以用int()

    展开全文
  • 在Javascript的数值运算中,很多时候需要对最后计算结果向下取整Math.floor是javascript中对计算结果向下取整的函数,它总是将数值向下舍入为最接近的整数。此外Math.ceil()函数则是javascript中向上取整函数,...
  • import math ‘python 分别使用math模块中的ceil、floor和round函数进行向上、向下、四舍五入取整:‘ math.ceil(2.7) math.floor(2.7) math.round(2.7) ... 向下取整 round: 大概的——> 四舍五入 ...
  • 数学工具类Math ...Math.floor() 向下取整 Math.round() 四舍五入 直接看代码: public class MathTool { public static void main(String[] args) { //获取绝对值 System.out.println(Math.abs(-3.14...
  • #encoding:utf-8import math#向上取整 http://www.manongjc.com/article/1335.htmlprint "math.ceil---"print "math.ceil(2.3) => ", math.ceil(2.3)print "math.ceil... ", math.ceil(2.6)#向下取整 http://www....
  • Math对象向上取整,下取整

    千次阅读 2018-10-18 23:20:53
  • 1.丢弃小数部分,保留整数部分 parseInt(5/2) 2.向上取整,有小数就整数... Math.round(5/2) 4,向下取整 Math.floor(5/2) Math 对象的方法 FF: Firefox, N: Netscape, IE: Internet Explorer 方法 描述 FF N IE abs(x)...
  • 1.丢弃小数部分,保留整数部分 parseInt(5/2) 2.向上取整,有小数就整数部分加1 ...4,向下取整 Math.floor(5/2) Math 对象的方法 FF: Firefox, N: Netscape, IE: Internet Explorer 方...
  • 在Javascript的数值运算中,很多时候需要对最后计算结果向下取整Math.floor是javascript中对计算结果向下取整的函数,它总是将数值向下舍入为最接近的整数。此外Math.ceil()函数则是javascript中向上取整函数,...
  • 向下取整向上取整

    2019-08-09 21:55:02
    我们平时用5/2=2是向下取整,而负数的话是-7/2=-3,是向上取整 在一些题目他会要求向上取整还是向下取整 可以用这个函数 函数原型 double floor(doube x);//都是double类型!!! 头文件 #include<math.h> ...
  • package roundTest; public class RoundTest { public static void main... //规则:+0.5,向下取整 System.out.println(Math.round(-1.5));//-1.5+0.5=-1,向下取整-1 System.out.println(Math.round(-1.5...
  • 主要介绍了Math.floor 方法用于对数值向下取整,即得到小于或等于该数值的最大整数,需要的朋友可以参考下
  • Math中的取整函数

    千次阅读 热门讨论 2016-05-07 18:08:57
    它们函数作用和其英文意义差不多对应,ceil是天花板的意思,该方法就表示向上取整,floor是地板的意思,该方法就表示向下取整,而round有点麻烦,是银行家舍入算法,即四舍六入五取偶。  1、ceil
  • Math中的取整方法

    2017-12-19 10:32:00
    Floor:向下取整,只取整数部分; Round:四舍六入,遇到五则取偶数; Ceiling:向上取整,只要小数部分大于等于一,均往上加一。 转载于:https://www.cnblogs.com/nora/p/8064272.html...
  • Math类的取整方法

    2015-09-29 22:39:32
    Math类中提供了三个与取整有关的方法:ceil、floor、round,这些方法的作用与它们的英文名称的含义相对应。...floor的英文意义是地板,该方法就表示向下取整Math.ceil(11.6)的结果为11,Math.ceil(-11.
  • 向下取整math.floor()、整除"//" 四舍五入:round() 向0取整:int() 注:round()——针对小数点后.5的情况:奇数向远离0取整,偶数去尾取整;或言之:奇数进位,偶数去尾。之所以出现这种情况,主要是因为存储...
  • // 5向下取整(<= 该数值的最大整数,和parseInt()一样)Math.floor(5.1234); // 5向上取整(有小数,整数部分就+1)Math.ceil(5.1234); // 6四舍五入(小数部分)Math.round(5.1234); // 5Math.round(5....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,945
精华内容 1,178
关键字:

math向下取整