浮点数的加减法

已于 2022-03-14 22:05:37 修改
阅读量1k 收藏 10
点赞数 2
分类专栏： 计算机组成原理 文章标签： c语言 c++ 开发语言
于 2022-03-14 19:02:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53364209/article/details/123485724
版权

 

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
//计算机组成原理作业：浮点数的加减法

//************ 二进制整数 ************
//由真值求补码（二进制整数）
void trueInt_to_twocomplement(char* bin);
//由补码求真值（二进制整数）
void twocomplementInt_to_trueInt(char* bin);
//二进制转十进制（双符号位二进制整数）
int binary_to_decimal(char* bin);
//双符号位二进制整数的加法
void add_Intbin(char* bin1, char* bin2, char* bin);

//************ 二进制小数 ************
//由真值求补码（二进制小数）
void trueDouble_to_twocomplement(char* bin);
//由补码求真值（二进制小数）
void twocomplementDouble_to_trueDouble(char* bin);
//双符号位二进制小数的加法
void add_Doublebin(char* bin1, char* bin2, char* bin);

//************ 其他 ************
//向右规格化，小数点向左移
void right_standardize(char* bin);
//向左规格化，小数点向右移, *n 用来记录小数点移动了多少位
void left_standardize(char* bin, int* n);
//对阶
void equal_exponent(char* bin, int n);
//比较两浮点数阶码，即比较 Ex 和 Ey
int compare_twocomplementInt(char* Ex_bin, char* Ey_bin);
//尾数相加
void mantissa_addition(char* Mx_bin, char* My_bin, char* bin, char* E);

//规格化数,X = Mx * 2^(Ex), Y = My * 2^(Ey)
typedef struct floatNumber
{
	char M[99];
	char E[99];
}floatNumber, *pfloatNumber;
int main() {
	//开辟内存，并给规格化数赋初值
	pfloatNumber x = (pfloatNumber)malloc(sizeof(floatNumber));
	if(x == NULL) {
		printf("分配内存失败\n");
		exit(-1);
	}
	printf("Please Enter A Value For Mx:");
	scanf("%s", &(x->M));
	printf("Please Enter A Value For Ex:");
	scanf("%s", &(x->E));

	pfloatNumber y = (pfloatNumber)malloc(sizeof(floatNumber));
	if(y == NULL) {
		printf("分配内存失败\n");
		exit(-1);
	}
	printf("Please Enter A Value For My:");
	scanf("%s", &(y->M));
	printf("Please Enter A Value For Ey:");
	scanf("%s", &(y->E));


	printf("\n---------------------------\n");
	printf("当前的规格化数 x 为：%s * 2^%s\n", x->M, x->E);
	printf("\n---------------------------\n");
	printf("当前的规格化数 y 为：%s * 2^%s\n", y->M, y->E);

	//求出 Mx，Ex，My，Ey 的补码
	 trueDouble_to_twocomplement(x->M);
	 trueInt_to_twocomplement(x->E);
	 trueDouble_to_twocomplement(y->M);
	 trueInt_to_twocomplement(y->E);

	 printf("\n---------------------------\n");
	 printf("twocomplement_Mx = %s\n", x->M);
	 printf("\n---------------------------\n");
	 printf("twocomplement_Ex = %s\n", x->E);
	 printf("\n---------------------------\n");
	 printf("twocomplement_My = %s\n", y->M);
	 printf("\n---------------------------\n");
	 printf("twocomplement_Ey = %s\n", y->E);

	 //求阶差
	 int sub_E = compare_twocomplementInt(x->E, y->E);
	 printf("\n---------------------------\n");
	 printf("sub_E = %d\n", sub_E);

	 
	 //保留大阶
	 char E[99];
	 sub_E < 0 ? strcpy(E, y->E) : strcpy(E, x->E);
	 printf("\n---------------------------\n");
	 printf("E = %s\n", E);

	 
	 //对阶
	 char twocomplement[99];
	 sub_E <= 0 ? equal_exponent(x->M, abs(sub_E)) : equal_exponent(y->M, abs(sub_E));
	 sub_E <= 0 ? strcpy(twocomplement, x->M) : strcpy(twocomplement, y->M);
	 printf("\n---------------------------\n");
	 printf("twocomplement = %s\n", twocomplement);

	 //尾数相加
	 char bin[99];
	 mantissa_addition(x->M, y->M, bin, E);
	 printf("\n---------------------------\n");
	 printf("bin = %s\n", bin);
	 printf("\n---------------------------\n");
	 printf("E = %s\n", E);

	 twocomplementInt_to_trueInt(E);
	 twocomplementDouble_to_trueDouble(bin);
	 printf("\n---------------------------\n");
	 printf("当前的规格化数 x + y 为：%s * 2^%s\n", bin, E);
	//释放内存
	free(x);
	free(y);
	
	return 0;
}

//由真值求补码（二进制整数）
void trueInt_to_twocomplement(char* bin) {
	char newBin[99];
	//原码
	char newBin1[99];
	//反码
	char newBin2[99];
	//补码
	char newBin3[99];
	//正数的原反补相同
	if (bin[0] != '-') {
		newBin[0] = newBin[1] = '0';
		int i;
		for (i = 0; i < strlen(bin); i++) {
			newBin[i + 2] = bin[i];
		}
		newBin[i + 2] = '\0';
		strcpy(bin, newBin);
	}//负数
	else {
		//原码
		newBin1[0] = newBin1[1] = '1';
		int i;
		for (i = 1; i < strlen(bin); i++) {
			newBin1[i + 1] = bin[i];
		}
		newBin1[i + 1] = '\0';
		newBin2[0] = newBin2[1] = '1';
		for (i = 2; i < strlen(newBin1); i++) {
			newBin2[i] = newBin1[i] == '0' ? '1' : '0';
		}
		newBin2[i] = '\0';
		for (int i = 0; i < strlen(newBin2); i++) {
			newBin3[i] = newBin2[i];
		}
		newBin3[strlen(newBin2)] = '\0';
		//bool 用于判断有没有进行进位操作
		//0 表示未进位，1 表示进位操作已完成，退出循环
		int bool = 0;
		for (int i = strlen(newBin2) - 1; i >= 2 && bool == 0; i--) {
			//如果当前位为 0 的话，直接进位就行，并把 bool 改成 1，完成进位操作，退出循环
			if (newBin2[i] == '0') {
				newBin3[i] = '1';
				bool = 1;
			}//如果当前为为 1 的话，当前位变为 0，向下一位进 1，继续循环
			else {
				newBin3[i] = '0';
			}
		}
		//反码是 111 这种情况，说明真值为 0，0 的补码是 0
		if (bool == 0) {
			return "0";
		}
		else {
			strcpy(bin, newBin3);
		}
	}
}

//由真值求补码（二进制小数）
void trueDouble_to_twocomplement(char* bin) {
	char newBin[99];
	//原码
	char newBin1[99];
	//反码
	char newBin2[99];
	//补码
	char newBin3[99];
	//正数的原反补相同
	if (bin[0] != '-') {
		newBin[0] = newBin[1] = '0';
		int i;
		for (i = 1; i < strlen(bin); i++) {
			newBin[i + 1] = bin[i];
		}
		newBin[i + 1] = '\0';
		strcpy(bin, newBin);
	}//负数
	else {
		//原码
		newBin1[0] = newBin1[1] = '1';
		int i;
		for (i = 2; i < strlen(bin); i++) {
			newBin1[i] = bin[i];
		}
		newBin1[i] = '\0';
		newBin2[0] = newBin2[1] = '1';
		newBin2[2] = '.';
		for (i = 3; i < strlen(newBin1); i++) {
			newBin2[i] = newBin1[i] == '0' ? '1' : '0';
		}
		newBin2[i] = '\0';
		for (int i = 0; i < strlen(newBin2); i++) {
			newBin3[i] = newBin2[i];
		}
		newBin3[strlen(newBin2)] = '\0';
		//bool 用于判断有没有进行进位操作
		//0 表示未进位，1 表示进位操作已完成，退出循环
		int bool = 0;
		for (int i = strlen(newBin2) - 1; i >= 3 && bool == 0; i--) {
			//如果当前位为 0 的话，直接进位就行，并把 bool 改成 1，完成进位操作，退出循环
			if (newBin2[i] == '0') {
				newBin3[i] = '1';
				bool = 1;
			}//如果当前为为 1 的话，当前位变为 0，向下一位进 1，继续循环
			else {
				newBin3[i] = '0';
			}
		}
		//真值为 0，0 的补码是 0
		if (bool == 0) {
			return "0";
		}
		else {
			strcpy(bin, newBin3);
		}
	}
}

//由补码求真值（二进制整数）
void twocomplementInt_to_trueInt(char* bin) {
	//newBin 字符数组用来存放真值
	char newBin[99];
	char newBin1[99];
	char newBin2[99];
	//补码为 0
	if (strlen(bin) == 1 && bin[0] == '0') {
		return "0";
	}
	//正数的原反补相同
	if(bin[0] == '0' && bin[1] == '0') {
		int i;
		for (i = 2; i < strlen(bin); i++) {
			newBin[i - 2] = bin[i];
		}
		newBin[i - 2] = '\0';
	}
	else {
		newBin[0] = '-';
		//先直接去除符号位（暂时不考虑符号位后面的变化）
		int i;
		for (i = 2; i < strlen(bin); i++) {
			newBin1[i - 2] = bin[i];
		}
		newBin1[i - 2] = '\0';
		//可以判断有没有遇到 1，遇到 1 的话直接退出循环
		int bool = 0;
		for (i = strlen(newBin1) - 1; i >= 0 && bool == 0; i--) {
			if (newBin1[i] == '1') {
				newBin2[i] = '0';
				bool = 1;
			}
			else {
				newBin2[i] = '1';
			}
		}
		//中途碰到 1 
		if (bool == 1) {
			for (int j = 0; j <= i; j++) {
				newBin2[j] = newBin1[j];
			}
		}
		newBin2[strlen(newBin1)] = '\0';
		//按位取反就是真值 
		for (i = 0; i < strlen(newBin2); i++) {
			newBin[i + 1] = newBin2[i] == '0' ? '1' : '0';
		}
		newBin[i + 1] = '\0';
	}
	strcpy(bin, newBin);
}

//由补码求真值（二进制小数）
void twocomplementDouble_to_trueDouble(char* bin) {
	//newBin 字符数组用来存放真值
	char newBin[99];
	char newBin1[99];
	char newBin2[99];
	//补码为 0
	if (strlen(bin) == 1 && bin[0] == '0') {
		return "0";
	}
	
	//正数的原反补相同
	if (bin[0] == '0' && bin[1] == '0') {
		int i;
		for (i = 1; i < strlen(bin); i++) {
			newBin[i - 1] = bin[i];
		}
		newBin[i - 1] = '\0';
	}
	else {
		newBin[0] = '-';
		newBin[1] = '0';
		newBin[2] = '.';
		//先直接去除符号位（暂时不考虑符号位后面的变化）
		int i;
		for (i = 3; i < strlen(bin); i++) {
			newBin1[i - 3] = bin[i];
		}
		newBin1[i - 3] = '\0';
		//可以判断有没有遇到 1，遇到 1 的话直接退出循环
		int bool = 0;
		for (i = strlen(newBin1) - 1; i >= 0 && bool == 0; i--) {
			if (newBin1[i] == '1') {
				newBin2[i] = '0';
				bool = 1;
			}
			else {
				newBin2[i] = '1';
			}
		}
		//中途碰到 1 
		if (bool == 1) {
			for (int j = 0; j <= i; j++) {
				newBin2[j] = newBin1[j];
			}
		}
		newBin2[strlen(newBin1)] = '\0';
		//按位取反就是真值 
		for (i = 0; i < strlen(newBin2); i++) {
			newBin[i + 3] = newBin2[i] == '0' ? '1' : '0';
		}
		newBin[i + 3] = '\0';
	}
	strcpy(bin, newBin);
}

//二进制转十进制（双符号位二进制整数）
int binary_to_decimal(char* bin) {
	int res;
	res = 0;
	int exponent = strlen(bin) - 3;
	for (int i = 2; i < strlen(bin); i++, exponent--) {
		res = bin[i] == '0' ? res : res + pow(2, exponent);
	}
	return bin[0] == '0' ? res : 0 - res;
}

//比较两浮点数阶码，即比较 Ex 和 Ey
int compare_twocomplementInt(char* Ex_bin, char* Ey_bin) {
	int decimal_Ex = binary_to_decimal(Ex_bin);
	int decimal_Ey = binary_to_decimal(Ey_bin);
	return decimal_Ex - decimal_Ey;
}

//双符号位二进制整数的加法
void add_Intbin(char* bin1, char* bin2, char* bin) {
	char newBin1[99];
	char newBin2[99];
	char newBin3[99];
	int length = max(strlen(bin1), strlen(bin2));
	//使位数与位数大的保持一致（即位数小的前面补 0，便于后面加法运算）
	int i,j;
	for (i = 0; i < length; i++) {
		newBin1[i] = bin1[i] == '1' ? '1' : '0';
		newBin2[i] = bin2[i] == '1' ? '1' : '0';
	}
	newBin1[length] = newBin2[length] = '\0';
	if (length == strlen(bin1)) {
		for (i = 2; i < 2 + strlen(bin1) - strlen(bin2); i++) {
			newBin2[i] = newBin2[0] == '0' ? '0' : '1';
		}
		for (i = strlen(bin2), j = 2; i < strlen(bin1); i++,j++) {
			newBin2[i] = bin2[j];
		}
	}
	else if (length == strlen(bin2)) {
		for (i = 2; i < 2 + strlen(bin2) - strlen(bin1); i++) {
			newBin1[i] = newBin1[i] == '0 ' ? '0' : '1';
		}
		for (j = 2; i < strlen(bin2); i++, j++) {
			newBin1[i] = bin1[j];
		}
	}
	printf("newBin1 = %s\n", newBin1);
	printf("newBin2 = %s\n", newBin2);

	// bool 的值为 0，表示没有进位， bool 的值为 1，表示有进位
	int bool = 0;
	for (i = strlen(newBin1) - 1; i >= 0; i--) {
		if (newBin1[i] == '0' && newBin2[i] == '0') {
			newBin3[i] = bool == 0 ? '0' : '1';
			bool = 0;
		}
		else if ((newBin1[i] == '0' && newBin2[i] == '1') || (newBin1[i] == '1' && newBin2[i] == '0')) {
			newBin3[i] = bool == 0 ? '1' : '0';
		}
		else if (newBin1[i] == '1' && newBin2[i] == '1') {
			newBin3[i] = bool == 0 ? '0' : '1';
			bool = 1;
		}
	}
	newBin3[strlen(newBin1)] = '\0';
	printf("newBin3 = %s\n", newBin3);
	strcpy(bin, newBin3);
}

//双符号位二进制小数的加法
void add_Doublebin(char* bin1, char* bin2, char* bin) {
	char newBin1[99];
	char newBin2[99];
	char newBin3[99];
	char newBin4[99];
	int length = max(strlen(bin1), strlen(bin2));
	int i;
	//去掉小数点，并且使位数与位数大的保持一致（即位数小的后面补 0，便于后面加法运算）
	for (i = 0; i < 2; i++) {
		newBin1[i] = bin1[i];
		newBin2[i] = bin2[i];
	}
	for (i = 3; i < length; i++) {
		newBin1[i - 1] = bin1[i] == '1' ? '1' : '0';
		newBin2[i - 1] = bin2[i] == '1' ? '1' : '0';
	}
	newBin1[i - 1] = newBin2[i - 1] = '\0';
	// bool 的值为 0，表示没有进位， bool 的值为 1，表示有进位
	int bool = 0;
	for (i = strlen(newBin1) - 1; i >= 0; i--) {
		if (newBin1[i] == '0' && newBin2[i] == '0') {
			newBin3[i] = bool == 0 ? '0' : '1';
			bool = 0;
		}
		else if ((newBin1[i] == '0' && newBin2[i] == '1') || (newBin1[i] == '1' && newBin2[i] == '0')) {
			newBin3[i] = bool == 0 ? '1' : '0';
		}
		else if (newBin1[i] == '1' && newBin2[i] == '1') {
			newBin3[i] = bool == 0 ? '0' : '1';
			bool = 1;
		}
	}
	newBin3[strlen(newBin1)] = '\0';
	for (i = 0; i < 2; i++) {
		newBin4[i] = newBin3[i];
	}
	newBin4[2] = '.';
	for (i = 2; i < strlen(newBin3); i++) {
		newBin4[i + 1] = newBin3[i];
	}
	newBin4[i + 1] = '\0';

	strcpy(bin, newBin4);
}

//尾数相加
void mantissa_addition(char* Mx_bin, char* My_bin, char* bin, char* E) {
	add_Doublebin(Mx_bin, My_bin, bin);
	//规格化：
	//		采用双符号位的补码： S = 00.1xxx xxxx...
	//							 S = 11.0xxx xxxx...
	//若不是规格化的数，需要尾数向左移动，以实现规格化，即向左规格化
	//如果尾数相加发生正溢或负溢，即S = 01.xxxx xxxx...或S = 10.xxxx xxxx...，向右规格化
	if ((bin[0] == '0' && bin[1] == '1') || (bin[0] == '1' && bin[1] == '0')) {
		right_standardize(bin);
		char newBin[99];
		add_Intbin(E, "001", newBin);
		strcpy(E, newBin);
	}
	else {
		char newBin[99];
		char newBin1[99];
		newBin1[0] = '-';
		int n;
		left_standardize(bin, &n);
		printf("n = %d\n", n);
		itoa(n, newBin, 2);
		printf("newBin = %s\n", newBin);
		int i;
		for (i = 0; i < strlen(newBin); i++) {
			newBin1[i + 1] = newBin[i];
		}
		newBin1[i + 1] = '\0';
		printf("newBin1 = %s\n", newBin1);
		trueInt_to_twocomplement(newBin1);
		printf("newBin1 = %s\n", newBin1);
		add_Intbin(E, newBin1, newBin);
		strcpy(E, newBin);
	}
}	

//对阶
void equal_exponent(char* bin, int n) {
	char newBin[99];
	int i;
	for (i = 0; i < 3; i++) {
		newBin[i] = bin[i];
	}
	for (i = 3; i < n + 3; i++) {
		newBin[i] = '0';
	}
	for (i = 3; i < strlen(bin); i++) {
		newBin[i + n] = bin[i];
	}
	newBin[i] = '\0';
	strcpy(bin, newBin);
}

//向右规格化，小数点向左移
void right_standardize(char* bin) {
	char newBin[99];
	newBin[0] = newBin[1] = bin[0];
	newBin[2] = '.';
	newBin[3] = bin[1];
	int i;
	for (i = 3; i < strlen(bin); i++) {
		newBin[i + 1] = bin[i];
	}
	newBin[i] = '\0';
	strcpy(bin, newBin);
}

//向左规格化，小数点向右移, *n 用来记录小数点移动了多少位
void left_standardize(char* bin, int* n) {
	static char newBin[99];
	memset(newBin, '\0', sizeof(newBin));
	char newBin1[99];
	//去掉小数点
	newBin1[0] = newBin1[1] = bin[0];
	for (int i = 3; i < strlen(bin); i++) {
		newBin1[i - 1] = bin[i];
	}
	newBin1[strlen(bin) - 1] = '\0';
	int index = 0;
	//如果符号位是 11，寻找第一个 0，如果符号位是 00，寻找第一个 1
	char c = bin[0] == '0' ? '1' : '0';
	for (int i = 0; i < strlen(newBin1); i++) {
		//找到目标，index 记录对应的索引位置，结束for循环
		if (newBin1[i] == c) {
			index = i;
			break;
		}
	}
	newBin[0] = newBin1[index - 2];
	printf("newBin[0] = %c\n", newBin[0]);
	newBin[1] = newBin1[index - 1];
	newBin[2] = '.';
	int i, j;
	for (i = index, j = 3; i < strlen(newBin1); i++,j++) {
		newBin[j] = newBin1[i];
	}
	newBin[j] = '\0';
	*n = index - 2;
	strcpy(bin, newBin);
}

大柠丶
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单片机与DSP中的浮点数加减法模块设计思路
11-14
　浮点数减法程序将减数取补后，就可以转换为浮卢数加法运算。进行浮点数的加法运算时必须保证被加数和加数的阶码相等，着不相等，则必须先对阶使两数的阶码相等．然后刈对阶后的两个数的尾数按定点数的加法相加，...
【计算机组成原理】浮点加减运算（简洁易懂）
qq_73301283的博客
10-17 2007
本文主要介绍了浮点数的加减运算，分为对阶，尾数运算，规格化，舍入,溢出判断等步骤
C语言实现浮点数加法
ChenBryant的博客
12-17 1万+
理论分析： 双精度浮点数(double)是计算机使用的一种数据类型，使用 64 位（8字节） 来存储一个浮点数。双精度型占8 个字节内存空间，其数值范围为-1.7E308～+1.7E308。在IEEE754标准下，第一位为符号位，其后11位为阶码位，最后52位为小数位。每一位上均为0/1，为二进制形式表达。 由于在计算机中，数据的运算是通过二进制这一工具，双精度浮点数的运算同样遵循二进制计算的进位...
浮点数加减运算过程：对阶、尾数运算、规格化、舍入和判溢出
热门推荐
理木客
12-31 3万+
例如：两浮点数x=0.1101*201,y=(-0.1010)*211,求x+y 一、 对阶 1、求补码 [x]补=00,01;00.1101,[y]补=00,11;11.0110； 2、求阶差 小阶向大阶对阶，同时尾数右移，移动位数为阶差。 00.11-00.01=00.10=2，故阶差为2，故[x]’补=00,11;00.0011 二、尾数求和 将对阶后的两个尾数安定点加减运算规则进行运算。 ...
IEEE 754 浮点数加减运算
WWIandMC的博客
04-22 9813
移码 定义：[X]移 = 2n + X ( 2n > x >= -2n ) X为真值，n为整数的位数 数值位和X的补码相同，符号位与补码相反 IEEE 754 32位单精度 Sign 8位阶码 [ 反码 ] 23位尾数 [原码] 表达式 取值范围 N = (-1)s × 2E-127 × 1.M 1到254 阶码用非标准移码表示（仅偏移127） ...
浮点加减法（个人见解有待改正）
qq_43727126的博客
10-07 770
例： x=2^-0110.100101, y=2^-010-0.011110 将浮点数分阶码和尾数两部分写, 并且均采用补码(用于计算▲E和尾数的加减),均采用双符号位： 阶码 尾数 X 11 101 00.100101 Y 11 110 11 .100010 其中分步执行这里只说一下注意点 1）对阶的时候要向右移动小阶的尾数,(▲E=Ex-Ey；>0则Y小，<0则X小，=0则相等不用对阶) 移动的位数与▲E有关 2）尾数的加减与定点加减法一样，采用补码进行
c语言float如何做减法,利用c语言设计开发一个简单计算器,可进行加减乘除运算....
weixin_31093677的博客
05-19 1173
共回答了18个问题采纳率：94.4%#include#includevoid add(float num1,float num2){printf("num1 + num2 = %6.2f", num1 + num2);}void sub(float num1,float num2){printf("num1 - num2 = %6.2f", num1 - num2);}void mul(float...
浮点数的加减运算
阳光大男孩！！！的博客
12-27 5675
前言 浮点数的加减运算大体可以分为五步。 我们用一个实例来逐步体会做法。 题目： X=0.1101 × 2+10 ,Y= - 0.1111×211,采用浮点数规格化形式求X+Y=？其中阶码4位(含阶符1位)，用补码表示，尾数6位(含尾符1位)。 在舍入时采用0舍1入法。 对X和Y进行表示： 阶码 尾符 尾数(补码形式) [X]浮 0010 0 11010 [Y]浮 0011...
计算机组成原理——浮点数的加减法
weixin_43752167的博客
06-10 8067
浮点加减法的运算步骤 前面已讲到,浮点数经常被写成如下的形式： 　　　　　　　　X　=　Mx * 2Ex 其中Mx为该浮点数的尾数,一般为绝对值小于1的规格化的二进制小数,机器中多用原码（或补码）形式表示。Ex为该浮点数的阶码,一般为二进制整数,机器中多用移码（或补码）表示，给出的是一个指数的幂，而该指数的底常用2、8或16,我们这里先以2为底作例子进行讨论。 浮点加减法的运算步骤 　　假定有...
c语言 浮点数的加减乘除,浮点数的加减乘除运算步骤
weixin_29964487的博客
05-24 3433
1、浮点加减法的运算步骤设两个浮点数 X=Mx※2Ex Y=My※2Ey实现X±Y要用如下5步完成：①对阶操作：小阶向大阶看齐②进行尾数加减运算③规格化处理：尾数进行运算的结果必须变成规格化的浮点数，对于双符号位的补码尾数来说，就必须是001×××…×× 或110×××…××的形式若不符合上述形式要进行左规或右规处理。④舍入操作：在执行对阶或右规操作时常用“0”舍“1”入法将右移出去的尾数数值进行...
浮点数的加法
qq_44895502的博客
05-27 2238
浮点数的加法：浮点数在相加时需要对阶，且运算顺序不同其结果也会不同。虽然两个浮点数进行加法运算时不会发生溢出，但在对阶时会出现大数吃小数的现象，从而导致运算结果错误。 一. 源代码部分 #include <stdio.h> #include <stdlib.h> #include <string.h> #define BUFSIZE 256 int main(...
单片机与DSP中的浮点数加减法模块程序设计
11-14
（1）包含必要的头文件及定义全局变量。 　来源:ks99
VHDL 32bit单精度浮点数加减法
10-24
VHDL 32bit单精度浮点数加减法，IEEE754单精度浮点数标准！
浮点数减法运算
05-26
linux下实现的浮点数精确计算，可以实现小数位借位
威纶通_宏指令_浮点数加减乘除开方计算机
06-07
用威纶通宏指令写的一个浮点数加减乘除开方计算机例子，威纶通宏指令学习参考
C语言 | Leetcode C语言题解之第45题跳跃游戏II
最新发布
m0_59237910的博客
04-23 361
C语言 | Leetcode C语言题解之第45题跳跃游戏II
【C】 初识C语言
努力学习C/C++
04-21 764
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
数据结构与算法学习笔记七--二叉树(C++)
我叫柱子哥
04-23 609
在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。根节点（Root）：树中的唯一顶层节点，没有父节点。
C++ WebServer的细节理解
我的博客
04-22 597
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
浮点数加减法阶码溢出
09-11
浮点数的加减法运算中可能发生阶码溢出。阶码溢出是指在运算过程中，阶码的值超出了浮点数表示范围所能表示的最大或最小值。 在浮点数运算中，阶码用于表示浮点数的指数部分，确定了浮点数的数量级。当两个浮点数相加或相减时，需要对阶码进行调整，使得两个操作数的阶码相等，再进行尾数的加减运算。 然而，当进行阶码调整时，可能会出现阶码溢出的情况。例如，当两个非常大的浮点数相加时，其阶码可能超出表示范围，导致无法正确表示结果。类似地，当两个非常小的浮点数相减时，阶码也可能溢出，导致结果无法正确表示。 为了避免阶码溢出，可以在进行浮点数运算前先检查操作数的阶码范围，并进行必要的处理。例如，可以通过缩放操作数的尾数来调整阶码，使其在有效表示范围内。此外，还可以使用更高精度的浮点数表示或者使用其他的数值计算方法来处理超出表示范围的运算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值