java实现施密特正交化

落日映苍穹つ 2023-02-12 11:19 30阅读 0赞

今天线代课刚学了这个

#### 施密特正交化 ####

然后今天老师布置的作业就是这个  
![在这里插入图片描述][20200525212503723.png]  
我这一看，这计算量，就我这计算水平，难免会有算错的

所以就自己写了个**程序帮我**计算，啊不对，是帮我**验证我算的对不对**

程序是**用java写的**(需要**装**了**jdk**才能运行)

!!!只做了正交，单位化暂时还没做，如果以后做出来的话我会再上传的

想用可以直接把代码复制粘贴过去就能用了，如果想看怎么实现的话，我觉得我写的注释应该能看得懂，哈哈哈，如果有什么疑问的话，可以在评论区留言哦

那废话不多说  
**代码如下:**

/* 本篇代码的命名极其的不规范(！！！请勿参考！！！) 英语不好，又懒得去百度翻译，所以好多命名就都是拼音，哈哈哈 */
 
 import java.util.Scanner;
 
 /** * 类名:{@code Test} * 功能: 用来测试和运行 * * @author 60rzvvbj * @data 2020/5/25 */
 class Test { 
 public static void main(String[] args) { 
 Shimitezhengjiao shimitezhengjiao = new Shimitezhengjiao();
 shimitezhengjiao.on();
 }
 }
 
 /** * 类名:{@code Shimitezhengjiao} * 功能: 将向量组施密特正交化 * 方法: * {@link #Shimitezhengjiao()}无参构造 * {@link #on()}启动 * * @author 60rzvvbj * @data 2020/5/25 */
 public class Shimitezhengjiao { 
 
 Shimitezhengjiao() { 
 //啥也没写，哈哈哈
 }
 
 /** * 方法名:{@code on} * 功能: 启动 * * @author 60rzvvbj * @data 2020/5/25 */
 public void on() { 
 Scanner sca = new Scanner(System.in);
 //先打印几句废话
 System.out.println("欢迎使用!");
 System.out.println("本程序可以利用施密特正交化方法，将向量组化为正交的向量组(单位化还在开发中)");
 System.out.println("作者: 60rzvvbj\n");
 while (true) { 
 //提示语
 System.out.println("请输入向量组中向量组的个数:");
 int n = sca.nextInt();
 sca.nextLine();
 System.out.println("请输入向量组:");
 //创建两个组向量，阿尔法和贝塔
 XiangLiang[] aErfa = new XiangLiang[n];
 XiangLiang[] beiTa = new XiangLiang[n];
 //输入值
 for (int i = 0; i < n; i++) { 
 String t = sca.nextLine();
 aErfa[i] = new XiangLiang(t);
 beiTa[i] = new XiangLiang(t);
 }
 //打印向量组阿尔法
 System.out.println("输入的向量组为:");
 for (int i = 0; i < n; i++) { 
 System.out.println("a" + (i + 1) + ":\t" + aErfa[i]);
 }
 //用施密特正交计算贝塔
 for (int i = 1; i < n; i++) { 
 for (int j = 0; j < i; j++) { 
 beiTa[i] = beiTa[i].jian(beiTa[j].shuCheng((aErfa[i].shuLiangJi(beiTa[j])).chu(beiTa[j].shuLiangJi(beiTa[j]))));
 }
 }
 //打印向量组贝塔
 System.out.println("\n正交向量组为:");
 for (int i = 0; i < n; i++) { 
 System.out.println("b" + (i + 1) + ":\t" + beiTa[i]);
 }
 //是否继续
 System.out.println("\n按1继续，其它键退出");
 String t = sca.nextLine();
 if (!"1".equals(t)) { 
 break;
 }
 }
 //释放资源
 sca.close();
 //卖一波萌
 System.out.println("谢谢使用!\nヾ(≧∪≦*)ノ〃");
 }
 }
 
 /** * 类名:{@code Fenshi} * 功能: 分式类 * 方法: * {@link #Fenshi(int)}构造方法(int) * {@link #Fenshi(Fenshi)}构造方法(Fenshi) * {@link #Fenshi(String)}构造方法(String) * {@link #getFenzi()}获取分子 * {@link #getFenmu()}获取分母 * {@link #toString()}重写的toString方法 * {@link #jia(Fenshi)}加法 * {@link #jian(Fenshi)}减法 * {@link #cheng(Fenshi)}乘法 * {@link #chu(Fenshi)}除法,除数为0会抛异常 * * @author 60rzvvbj * @data 2020/5/25 */
 class Fenshi { 
 /** * 分子 */
 private int fenzi;
 /** * 分母 */
 private int fenmu;
 /** * 正负号(true为正,false为负) */
 private boolean zhengfu = true;
 
 /** * 方法名:{@code Fenshi} * 功能: 用字符串创建一个分式，字符串格式为(-)+分子+/+分母 * * @param str 满足分式格式的字符串 * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi(String str) { 
 //用'/'分割字符串
 String[] zm = str.split("/");
 //分割后第一个转化成分子
 fenzi = Integer.parseInt(zm[0]);
 //调整正负号
 if (fenzi < 0) { 
 fenzi = -fenzi;
 zhengfu = false;
 }
 //如果有第二个，则把第二个转化成分母，如果没有，则分母为1
 fenmu = zm.length == 2 ? Integer.parseInt(zm[1]) : 1;
 //调整正负号
 if (fenmu < 0) { 
 fenmu = -fenmu;
 zhengfu = !zhengfu;
 }
 //约分
 yueFen();
 }
 
 /** * 方法名:{@code Fenshi} * 功能: 用一个分式创建一个新的分式 * * @param f 分式 * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi(Fenshi f) { 
 //将分子和分母赋值
 fenzi = f.getFenzi();
 fenmu = f.getFenmu();
 //调整正负号
 if (fenzi < 0) { 
 fenzi = -fenzi;
 zhengfu = false;
 }
 }
 
 /** * 方法名:{@code Fenshi} * 功能: 将一个整数转化成分式 * * @param x 整数 * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi(int x) { 
 //调整正负号，分子赋值分母为1
 if (x < 0) { 
 fenzi = -x;
 zhengfu = false;
 } else { 
 fenzi = x;
 }
 fenmu = 1;
 }
 
 /** * 方法名:{@code yueFen} * 功能: 将分式约分 * * @author 60rzvvbj * @data 2020/5/25 */
 private void yueFen() { 
 //如果分子为0的话，直接把分母变成1
 if (fenzi == 0) { 
 fenmu = 1;
 return;
 }
 //当分子分母都不是1的时候才约分，否则没必要约
 if (!(fenzi == 1 || fenmu == 1)) { 
 int t = Tool.gcd(fenzi, fenmu);
 fenzi /= t;
 fenmu /= t;
 }
 }
 
 /** * 方法名:{@code toString} * 功能: 将分式转化成字符串 * * @author 60rzvvbj * @data 2020/5/25 */
 @Override
 public String toString() { 
 return (zhengfu ? "" : "-") + (fenmu == 1 ? fenzi : fenzi + "/" + fenmu);
 }
 
 /** * 方法名:{@code getFenzi} * 功能: 获取分子 * * @author 60rzvvbj * @data 2020/5/25 */
 public int getFenzi() { 
 return zhengfu ? fenzi : -fenzi;
 }
 
 /** * 方法名:{@code getFenmu} * 功能: 获取分母 * * @author 60rzvvbj * @data 2020/5/25 */
 public int getFenmu() { 
 return fenmu;
 }
 
 /** * 方法名:{@code jia} * 功能: 返回this与x的和 * * @param x 加数 * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi jia(Fenshi x) { 
 //分子直接交叉相成在相加，分母是原来两个数的分母相乘
 return new Fenshi((this.getFenzi() * x.getFenmu() + x.getFenzi() * fenmu) + "/" + (fenmu * x.getFenmu()));
 }
 
 /** * 方法名:{@code jian} * 功能: 返回this与x的差 * * @param x 减数 * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi jian(Fenshi x) { 
 //分子直接交叉相成在相减，分母是原来两个数的分母相乘
 return new Fenshi((this.getFenzi() * x.getFenmu() - fenmu * x.getFenzi()) + "/" + (fenmu * x.getFenmu()));
 }
 
 /** * 方法名:{@code cheng} * 功能: 返回this与x的积 * * @param x 乘数 * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi cheng(Fenshi x) { 
 //分子相乘，分母相乘
 return new Fenshi((this.getFenzi() * x.getFenzi()) + "/" + (fenmu * x.getFenmu()));
 }
 
 /** * 方法名:{@code jia} * 功能: 返回this与x的商，除数为0会抛出异常 * * @param x 除数 * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi chu(Fenshi x) { 
 //如果除数为0则抛出异常
 if (x.getFenzi() == 0) { 
 throw new ArithmeticException("除数不能为0");
 }
 //除就是乘倒数
 return new Fenshi((this.getFenzi() * x.getFenmu()) + "/" + (fenmu * x.getFenzi()));
 }
 }
 
 /** * 类名:{@code XiangLiang} * 功能: 向量类,里面的坐标是分式 * 方法: * {@link #XiangLiang(String)}构造方法(String) * {@link #XiangLiang(Fenshi[])}构造方法(Fenshi[]) * {@link #getFenshi(int)}获取分式数组中某个分式 * {@link #getFenshis()}获取分式数组 * {@link #toString()}重写的toString方法 * {@link #jia(XiangLiang)}向量加法 * {@link #jian(XiangLiang)}向量减法 * {@link #shuCheng(Fenshi)}向量数乘 * {@link #shuLiangJi(XiangLiang)}求数量积 * * @author 60rzvvbj * @data 2020/5/25 */
 class XiangLiang { 
 /** * 保存向量值的分式数组 */
 private final Fenshi[] fenshis;
 
 /** * 方法名:{@code XiangLiang} * 功能: 用字符串构造一个向量，字符串格式为 分式 分式 ... 分式 ，分式之间用空格隔开 * * @param str 满足向量格式的字符串 * @author 60rzvvbj * @data 2020/5/25 */
 public XiangLiang(String str) { 
 //用空格分割字符串
 String[] t = str.split(" ");
 //用分割出来的字符串数组对分式数组赋值
 fenshis = new Fenshi[t.length];
 for (int i = 0; i < t.length; i++) { 
 fenshis[i] = new Fenshi(t[i]);
 }
 }
 
 /** * 方法名:{@code XiangLiang} * 功能: 用分式数组构造向量 * * @param f 分式数组 * @author 60rzvvbj * @data 2020/5/25 */
 public XiangLiang(Fenshi[] f) { 
 //直接复制一份分式数组
 fenshis = new Fenshi[f.length];
 for (int i = 0; i < f.length; i++) { 
 fenshis[i] = new Fenshi(f[i]);
 }
 }
 
 /** * 方法名:{@code toString} * 功能: 将向量转化成字符串格式 * * @author 60rzvvbj * @data 2020/5/25 */
 @Override
 public String toString() { 
 String str = "(";
 for (int i = 0; i < fenshis.length; i++) { 
 str += fenshis[i] + ",";
 }
 str = str.substring(0, str.length() - 1);
 str += ")";
 return str;
 }
 
 /** * 方法名:{@code getFenshi} * 功能: 获取分是数组中某个分式 * * @param index 要获取的分式的索引 * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi getFenshi(int index) { 
 return fenshis[index];
 }
 
 /** * 方法名:{@code getFenshis} * 功能: 获取整个分式数组 * * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi[] getFenshis() { 
 return fenshis;
 }
 
 /** * 方法名:{@code jia} * 功能: 返回当前向量与向量x相加后的结果 * * @param x 向量x * @author 60rzvvbj * @data 2020/5/25 */
 public XiangLiang jia(XiangLiang x) { 
 //对应分量相加
 Fenshi[] t = new Fenshi[fenshis.length];
 for (int i = 0; i < fenshis.length; i++) { 
 t[i] = fenshis[i].jia(x.getFenshi(i));
 }
 return new XiangLiang(t);
 }
 
 /** * 方法名:{@code jian} * 功能: 返回当前向量与向量x相减后的结果 * * @param x 向量x * @author 60rzvvbj * @data 2020/5/25 */
 public XiangLiang jian(XiangLiang x) { 
 //对应分量相减
 Fenshi[] t = new Fenshi[fenshis.length];
 for (int i = 0; i < fenshis.length; i++) { 
 t[i] = fenshis[i].jian(x.getFenshi(i));
 }
 return new XiangLiang(t);
 }
 
 /** * 方法名:{@code shuCheng} * 功能: 返回当前向量与分式f数乘后的结果 * * @param f 分式f * @author 60rzvvbj * @data 2020/5/25 */
 public XiangLiang shuCheng(Fenshi f) { 
 //每个分量都乘f
 Fenshi[] t = new Fenshi[fenshis.length];
 for (int i = 0; i < fenshis.length; i++) { 
 t[i] = fenshis[i].cheng(f);
 }
 return new XiangLiang(t);
 }
 
 /** * 方法名:{@code shuLiangJi} * 功能: 返回当前向量与向量x的数量积 * * @param x 向量x * @author 60rzvvbj * @data 2020/5/25 */
 public Fenshi shuLiangJi(XiangLiang x) { 
 //对应分量相乘在相加
 Fenshi t = new Fenshi(0);
 for (int i = 0; i < fenshis.length; i++) { 
 t = t.jia(fenshis[i].cheng(x.getFenshi(i)));
 }
 return t;
 }
 
 }
 
 /** * 类名:{@code Tool} * 功能: 工具类 * 方法: * {@link #gcd(int, int)}返回两个数的最大公约数 * * @author 60rzvvbj * @data 2020/5/25 */
 class Tool { 
 /** * 方法名:{@code gcd} * 功能: 返回两个数的最大公约数 * * @param a 第一个数 * @param b 第二个数 * @author 60rzvvbj * @data 2020/5/25 */
 public static int gcd(int a, int b) { 
 //让a b) { 
 a ^= b;
 b ^= a;
 a ^= b;
 }
 //然后遍历a到1
 for (int i = a; i >= 1; i--) { 
 if (a % i == 0 && b % i == 0) { 
 return i;
 }
 }
 return 0;
 }
 }

#### 运行结果: ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljeDYwcnp2dmJq_size_16_color_FFFFFF_t_70]

最后再提醒一下，用程序计算虽然可以减轻我们的计算负担，但是**不要过度依赖程序**哦，计算能力和耐心还是要锻炼的。

#### 好了，就这些，不喜勿喷哦 ####

ヾ(≧∪≦\*)ノ〃

[20200525212503723.png]: https://img-blog.csdnimg.cn/20200525212503723.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljeDYwcnp2dmJq_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200525214208628.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ljeDYwcnp2dmJq,size_16,color_FFFFFF,t_70