Java中求Logn/log2 的精度问题

2024-04-02 19:04:59 154人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录java求Logn/log2精度例如程序如下：java 处理高精度计算使用的BigDecimal类的时候需要注意的地方：java求Logn/log2精度经过本人测试，java

java求Logn/log2精度

经过本人测试，java 中，一直到 2的492 次方（这么大的数，平时够用了）；用 Math.log(n) / Math.log(x) 公式都会产生一个整数

例如


  int x = 2 ;  
  double n = Math.pow(2, 234)
  System.out.println(Math.log(n) / Math.log(x));

输出的是 234.0

而到了 2的493次方，结果是493.00000000000006 ；所以，平时用这个公式来确定n是否是2的整数次幂足够了！

程序如下：


public class Test { 
 public static void main(String[] args) {  
 // System.out.println(Math.pow(2, 23));  
  int x = 2 ;  
  double n = Math.pow(2, 493) ;  
  System.out.println(Math.log(n) / Math.log(x));  
 }
}

java 处理高精度计算

Double.valueOf(String) and Float.valueOf(String)都会丢失精度。

为了解决这个问题，需要用到BigDecimal类。

使用的BigDecimal类的时候需要注意的地方：

1. 在实例化BigDecimal 的时候用 new BigDecimal(String) 代替new BigDecimal(double) ，new BigDecimal(float)在《Effective Java》书中有提到

2. 比较两个数的时候用compareTo 小于返回-1 ，等于返回0 ，大于返回1


import java.math.BigDecimal; 
public class ArithmeticUtil {  
     
    private static final int DEF_DIV_SCALE = 10; 
 
     
    public static double add(double v1, double v2) { 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return b1.add(b2).doubleValue(); 
    } 
   
     
    public static BigDecimal add(String v1, String v2) { 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.add(b2); 
    } 
   
     
    public static String strAdd(String v1, String v2,int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString(); 
    } 
     
    public static double sub(double v1, double v2) { 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return b1.subtract(b2).doubleValue(); 
    } 
   
     
    public static BigDecimal sub(String v1, String v2) { 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.subtract(b2); 
    } 
   
     
    public static BigDecimal round(String v, int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b = new BigDecimal(v); 
        BigDecimal one = new BigDecimal("1"); 
        return b.divide(one, scale, BigDecimal.ROUND_HALF_UP); 
    } 
   
     
    public static String strSub(String v1, String v2,int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString(); 
    } 
     
    public static double mul(double v1, double v2) { 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return b1.multiply(b2).doubleValue(); 
    } 
   
     
    public static BigDecimal mul(String v1, String v2) { 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.multiply(b2); 
    } 
   
     
    public static double mul2(double v1, double v2,int scale) { 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return  round(b1.multiply(b2).doubleValue(),scale); 
    } 
   
     
    public static String strMul2(String v1, String v2,int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString(); 
    } 
     
    public static BigDecimal div(String v1, String v2) { 
        return div(v1, v2, DEF_DIV_SCALE); 
    } 
   
     
    public static double div(double v1, double v2) { 
        return div(v1, v2, DEF_DIV_SCALE); 
    } 
 
     
    public static double div(double v1, double v2, int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
   
     
    public static BigDecimal div(String v1, String v2, int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP); 
    } 
 
     
    public static String strDiv(String v1, String v2, int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString(); 
    } 
   
     
    public static BigDecimal bigDiv(String v1, String v2, int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP); 
    } 
     
    public static BigDecimal strRemainder(String v1,String v2, int scale){ 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP); 
    } 
     
    public static String strRemainder2Str(String v1,String v2, int scale){ 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString(); 
    } 
   
     
    public static boolean strcompareTo(String v1,String v2){ 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        int bj = b1.compareTo(b2); 
        boolean res ; 
        if(bj>0) 
            res = true; 
        else 
            res = false; 
        return res; 
    } 
   
     
    public static boolean strcompareTo2(String v1,String v2){ 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        int bj = b1.compareTo(b2); 
        boolean res ; 
        if(bj>=0) 
            res = true; 
        else 
            res = false; 
        return res; 
    } 
   
     
    public static boolean strcompareTo3(String v1,String v2){ 
        BigDecimal b1 = new BigDecimal(v1); 
        BigDecimal b2 = new BigDecimal(v2); 
        int bj = b1.compareTo(b2); 
        boolean res ; 
        if(bj==0) 
            res = true; 
        else 
            res = false; 
        return res; 
    } 
    
     
    public static BigDecimal bigRemainder(BigDecimal v1,BigDecimal v2, int scale){ 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP); 
    } 
    
     
    public static double round(double v, int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b = new BigDecimal(Double.toString(v)); 
        BigDecimal one = new BigDecimal("1"); 
        return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
   
     
    public static String strRound(String v, int scale) { 
        if (scale < 0) { 
            throw new IllegalArgumentException( 
                    "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b = new BigDecimal(v); 
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString(); 
    }      
}

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java中求Logn/log2 的精度问题

本文链接: https://www.lsjlt.com/news/132525.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

Java中求Logn/log2 的精度问题

目录java求Logn/log2精度例如程序如下：java 处理高精度计算使用的BigDecimal类的时候需要注意的地方：java求Logn/log2精度经过本人测试，java ...

99+

2024-04-02
详解java中BigDecimal精度问题

目录一、背景二、BigDecimal构造函数1、四种构造函数2、为什么会出现这种情况3、如何解决三、常用方法1、常用方法2、取舍规则四、格式化一、背景在实际开发中，对于不需要任何...

99+

2024-04-02
java中计算缺失精度的问题

Java中计算会缺失精度的主要原因是浮点数的精度问题和整数溢出问题。浮点数的精度 Java中的浮点数类型为float和double，它们采用的是IEEE 754规范的浮点数编码，这种编码方式虽然能够表示大范围的实数，但存在一定的精度损失。...

99+

2023-09-16

java jvm 开发语言
java中的BigDecimal精度问题怎么解决

在Java中，可以使用BigDecimal类来解决精度问题。BigDecimal类提供了高精度的数值计算，可以避免浮点数计算精度丢失...

99+

2023-08-16

java BigDecimal
java中BigDecimal精度问题的示例分析

这篇文章给大家分享的是有关java中BigDecimal精度问题的示例分析的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。一、背景在实际开发中，对于不需要任何准确计算精度的属性可以直接使用float或double...

99+

2023-06-15
java精度问题怎么解决

在Java中，处理浮点数的精度问题可以使用BigDecimal类来解决。BigDecimal类提供了精确的数值计算，可以避免浮点数的...

99+

2023-08-16

java
处理 Golang 中的数值精度问题

Golang 中的精度丢失现象及处理策略在使用编程语言 Golang 进行数值计算时，我们常常会遇到精度丢失的问题。这种问题可能会导致计算结果不准确，影响程序运行的正确性。本文将探讨...

99+

2024-02-25

golang 处理策略精度丢失
详解Python中的数据精度问题

目录一、python运算时精度问题1.运行时精度问题2.解决方案：添加方法二、python四舍五入时精度问题1.使用round与浮点数格式化时候的精度问题 2.解决方案，使...

99+

2024-04-02
Java中BigDecimal除法使用不当导致精度问题

目录I. 问题抛出 II. 源码定位 1. 整形传参构造 2. 浮点传参 3. String传参 4. 小结在使用BigDecimal的除法时，遇到一个鬼畜的问题，本以为的精度计算，...

99+

2024-04-02
解决java.sql.Timestamp丢失精度的问题

目录java.sql.Timestamp丢失精度需要重新补偿java.sql.Timestamp类的使用1. 获取当前时间2.String类型转换为Timestamp3.Timest...

99+

2024-04-02
java中求高精度除法,要求保留N位小数

目录求高精度除法，要求保留N位小数题目要求java 大数处理和高精度小数处理(so easy)简单的例子：部分简单代码求高精度除法，要求保留N位小数题目要求高精度除法，要求保留N...

99+

2024-04-02
讨论PHP除以10000的精度问题

PHP是一种广泛使用的服务器端编程语言，它可以嵌入HTML中，也可以用于开发Web应用程序、命令行脚本和桌面应用程序。在PHP中，我们常常需要进行数字计算，而这些计算可能会遇到精度问题。本文将介绍PHP除以10000的精度问题，并提供解决方...

99+

2023-05-14

精度 php
MySQL之DATETIME与TIMESTAMP的时间精度问题

目录datetime与timestamp时间精度问题默认时间精度与最大时间精度更改数据库中所有指定字段的类型的存储过程（用于修正时间精度）mysql中选datetime还是timestamp呢？1. 基本区别2. 其他特...

99+

2023-02-23

MySQL DATETIME MySQL TIMESTAMP MySQL时间精度
Double类型精度问题引起的错误

场景说明研发同事让把某个double类型字段的值四舍五入保留2位小数，mysql中round(col,2)可以实现四舍五入并且保留2位小数，但是神奇的事情发生了：发现有的四舍五入是正确的，而有...

99+

2024-04-02
分析和解决 Golang 中数值精度丢失的问题

Golang 精度丢失问题分析与解决方法在使用 Golang 编程语言进行数学运算时，一些情况下会遇到精度丢失的问题。这种问题通常发生在浮点数运算中，特别是涉及到大数值、小数值或者需...

99+

2024-02-24

golang 解决方法精度问题标准库
JS中toFixed()方法四舍五入的精度问题详解

目录踩的坑填坑方法什么样的坑？总结踩的坑最近工作中，在计算一个商品的折扣价格，有时候总是出现价格会有一分钱的差异，涉及钱的问题都是比较敏感的，经过排查，最后发现竟然是 JS...

99+

2024-04-02
C语言中浮点数的精度丢失问题解决

目录一先来看一段代码运行结果：二如何解决（1）浮点数的大小比较（2）含浮点数的表达式和0.0的比较总结一先来看一段代码 #include<stdio.h> int ...

99+

2024-04-02
PHP除以10000的精度问题怎么解决

这篇文章主要介绍“PHP除以10000的精度问题怎么解决”，在日常操作中，相信很多人在PHP除以10000的精度问题怎么解决问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”PHP除以10000的精度问题怎么解决...

99+

2023-07-05
javascript精度问题与调整的示例分析

这篇文章主要为大家展示了“javascript精度问题与调整的示例分析”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“javascript精度问题与调整的示例分析...

99+

2024-04-02
Python中的浮点数计算精度问题是如何解决的？

Python中的浮点数计算精度问题是如何解决的？在计算机科学中，浮点数计算精度问题是常见的挑战之一。由于计算机内部使用有限的比特位来表示浮点数，所以对于某些小数的表示和运算时，可能会出现精度损失的情况。Python作为一门强大的编程语言，提...

99+

2023-10-22

解决浮点数精度