IEEE754标准的c语言阐述，以及几个浮点数常量

news2024/9/22 1:23:10

很多年前，调研过浮点数与整数之间的双射问题：
win7 intel x64 cpu vs2013 c语言浮点数精度失真问题

最近重新学习了一下IEEE754标准，也许实际还有很多深刻问题没有被揭示。
计算机程序设计艺术，据说这本书中也有讨论。

参考：https://upimg.baike.so.com/doc/643382-681042.html
在这里插入图片描述
float32在线测试页面 ：https://www.h-schmidt.net/FloatConverter/IEEE754.html
在这里插入图片描述
我用手写计算的方式，算过一遍之后，得到一个结论：
任意数值的32bit，对应的float，都可以被精确地计算，转换为一个无误差对应的字符串，且与printf %.Nf一致，只要N足够大。
eg:float FLT_TRUE_MIN == 0x00000001, 0.00000000000000000000000000000000000000000000140129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158203125 (149位小数)
所有其他float都是FLT_TRUE_MIN这个数的整数倍。
稍微计算几个值就明白为什么。fraction中第一个1代表0.5，第二个1是0.25，然后是0.125,0.0625,0.03125 …尾数一直可以被2整除。题外话，如果是前苏联的3进制计算机，可能就存在无限循环除不尽的问题。

但是，前面提过，float与u32的双射问题。
显然32bit最多只有4,294,967,295个值。
u32只有10位十进制数，与149位十进制小数到FLT_MAX(340282346638528859811704183484516925440.000000)是无法一一对应的。
那么中间，绝大多数的浮点数数值都没有32bit的对应值，也就是说，人工随便写的一个浮点数字符串，有99%以上的概率转换为float之后，再转换为string，是无法还原的！
但是，c基础库的printf %f和atof有一种不失真、可逆的转换实现！只是这种实现是从32bit到float string，再还原到32bit。
人为造假float值比较容易被识别，只要是不可逆的就一定是人为改过的！

个人觉得IEEE754标准的设计，c语言的实现，并不是看起来那么简单。
稍微提几个方面：硬件电路、编译器、累计误差…这些方面的坑感觉都很深。

下面是个人测试float的代码及测试结果：

#include <stdio.h>
#include <float.h>
#include <math.h>
union u32f32 {
	unsigned int u32;
	float f32;
	struct {
		unsigned int fraction : 23;
		unsigned int exp : 8;
		unsigned int sign : 1;
	};
};
static char c_u32[64] = { 0 };
static char c_sign[64] = { 0 };
static char c_exp[64] = { 0 };
static char c_fraction[64] = { 0 };
void to_binary_string_with_spaces(const unsigned int u32, const int bits, char c_temp[64]) {
	int valid_bits = bits <= 32 ? bits : 32;
	int char_index = 0;
	for (int i = valid_bits - 1; i >= 0; i--) {
		if (i % 4 == 3 && i != valid_bits - 1) {
			c_temp[char_index++] = ' ';
		}
		c_temp[char_index++] = (u32 & (1U << i)) ? '1' : '0';
	}
	c_temp[char_index] = '\0';
}
void print_float_binary(const char* p_name, const unsigned int i) {
	const union u32f32 u32_f32_obj = { .u32 = i };
	to_binary_string_with_spaces(u32_f32_obj.u32, 32, c_u32);
	to_binary_string_with_spaces(u32_f32_obj.sign, 1, c_sign);
	to_binary_string_with_spaces(u32_f32_obj.exp, 8, c_exp);
	to_binary_string_with_spaces(u32_f32_obj.fraction, 23, c_fraction);
	printf("float %s == 0x%08x, binary(%s)\n", p_name, u32_f32_obj.u32, c_u32);
	printf("float %s == 0x%08x, sign(%s)*(-1) 2^exp(%s-127) fraction(1.%s)\n",
		p_name, u32_f32_obj.u32, c_sign, c_exp, c_fraction);
}
int test_float() {
	union u32f32 u32_f32_max_obj = { .f32 = FLT_MAX };//3.402823466e+38F
	union u32f32 u32_f32_epsilon_obj = { .f32 = FLT_EPSILON };//1.192092896e-07F
	union u32f32 u32_f32_min_obj = { .f32 = FLT_MIN };//1.175494351e-38F
	union u32f32 u32_f32_true_min_obj = { .f32 = FLT_TRUE_MIN };//1.401298464e-45F
	union u32f32 u32_f32_NaN_obj = { .f32 = NAN };//nan
	union u32f32 u32_f32_inf_obj = { .f32 = INFINITY };
	union u32f32 u32_f32_ne_inf_obj = { .f32 = -INFINITY };
	union u32f32 u32_f32_0_obj = { .f32 = 0 };
	union u32f32 u32_f32_ne_0_obj = { .f32 = 0,.sign = 1 };
	printf("float FLT_MAX      == 0x%08x, %f\n", u32_f32_max_obj.u32, u32_f32_max_obj.f32);
	printf("float FLT_EPSILON  == 0x%08x, %.23f\n", u32_f32_epsilon_obj.u32, u32_f32_epsilon_obj.f32);
	printf("float FLT_MIN      == 0x%08x, %.126f\n", u32_f32_min_obj.u32, u32_f32_min_obj.f32);
	printf("float FLT_TRUE_MIN == 0x%08x, %.149f\n", u32_f32_true_min_obj.u32, u32_f32_true_min_obj.f32);
	printf("float NaN          == 0x%08x, %f\n", u32_f32_NaN_obj.u32, u32_f32_NaN_obj.f32);
	printf("float INFINITY     == 0x%08x, %f\n", u32_f32_inf_obj.u32, u32_f32_inf_obj.f32);
	printf("float -INFINITY    == 0x%08x, %f\n", u32_f32_ne_inf_obj.u32, u32_f32_ne_inf_obj.f32);
	printf("float +0           == 0x%08x, %f\n", u32_f32_0_obj.u32, u32_f32_0_obj.f32);
	printf("float -0           == 0x%08x, %f\n", u32_f32_ne_0_obj.u32, u32_f32_ne_0_obj.f32);
	//
	print_float_binary("FLT_MAX     ", u32_f32_max_obj.u32);
	print_float_binary("FLT_EPSILON ", u32_f32_epsilon_obj.u32);
	print_float_binary("FLT_MIN     ", u32_f32_min_obj.u32);
	print_float_binary("FLT_TRUE_MIN", u32_f32_true_min_obj.u32);
	print_float_binary("NaN         ", u32_f32_NaN_obj.u32);
	print_float_binary("INFINITY    ", u32_f32_inf_obj.u32);
	print_float_binary("-INFINITY   ", u32_f32_ne_inf_obj.u32);
	print_float_binary("zero(+0)    ", u32_f32_0_obj.u32);
	print_float_binary("zero(-0)    ", u32_f32_ne_0_obj.u32);
	//
	union u32f32 u32_f32_obj = { .u32 = 0xBCD3D6D8 };//0xBCD3D6D8 == -0.02585928142070770263671875
	printf("float obj_test     == 0x%08x, %.60f\n", u32_f32_obj.u32, u32_f32_obj.f32);
	print_float_binary("obj_test    ", u32_f32_obj.u32);
	//
	printf("float obj_test     == 0x%08x, sign(%s1) 2^exp(%d) fraction(%.30f)\n", u32_f32_obj.u32,
		u32_f32_obj.sign ? "-" : "+",
		((int)u32_f32_obj.exp) - 127,
		1.0 * u32_f32_obj.fraction / (1 << 23) + 1);
	printf("float obj_test     == 0x%08x, sign(%d) exp(%f) fraction(%.30f)\n", u32_f32_obj.u32,
		(-1) * (int)u32_f32_obj.sign,
		(pow(2, ((int)u32_f32_obj.exp) - 127)),
		(1.0 * u32_f32_obj.fraction / (1 << 23) + 1));
	printf("float obj_test     == 0x%08x, %.30f\n", u32_f32_obj.u32,
		(-1) * (int)u32_f32_obj.sign *
		(pow(2, ((int)u32_f32_obj.exp) - 127)) *
		(1.0 * u32_f32_obj.fraction / (1 << 23) + 1));
	return 0;
}

int main(int argc, char** argv) {
	return test_float();
}

float FLT_MAX      == 0x7f7fffff, 340282346638528859811704183484516925440.000000
float FLT_EPSILON  == 0x34000000, 0.00000011920928955078125
float FLT_MIN      == 0x00800000, 0.000000000000000000000000000000000000011754943508222875079687365372222456778186655567720875215087517062784172594547271728515625
float FLT_TRUE_MIN == 0x00000001, 0.00000000000000000000000000000000000000000000140129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158203125
float NaN          == 0x7fc00000, nan
float INFINITY     == 0x7f800000, inf
float -INFINITY    == 0xff800000, -inf
float +0           == 0x00000000, 0.000000
float -0           == 0x80000000, -0.000000
float FLT_MAX      == 0x7f7fffff, binary(0111 1111 0111 1111 1111 1111 1111 1111)
float FLT_MAX      == 0x7f7fffff, sign(0)*(-1) 2^exp(1111 1110-127) fraction(1.111 1111 1111 1111 1111 1111)
float FLT_EPSILON  == 0x34000000, binary(0011 0100 0000 0000 0000 0000 0000 0000)
float FLT_EPSILON  == 0x34000000, sign(0)*(-1) 2^exp(0110 1000-127) fraction(1.000 0000 0000 0000 0000 0000)
float FLT_MIN      == 0x00800000, binary(0000 0000 1000 0000 0000 0000 0000 0000)
float FLT_MIN      == 0x00800000, sign(0)*(-1) 2^exp(0000 0001-127) fraction(1.000 0000 0000 0000 0000 0000)
float FLT_TRUE_MIN == 0x00000001, binary(0000 0000 0000 0000 0000 0000 0000 0001)
float FLT_TRUE_MIN == 0x00000001, sign(0)*(-1) 2^exp(0000 0000-127) fraction(1.000 0000 0000 0000 0000 0001)
float NaN          == 0x7fc00000, binary(0111 1111 1100 0000 0000 0000 0000 0000)
float NaN          == 0x7fc00000, sign(0)*(-1) 2^exp(1111 1111-127) fraction(1.100 0000 0000 0000 0000 0000)
float INFINITY     == 0x7f800000, binary(0111 1111 1000 0000 0000 0000 0000 0000)
float INFINITY     == 0x7f800000, sign(0)*(-1) 2^exp(1111 1111-127) fraction(1.000 0000 0000 0000 0000 0000)
float -INFINITY    == 0xff800000, binary(1111 1111 1000 0000 0000 0000 0000 0000)
float -INFINITY    == 0xff800000, sign(1)*(-1) 2^exp(1111 1111-127) fraction(1.000 0000 0000 0000 0000 0000)
float zero(+0)     == 0x00000000, binary(0000 0000 0000 0000 0000 0000 0000 0000)
float zero(+0)     == 0x00000000, sign(0)*(-1) 2^exp(0000 0000-127) fraction(1.000 0000 0000 0000 0000 0000)
float zero(-0)     == 0x80000000, binary(1000 0000 0000 0000 0000 0000 0000 0000)
float zero(-0)     == 0x80000000, sign(1)*(-1) 2^exp(0000 0000-127) fraction(1.000 0000 0000 0000 0000 0000)
float obj_test     == 0xbcd3d6d8, -0.025859281420707702636718750000000000000000000000000000000000
float obj_test     == 0xbcd3d6d8, binary(1011 1100 1101 0011 1101 0110 1101 1000)
float obj_test     == 0xbcd3d6d8, sign(1)*(-1) 2^exp(0111 1001-127) fraction(1.101 0011 1101 0110 1101 1000)
float obj_test     == 0xbcd3d6d8, sign(-1) 2^exp(-6) fraction(1.654994010925292968750000000000)
float obj_test     == 0xbcd3d6d8, sign(-1) exp(0.015625) fraction(1.654994010925292968750000000000)
float obj_test     == 0xbcd3d6d8, -0.025859281420707702636718750000

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1484411.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

uni-app去除页面头部的标题栏

uni-app去除页面头部的标题栏

uniapp项目 每个界面都会有一个标题栏 配置在我们项目根目录的 pages.json中 我们将它全部去掉 上面还是有一条黑的 体验非常差 我们只需要在pages.json中 指定page的 style中加入 "navigationStyle": "custom"对应的page 就没有这个标题栏了
阅读更多...
Spring 源码解析

Spring 源码解析

文章目录 前言相关Spring的定义接口整体代码StartupStep contextRefresh this.applicationStartup.start("spring.context.refresh")prepareRefresh()obtainFreshBeanFactory()registerBeanPostProcessors(beanFactory)SpringAOP原码流程EnableAspectJAutoProxyAnno…
阅读更多...
协方差矩阵计算

协方差矩阵计算

文章目录 协方差矩阵计算原理python实现 协方差矩阵 协方差矩阵反映了两个随机变量变化时是同向还是反向的&#xff08;相关性&#xff09;。 如果协方差>0&#xff0c;则说明这两个随机变量同向变化。 协方差矩阵<0&#xff0c;则说明是反向变化。 协方差矩阵0&#xf…
阅读更多...
【MySQL】查询语句：条件、排序和分页

【MySQL】查询语句：条件、排序和分页

基本查询 MySQL 数据库使用SELECT语句来查询数据。 查询字段 以下为在MySQL数据库中查询数据通用的 SELECT 语法&#xff1a; SELECT 字段名,字段名... FROM 表名;选择全部列 SELECT * FROM emp; -- 查询所有字段一般情况下&#xff0c;除非需要使用表中所有的字段数据&…
阅读更多...
React入门之React_使用es5和es6语法渲染和添加class

React入门之React_使用es5和es6语法渲染和添加class

React入门 //react的核心库 <script src"https://cdn.jsdelivr.net/npm/react17/umd/react.development.js"></script> //react操作dom的核心库&#xff0c;类似于jquery <script src"https://cdn.jsdelivr.net/npm/react-dom17/umd/react-dom.…
阅读更多...
【知识分享】配电网重构知识及matlab实现

【知识分享】配电网重构知识及matlab实现

目录 一、理论分析 二、程序介绍 1.基本环矩阵M的matlab代码 2.智能算法重构代码 三、下载链接 配网重构中&#xff0c;很重要的一个约束条件为配网应随时保持开环、辐射的状态&#xff1a; 配电网系统是属于闭环设计但是开环运行的系统&#xff0c;因此&#xff0c;在开关…
阅读更多...
考取ORACLE数据库OCP的必要性 Oracle数据库

考取ORACLE数据库OCP的必要性 Oracle数据库

OCP证书是什么&#xff1f; OCP&#xff0c;全称Oracle Certified Professional&#xff0c;是Oracle公司的Oracle数据库DBA&#xff08;Database Administrator&#xff0c;数据库管理员)认证课程。这是Oracle公司针对数据库管理领域设立的一项认证课程&#xff0c;旨在评估和…
阅读更多...
Java ZooKeeper-RocketMQ 面试题

Java ZooKeeper-RocketMQ 面试题

Java ZooKeeper-RocketMQ 面试题 前言1、谈谈你对ZooKeeper的理解 &#xff1f;2、Zookeeper的工作原理&#xff08;Zab协议&#xff09;3、谈谈你对分布式锁的理解&#xff0c;以及分布式锁的实现&#xff1f;4、 zookeeper 是如何保证事务的顺序一致性的&#xff1f;5、 zook…
阅读更多...
Unity 向量计算、欧拉角与四元数转换、输出文本、告警、错误、修改时间、定时器、路径、

Unity 向量计算、欧拉角与四元数转换、输出文本、告警、错误、修改时间、定时器、路径、

using System.Collections; using System.Collections.Generic; using UnityEngine;public class c2 : MonoBehaviour {// 定时器float t1 0;void Start(){// 向量Vector3 v1 new Vector3(0, 0, 2);Vector3 v2 new Vector3(0, 0, 3);// 计算两个向量的夹角Debug.Log(Vector3…
阅读更多...
Netty的InboundHandler 和OutboundHandler

Netty的InboundHandler 和OutboundHandler

一、InboundHandler 和OutboundHandler的区别 在Netty中&#xff0c;"inbound"表示来自外部来源&#xff08;如网络连接&#xff09;的数据&#xff0c;而"outbound"则表示从应用程序发送到外部目标&#xff08;如网络连接或其他服务&#xff09;的数据。…
阅读更多...
如何使用 CrewAI 构建协作型 AI Agents

如何使用 CrewAI 构建协作型 AI Agents

一、前言 AI Agents 的开发是当前软件创新领域的热点。随着大语言模型 (LLM) 的不断进步&#xff0c;预计 AI 智能体与现有软件系统的融合将出现爆发式增长。借助 AI 智能体&#xff0c;我们可以通过一些简单的语音或手势命令&#xff0c;就能完成以往需要手动操作应用程序才能…
阅读更多...
QT绘图

QT绘图

QPainter paintEvent是Qt中一个非常重要的函数&#xff0c;它是QWidget类的一个事件处理函数&#xff0c;用于处理小部件的绘制事件。当Qt认为小部件需要重绘时&#xff08;例如&#xff0c;窗口首次出现时&#xff0c;大小改变时&#xff0c;或者调用了小部件的update()方法时…
阅读更多...
JVM(5)

JVM(5)

垃圾回收相关 垃圾收集器 警告:纯八股文! 如果说上面我们讲的收集算法是内存回收的方法论,那么垃圾收集器就是内存回收的具体体现. 垃圾收集器的作用:垃圾收集器是为了保证程序能够正常,持久运行的一种技术,它是将程序中不用的死亡对象也就是垃圾对象进行清除,从而保证新的…
阅读更多...
【 C++ 】空间配置器

【 C++ 】空间配置器

1、什么是空间配置器 空间配置器&#xff0c;顾名思义就是为各个容器高效的管理空间(空间的申请与回收)的&#xff0c;在默默地工作。虽然在常规使用STL时&#xff0c;可能用不到它&#xff0c;但站在学习研究的角度&#xff0c;学习它的实现原理对我们有很大的帮助。 2、为什…
阅读更多...
P4715 【深基16.例1】淘汰赛题解

P4715 【深基16.例1】淘汰赛题解

题目 有&#xff08;n≤7&#xff09;个国家参加世界杯决赛圈且进入淘汰赛环节。已经知道各个国家的能力值&#xff0c;且都不相等。能力值高的国家和能力值低的国家踢比赛时高者获胜。1号国家和2号国家踢一场比赛&#xff0c;胜者晋级。3号国家和4号国家也踢一场&#xff0c;…
阅读更多...
zephyr学习

zephyr学习

zephyr内核对象学习 定时器 类似linux的定时器&#xff0c; 可以分别设置第一次到期时间和后续的周期触发时间&#xff0c; 可以注册到期回调和停止回调 还有一个计数状态&#xff0c;用于标记timer到期了多少次 duration&#xff1a;设定timer第一次到期的时间。 period: …
阅读更多...
SpringBoot整合JdbcTemplate

SpringBoot整合JdbcTemplate

✅作者简介：大家好，我是Leo，热爱Java后端开发者，一个想要与大家共同进步的男人😉😉 🍎个人主页：Leo的博客 💞当前专栏： 循序渐进学SpringBoot ✨特色专栏： MySQL学习 🥭本文内容：SpringBoot整合JdbcTemplate 📚个人知识库： Leo知识库，欢迎大家访问 目录 …
阅读更多...
超详细的 pytest 钩子函数 之初始钩子和引导钩子来啦

超详细的 pytest 钩子函数 之初始钩子和引导钩子来啦

前几篇文章介绍了 pytest 点的基本使用&#xff0c;学完前面几篇的内容基本上就可以满足工作中编写用例和进行自动化测试的需求。从这篇文章开始会陆续给大家介绍 pytest 中的钩子函数&#xff0c;插件开发等等。 仔细去看过 pytest 文档的小伙伴&#xff0c;应该都有发现 pyt…
阅读更多...
递归与回溯2

递归与回溯2

一&#xff1a;递归分治 什么是递归&#xff1f; 函数自己调用自己通过函数体来进行循环以自相似的方法重复进行的过程 递归的过程&#xff1a;先自顶向下找到递归出口&#xff0c;在自底向上回到最初的递归位置 推导路径未知的题目只能用递归不能用循环 比如求多叉树的节点&…
阅读更多...
NOC2023软件创意编程（学而思赛道）python小高组初赛真题

NOC2023软件创意编程（学而思赛道）python小高组初赛真题

软件创意编程 一、参赛范围 1.参赛组别：小学低年级组（1-3 年级）、小学高年级组（4-6 年级）、初中组。 2.参赛人数：1 人。 3.指导教师：1 人（可空缺）。 4.每人限参加 1 个赛项。 组别确定：以地方教育行政主管部门（教委、教育厅、教育局） 认定的选手所属学段为准。 二、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023