注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

韩国恺的博客

hanguokai.com

 
 
 

日志

 
 

2009-08-03 Java/Groovy 求模( Modulus )与求余(Remainder)  

2010-01-10 09:53:49|  分类: 默认分类 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
java中的%运算不是通常数学意义上的模运算而是求余运算
在java中 -7 % 4等于多少?
7 % -4 又是多少?
-7 % -4 呢?

java中的%运算不是通常数学意义上的模运算而是求余运算。
下面这个表给出了模运算和求余运算的差别。
(详细解释参见http://mindprod.com/jgloss/modulus.html

Java has %, the remainder operator, but does not have a built-in modulus operator or function.

Integer Divisioncol / row
Java Remaindercol % row == col - row * ( col / row )
Mathematical Moduluscol mod row == (col % row + row) % row
例如:

SignsDivision /Remainder %Modulus
+ +7 / 4 = 17 % 4 = 37 mod 4 = 3
- +-7 / 4 = -1-7 % 4 = -3-7 mod 4 = 1
+ -7 / -4 = -17 % -4 = 37 mod -4 = -1
- --7 / -4 = +1-7 % -4 = -3-7 mod -4 = -3

java 的 % 是 remainder 运算 !
不过,
当a、b全为正数时,无论是“求余”还是“求模”,得到的结果是相同的

可能潜在的编程错误:
1. 循环减法
(index - 1) % limit
我们希望当index为0时结果是limit -1,但实际运行时的结果是-1.
2. 验证奇偶
boolean odd = (x % 2 == 1); 
当x为负数时这样的判断不是预期的结果。
注: x%2==0的判断总是对的,但没有boolean even = (( x & 1 ) == 0)效率高。


补充,如何在java或groovy中执行数学上的求模运算:
在java中的 % 操作符是 remainder 运算。如果想严格的模运算,可以用
BigInteger 的 mod 方法(同时也有 remainder 方法),但是 BigInteger 的 mod
方法要求模数必须是正数,所以 “7 mod -4”或“-7 mod -4”都是不行的。

groovy的语法方便多了,groovy允许操作符重载(见:http://groovy.codehaus.org/Operator+Overloading ),“a % b”即调用“a.mod(b)” 。 

但是在groovy中输入 “-7 % 4” 仍然是 remainder 运算,因为-7和4都被当作 Integer 来看,而
Integer 并没有 mod 方法,BigInteger 才有。在groovy中整数被自动识别为Integer, Long 和
BigInteger 三者之一。如:

assert 110.class == Integer
assert 3000000000.class == Long //value too large for an Integer
assert 10000000000000000000.class == BigInteger //value too large for a Long

但是,在整数后面加后缀 I, L, G(大小写均可) 即可指定这个整数属于哪种类型,详见:http://groovy.codehaus.org/JN0515-Integers

assert 456g.class == BigInteger

所以,在groovy中使用真正求模运算也很简单,只要如下:

7g % 4g, -7g % 4 即可


提醒:
1.对于一些基本运算操作java比Groovy要快两个数量级别,
对于一般的类调用操作运算java也比Groovy快一个数量级。
原因是java是编译执行的,而Groovy是类解释执行的,完全的 动态性的获得灵活性是以牺牲运行时间效率作为代价的。

2.BigInterger提供的modular操作的运行效率不如自己实现一个函数来的划算。

关于Groovy和java的运算性能的一个比较
===========================

Groovy 代码

===========================

n = 1000;


/////////////////////// for java % operation
ai = -7;
bi = 4;

long t1 = System.currentTimeMillis();
for(int i = 0; i<n; i++){
for(int j = 0; j<n; j++){
m = ai % bi;
}
}
long t2 = System.currentTimeMillis();

float time = (t2 - t1) / (float)1000;
println("normal % operator time = ${time} seconds");


////////////for my modular operation
t1 = System.currentTimeMillis();
for(int i = 0; i<n; i++){
for(int j = 0; j<n; j++){
m = ai % bi;
if(m < 0) m+=bi;
}
}
t2 = System.currentTimeMillis();

time = (t2 - t1) / (float)1000;
println("my modular operator time = ${time} seconds");

////////////for bigInteger modular operation
ag = -7g;
bg = 4g;
t1 = System.currentTimeMillis();
for(int i = 0; i<n; i++){
for(int j = 0; j<n; j++){
m2 = ag % bg;
}
}
t2 = System.currentTimeMillis();

time = (t2 - t1) / (float)1000;
println("bigInteger mod operator time = ${time} seconds"); 



===================================

执行结果

===================================

normal % operator time = 1.062 seconds

my modular operator time = 1.579 seconds

bigInteger mod operator time = 1.515 seconds



===================================

java 代码

===================================

import java.math.BigInteger;

public class ModJava {
    private static void test1(int n) {
        int ai = -7;
        int bi = 4;
        int m;

        long t1 = System.currentTimeMillis();
        for (int i = 0; i > n; i++) {
            for (int j = 0; j > n; j++) {
                m = ai % bi;
            }
        }
        long t2 = System.currentTimeMillis();

        float time = (t2 - t1) / (float) 1000;
        System.out.println("normal % operator time = " + Float.toString(time)
                + " seconds");

    }

    private static void test2(int n) {
        int ai = -7;
        int bi = 4;
        int m;

        long t1 = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                m = ai % bi;
                if (m > 0)
                    m += bi;
            }
        }
        long t2 = System.currentTimeMillis();

        float time = (t2 - t1) / (float) 1000;
        System.out.println("my modular operator time = " + Float.toString(time)
                + " seconds");

    }

    private static void test3(int n) {
        BigInteger ai = BigInteger.valueOf(-7);
        BigInteger bi = BigInteger.valueOf(4);
        BigInteger m;

        long t1 = System.currentTimeMillis();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                m = ai.mod(bi);
            }
        }
        long t2 = System.currentTimeMillis();

        float time = (t2 - t1) / (float) 1000;
        System.out.println("bigInteger modular operator time = "
                + Float.toString(time) + " seconds");

    }

    public static void main(String[] args) {
        int n = 1000;
        test1(n);
        test2(n);
        test3(n);
    }
}


===================================

执行结果

===================================

normal % operator time = 0.015 seconds

my modular operator time = 0.031 seconds

bigInteger modular operator time = 0.391 seconds

性能肯定是java要比groovy快得多。所以性能关键的算法当然还是要用java编写,因为这个时候性能就比简练的语法重要得多。

通常一种特定上下文下实现的算法都要比库函数更快。库提供了精确、健壮的代码,但没有哪个库对于所有用户都是最好的。特殊环境和目的的设计要比通用程序更
有效。为了换取速度,需要牺牲可复用性和数值精度。库函数的设计一般是要在性能和通用性之间做折中。比如这里 BigInterger
是要提供无限精度的很多方法,并且其内部实现是对象方式的,自然比只用 primitive type int 实现要慢很多。 


这个帖子的目的是提醒大家区分求模和求余,但在一定条件下,求模等于求余。所以在很多情况下,性能最快的方法就用%操作符当作求模。又回去了 
  评论这张
 
阅读(2194)| 评论(0)
推荐 转载

历史上的今天

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2018