java实现生成高斯分布（0，1）随机数的函数

高斯0-1分布就是正态0-1随机分布。

我们提供的服务有：成都网站设计、成都网站建设、微信公众号开发、网站优化、网站认证、英吉沙ssl等。为上千余家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的英吉沙网站制作公司

在java中可用如下语句：

a=5;b=6;c=7;

A=randn(a);%生成正方矩阵

A=randn(a,b);%生成非正方矩阵

A=randn(a,b,c);%生成三维矩阵

怎么用Java写高斯回归方程

高斯消元法（或译：高斯消去法），是线性代数规划中的一个算法，可用来为线性方程组求解。但其算法十分复杂，不常用于加减消元法，求出矩阵的秩，以及求出可逆方阵的逆矩阵。不过，如果有过百万条等式时，这个算法会十分省时。

一些极大的方程组通常会用迭代法以及花式消元来解决。当用于一个矩阵时，高斯消元法会产生出一个“行梯阵式”。

高斯消元法可以用在电脑中来解决数千条等式及未知数。亦有一些方法特地用来解决一些有特别排列的系数的方程组。

如何用java编写naivebayes

1.关于贝叶斯分类

bayes 是一种统计学分类方法，它基于贝叶斯定理，它假定一个属性值对给定类的影响独立于其它属性点的值。该假定称作类条件独立。做次假定是为了简化所需计算，并在此意义下称为“朴素的”。

bayes分类的算法大致如下：

（1）对于属性值是离散的，并且目标label值也是离散的情况下。分别计算label不同取值的概率，以及样本在label情况下的概率值，然后将这些概率值相乘最后得到一个概率的乘积，选择概率乘积最大的那个值对应的label值就为预测的结果。

例如以下：是预测苹果在给定属性的情况是甜还是不甜的情况：

color={0,1,2,3} weight={2,3,4};是属性序列，为离散型。sweet={yes,no}是目标值，也为离散型；

这时我们要预测在color=3,weight=3的情况下的目标值，计算过程如下：

P{y=yes}=2/5=0.4; P{color=3|yes}=1/2=0.5;P{weight=3|yes}=1/2=0.5; 故F{color=3,weight=3}取yesd的概率为 0.4*0.5*0.5=0.1;

P{y=no}=3/5=0.6; P{color=3|no}=1/3 P{weight=3|no}=1/3; 故P{color=3,weight=3}取no为 0.6*1/3*1/3=1/15;

0.11/15 所以认为 F{color=3,weight=3}=yes;

(2)对于属性值是连续的情况，思想和离散是相同的，只是这时候我们计算属性的概率用的是高斯密度：

这里的Xk就是样本的取值，u是样本所在列的均值，kesi是标准差；

最后代码如下：

/*

* To change this template, choose Tools | Templates

* and open the template in the editor.

*/

package auxiliary;

import java.util.ArrayList;

/**

*

* @author Michael Kong

*/

public class NaiveBayes extends Classifier {

boolean isClassfication[];

ArrayList DoublelblClass=new ArrayListDouble(); //存储目标值的种类

ArrayListIntegerlblCount=new ArrayListInteger();//存储目标值的个数

ArrayListFloatlblProba=new ArrayListFloat();//存储对应的label的概率

CountProbility countlblPro;

/*@ClassListBasedLabel是将训练数组按照 label的顺序来分类存储*/

ArrayListArrayListArrayListDouble ClassListBasedLabel=new ArrayListArrayListArrayListDouble ();

public NaiveBayes() {

}

@Override

/**

* @train主要完成求一些概率

* 1.labels中的不同取值的概率f(Yi); 对应28,29行两段代码

* 2.将训练数组按目标值分类存储 第37行代码

* */

public void train(boolean[] isCategory, double[][] features, double[] labels){

isClassfication=isCategory;

countlblPro=new CountProbility(isCategory,features,labels);

countlblPro.getlblClass(lblClass, lblCount, lblProba);

ArrayListArrayListDouble trainingList=countlblPro.UnionFeaLbl(features, labels); //union the features[][] and labels[]

ClassListBasedLabel=countlblPro.getClassListBasedLabel(lblClass, trainingList);

}

@Override

/**3.在Y的条件下，计算Xi的概率 f(Xi/Y)；

* 4.返回使得Yi*Xi*...概率最大的那个label的取值

* */

public double predict(double[] features) {

int max_index; //用于记录使概率取得最大的那个索引

int index=0; //这个索引是 标识不同的labels 所对应的概率

ArrayListDouble pro_=new ArrayListDouble(); //这个概率数组是存储features[] 在不同labels下对应的概率

for(ArrayListArrayListDouble elements: ClassListBasedLabel) //依次取不同的label值对应的元祖集合

{

ArrayListDouble pro=new ArrayListDouble();//存同一个label对应的所有概率，之后其中的元素自乘

double probility=1.0; //计算概率的乘积

for(int i=0;ifeatures.length;i++)

{

if(isClassfication[i]) //用于对属性的离散还是连续做判断

{

int count=0;

for(ArrayListDouble element:elements) //依次取labels中的所有元祖

{

if(element.get(i).equals(features[i])) //如果这个元祖的第index数据和b相等，那么就count就加1

count++;

}

if(count==0)

{

pro.add(1/(double)(elements.size()+1));

}

else

pro.add(count/(double)elements.size()); //统计完所有之后 计算概率值 并加入

}

else

{

double Sdev;

double Mean;

double probi=1.0;

Mean=countlblPro.getMean(elements, i);

Sdev=countlblPro.getSdev(elements, i);

if(Sdev!=0)

{

probi*=((1/(Math.sqrt(2*Math.PI)*Sdev))*(Math.exp(-(features[i]-Mean)*(features[i]-Mean)/(2*Sdev*Sdev))));

pro.add(probi);

}

else

pro.add(1.5);

}

}

for(double pi:pro)

probility*=pi; //将所有概率相乘

probility*=lblProba.get(index);//最后再乘以一个 Yi

pro_.add(probility);// 放入pro_ 至此 一个循环结束，

index++;

}

double max_pro=pro_.get(0);

max_index=0;

for(int i=1;ipro_.size();i++)

{

if(pro_.get(i)=max_pro)

{

max_pro=pro_.get(i);

max_index=i;

}

}

return lblClass.get(max_index);

}

public class CountProbility

{

boolean []isCatory;

double[][]features;

private double[]labels;

public CountProbility(boolean[] isCategory, double[][] features, double[] labels)

{

this.isCatory=isCategory;

this.features=features;

this.labels=labels;

}

//获取label中取值情况

public void getlblClass( ArrayList DoublelblClass,ArrayListIntegerlblCount,ArrayListFloatlblProba)

{

int j=0;

for(double i:labels)

{

//如果当前的label不存在于lblClass则加入

if(!lblClass.contains(i))

{

lblClass.add(j,i);

lblCount.add(j++,1);

}

else //如果label中已经存在，就将其计数加1

{

int index=lblClass.indexOf(i);

int count=lblCount.get(index);

lblCount.set(index,++count);

}

}

for(int i=0;ilblClass.size();i++)

{

// System.out.println("值为"+lblClass.get(i)+"的个数有"+lblCount.get(i)+"概率是"+lblCount.get(i)/(float)labels.length);

lblProba.add(i,lblCount.get(i)/(float)labels.length);

}

}

//将label[]和features[][]合并

public ArrayListArrayListDouble UnionFeaLbl(double[][] features, double[] labels)

{

ArrayListArrayListDoubletraingList=new ArrayListArrayListDouble();

for(int i=0;ifeatures.length;i++)

{

ArrayListDoubleelements=new ArrayListDouble();

for(int j=0;jfeatures[i].length;j++)

{

elements.add(j,features[i][j]);

}

elements.add(features[i].length,labels[i]);

traingList.add(i,elements);

}

return traingList;

}

/*将测试数组按label的值分类存储*/

public ArrayListArrayListArrayListDouble getClassListBasedLabel (ArrayList DoublelblClass,ArrayListArrayListDoubletrainingList)

{

ArrayListArrayListArrayListDouble ClassListBasedLabel=new ArrayListArrayListArrayListDouble () ;

for(double num:lblClass)

{

ArrayListArrayListDouble elements=new ArrayListArrayListDouble();

for(ArrayListDoubleelement:trainingList)

{

if(element.get(element.size()-1).equals(num))

elements.add(element);

}

ClassListBasedLabel.add(elements);

}

return ClassListBasedLabel;

}

public double getMean(ArrayListArrayListDouble elements,int index)

{

double sum=0.0;

double Mean;

for(ArrayListDouble element:elements)

{

sum+=element.get(index);

}

Mean=sum/(double)elements.size();

return Mean;

}

public double getSdev(ArrayListArrayListDouble elements,int index)

{

double dev=0.0;

double Mean;

Mean=getMean(elements,index);

for(ArrayListDouble element:elements)

{

dev+=Math.pow((element.get(index)-Mean),2);

}

dev=Math.sqrt(dev/elements.size());

return dev;

}

}

}

求ECDSA的Java代码

【方案1】

package ECDSA;

import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;

import java.security.*;

import java.security.interfaces.ECPrivateKey;

import java.security.interfaces.ECPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

public class Ecdsa {

private static String src = "hello berber" ;

public static void main(String []args){

  jdkECDSA();

}

public static void jdkECDSA(){

  // 1.初始化密钥

  try{

      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");

      keyPairGenerator.initialize(256);

      KeyPair keyPair = keyPairGenerator.generateKeyPair() ;

      ECPublicKey ecPublicKey = (ECPublicKey)keyPair.getPublic() ;

      ECPrivateKey ecPrivateKey = (ECPrivateKey)keyPair.getPrivate() ;

      // 执行签名

      PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(ecPrivateKey.getEncoded());

      KeyFactory keyFactory = KeyFactory.getInstance("EC") ;

      PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec) ;

      Signature signature = Signature.getInstance("SHA1withECDSA");

      signature.initSign(privateKey);

      signature.update(src.getBytes());

      byte []arr = signature.sign();

      System.out.println("jdk ecdsa sign :"+ HexBin.encode(arr));

      // 验证签名

      X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(ecPublicKey.getEncoded());

      keyFactory = KeyFactory.getInstance("EC");

      PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);

      signature = Signature.getInstance("SHA1withECDSA");

      signature.initVerify(publicKey);

      signature.update(src.getBytes());

      boolean bool = signature.verify(arr);

      System.out.println("jdk ecdsa verify:"+bool);

  }catch(Exception e){

  }

}

}

Java数字签名——ECDSA算法

【方案2】

public class MyTest {

/**

* @param args

*/

public static void main(String[] args) {

new MyTest().getSign();

}

void getSign() {

// Get the instance of the Key Generator with "EC" algorithm

try {

KeyPairGenerator g = KeyPairGenerator.getInstance("EC");

ECGenParameterSpec kpgparams = new ECGenParameterSpec("secp256r1");

g.initialize(kpgparams);

KeyPair pair = g.generateKeyPair();

// Instance of signature class with SHA256withECDSA algorithm

Signature ecdsaSign = Signature.getInstance("SHA256withECDSA");

ecdsaSign.initSign(pair.getPrivate());

System.out.println("Private Keys is::" + pair.getPrivate());

System.out.println("Public Keys is::" + pair.getPublic());

String msg = "text ecdsa with sha256";//getSHA256(msg)

ecdsaSign.update((msg + pair.getPrivate().toString())

.getBytes("UTF-8"));

byte[] signature = ecdsaSign.sign();

System.out.println("Signature is::"

+ new BigInteger(1, signature).toString(16));

// Validation

ecdsaSign.initVerify(pair.getPublic());

ecdsaSign.update(signature);

if (ecdsaSign.verify(signature))

System.out.println("valid");

else

System.out.println("invalid!!!!");

} catch (Exception e) {

// TODO: handle exception

e.printStackTrace();

}

}}

java – 使用secp256r1曲线和SHA256算法生

怎么验证生成的Ecdsa签名是正确的呢，可以看下这篇文章:RSA,ECC,Ecdsa,国密SM2的签名，验签，加密

网页标题：java高斯算法代码 数学高斯算法
网站URL：http://chengdu.cdxwcx.cn/article/ddschps.html