Matlab中有二进制转十进制的函数，“bin2dec”，示例如下：



但是这个函数只能进行整数转换，如果有小数的话：



由于需要，最近写了一个小程序，实现带小数的二进制转十进制，先看代码：

clc
clear all
% 整数部分
bit1 = 3;
bit_integer = [0,1,0];
% 小数部分
bit2 = 2;
bit_decimal = [1，0];
integer = 0;
decimal = 0;
% 计算整数部分
for i = 1 : bit1
    integer = integer + bit_integer(i) * (2^(bit1 -i));
end
% 计算小数部分
for j = 1 : bit2
    decimal = decimal + bit_decimal(j) * (2^(-j));
end
% 整合
param = integer + decimal;

程序其实很简单，就是按照二进制转十进制的规则进行转化，需要人为输入的地方就是整数部分、整数部分的比特位数，小数部分、小数部分的比特位数。

欢迎各位交流指正！

用matlab实现一些简单的信号处理程序时，经常会碰到处理信息序列的情况，这些信息序列通常由N个码元所构成，而在做处理前我们常常需要将其做二进制转换。以下以八进制序列转二进制序列为例：
origin = randi(8, 1,Length)-1;    	% 八进制信息序列生成
x = reshape((de2bi(origin))’,1,3*(Length));  	% 二进制信息流生成
randi（K,M,N）产生大小为1到K的M x N随机数矩阵，这里的信息为1 x Length的一条序列，即一串Length个码元的信息，每个码元有 0-7 八种出现可能，因此转化为二进制序列时每三位代表信息序列的一位，即二进制序列为1 x (3*Length)；
de2bi 将十进制数矩阵转化为二进制数矩阵，但这里输出的矩阵的信息排序会从行变成列，

即Length x 3；
矩阵外加上一个 ’ 号则表示转置矩阵，将行列进行互换，这样使得上述矩阵重排列为3 x Length的矩阵；
最后我们希望得到的是一串1 x (3*Length)的序列，因此只需利用reshape重新排列，

reshape（X,M,N）函数通过对原矩阵X按列逐个输入再按列逐个输出，最后生成M x N的矩阵。
恢复也类似，如下：

y = reshape(x,3,Length);    %变回码元个数

receive = (bi2de(y’))’;        %最终信息流恢复

用java实现十进制与二进制小数的互转机制

  本篇博客主要讲述用java实现十进制与二进制小数的互转（不调用java自带的函数）。后期可能会用MATLAB实现，因为我们信息安全的一个实验是要求用MATLAB实现的。

要求

信息安全课程的一个实验要求 

1、 编写程序实现十进制小数x=0.7 的二进制转换，并分析其误差（即重新将二进制小数转成十进制小数，和原十进制小数进行比较。） 

2、编程实现十进制数 x=5.9的二进制转换。

思路

  第二小题的思路，就是将十进制分开为整数部分和小数部分分来实现。

实现

MATLA实现



%%
clear
clc
n=0.7;
m=20;%保留10位小数
%将十进制乘以2用floor取整，接着用其余数进行循环操作
d=char(mod(floor(n*2.^(1:m)),2)+'0');%char函数创建一个字符矩阵
d1=[d(1:end-m),'.',d(end-m+1:end)]%显示二进制转换小数
f=d-'0';
f1=sum(f./(2.^(1:m)))   %% 二进制转换十进制
error = n-f1


java语言实现 

执行环境：JDK1.8，IntelliJ IDEA 2017.3.4 x64。

import static java.lang.System.out;
/**
 * 实现二进制与十进制的互换
 * @author Canlong
 * @time 2018/4/13
 */
public class Test3 {

    /**
     * 1、 编写程序实现十进制小数x=0.7 的二进制转换，并分析其误差（即重新将二进制小数转成十进制小数，和原十进制小数进行比较。）
     2、编程实现十进制数 x=5.9的二进制转换。
     * @param args
     */
    public static void main(String[] args){
    //要转化的十进制小数
        double x = 0.7;
        //将十进制小数转化为二进制
        String binXStr = decXiao2Bin(x);
        //将二进制小数转化为十进制
        double decX = bin2DecXiao(binXStr);
        out.println("误差为："+(x-decX));

        //将十进制数转化为二进制
        double decX1 = 5.9;
        int decInt = (int) Math.floor(decX1);
        double decXiao = decX1-decInt;
        String  binInt = decInt2Bin(decInt);
        String binX = decXiao2Bin(decXiao);
        out.println("5对应的二进制为："+binInt);
        out.println("5.9对应的二进制为："+binInt+"."+binX);
    }
    //将十进制整数转换为二进制
    public static String decInt2Bin(int decInt){
        int index = 0;
        int rem = 1;
        String binStr="";
        while(decInt!=1){
            rem = decInt%2;
            decInt = decInt/2;
            binStr += Integer.toString(rem);
            if(decInt == 1){
               binStr+=Integer.toString(decInt);
            }
        }
        return binStr;
    }

    /**
     * 将十进制小数转化为二进制
     */
    public static String decXiao2Bin(double x){
        //精确位数
        int accurate = 100;
        int[] binX = new int[accurate];
        String binXSB="";
        double x1 = x;
        double x2=0;
        for(int i=0;i<binX.length;i++){
            x2 = x1+x1;
            x1 =Math.floor(x2);
            binX[i]=(int)x1;
            x1=x2-x1;
            binXSB += Integer.toString(binX[i]);
        }
        String binXStr = binXSB.toString();
        out.println(x+"的近似二进制数为（精确到小数点后"+accurate+"位）："+binXStr);
        return  binXStr;
    }

    /**
     * 将二进制小数转化为十进制
     * @param binXStr 二进制小数
     * @return 十进制小数
     */
    public static double bin2DecXiao(String binXStr){
        double decX = 0.0;
        //位数
        int k =0;
        for(int i=0;i<binXStr.length();i++){
            int exp = binXStr.charAt(i)-'0';
            exp = -(i+1)*exp;
            if(exp!=0) {
                decX += Math.pow(2, exp);
            }
        }
        out.println("二进制小数为;"+binXStr+"。\r\n其对应的十进制为："+decX);
        return decX;
    }
}

结果



误差分析： 

  测试了多次，java代码和matlab中将十进制小数转化为二进制小数，如果使用double来存储，最多只能转化到二进制到小数点后53位，再往后的数都为0。而且由于double类型的数值，java只能存储到小数点后16位，只要在这个范围内，利用以上的转化代码，产生的误差都为0。至于为什么利用数组存储二进制也只能存储到二进制数后53位，该原因还有待探索。初步怀疑由于十进制小数转化为二进制小数时不断减去整数部分，最终导致小数部分很少，即使进行了多次加倍，仍然无法达到1或者是计算机存储某个小数最多的二进制小数就是小数点后53位。 

  后来经过输出每一步的转化的十进制小数，发现每次都在第50步左右，十进制小数就变成了0.5，所以原因应该是只要是十进制小数为小数点16位以内，都可以通过50次加倍（加倍前去掉整数部分）变成0。

总结

  总的来说，这个实现起来并没有太大难度，只是由于自己对于方法运行的不熟悉，而导致自己写了很多多余的代码的和浪费了很多时间才能把这个课堂实验做完。下次有机会再完善一下。至于实现的原理，也在下次有机会的时候再说。其实java内部有函数实现十进制和二进制的互换的，但是经过自己把二进制和十进制的转换从原理级别上去实现后，能够锻炼了自己的思维能力。经过这次的实践，发现自己对于二进制与十进制转化的理论还没有太熟悉，java实现起来也效率极低。不过经过这次实践，我对这个转换的理论和实践部分的理解都加深了不少，后面会继续学习。

本来想从网上找现有的代码省点时间...但是最后看了很多代码还是自己各种修改重写。

香农编码的规则非常简单，用matlab实现起来也非常简单~就当作做作业时候的计算器啦。

代码如下：

辅助的函数：

function y = dectobin(num,L)
%十进制小数转换为指定位数的二进制数
%num为输入的十进制小数
%L为指定转换后二进制的位数
i = 0;
bin = zeros(1,L);
for k = 1:L
i = i+1;
num = num * 2;%小数转换为二进制,乘2取整
    if num >= 1%乘积大于一
        bin(i) = 1;%二进制此位为1
        num = num - 1;
    else
       bin(i) = 0;  %否则，二进制此位为0
    end
    if(i >= L)%截取所需位数
        break;
    end
end
y = bin;

主函数：

function [ s_code,ave_L ] = Shannon_code( p )
%香农编码
%p为降序排列的概率分布（便于需编码字符与输出编码对应）
%s_code储存香农编码
%ave_L为平均码长
px = sort(p,'descend');%按降序排列
N = length(px);%需编码的字符数目
ave_L = 0;
s_code={};
for i = 1:N
    %求累加概率
    p_sum = 0;  
    if (i==1)
        p_sum=0;
    else
    for k = 1:i-1
        p_sum = p_sum + px(k);
    end
    end
    %求码长
    if (i == 1)
        L = ceil(-log2(px(i)));  %向上取整
        y = zeros(1,L); %全0
        
    else
        L = ceil(-log2(px(i)));%L为码长
        y = dectobin(p_sum,L);%十进制小数转化为二进制，截取L位
    end
     %求平均码长
    ave_L = ave_L + px(i) * L; 
    s_code{i}=y;
end  


完成~

这个程序真的超级简单啊，最近一定要花时间写一篇有关任意进制哈夫曼编码matlab实现程序的思路的文章！毕竟好不容易写出来都被自己给机智到了嘿嘿嘿~