基于组件软件可信度量

基于组件软件可信度量

课程：软件质量分析

作业

请添加图片描述

可编写下面的java程序：

package org.example;

import java.util.Arrays;

public class ComponentBasedMeasurementModel {
    public static void main(String[] args) {
        double[][] keyComponentJudgmentMatrix = {
                {1.0, 2.0, 1.0 / 2.0, 2.0, 1.0 / 4.0},
                {1.0 / 2.0, 1.0, 2.0, 3.0, 1.0 / 2.0},
                {2.0, 1.0 / 2.0, 1.0, 1.0, 1.0 / 2.0},
                {1.0 / 2.0, 1.0 / 3.0, 1.0, 1.0, 1.0 / 2.0},
                {4.0, 2.0, 2.0, 2.0, 1.0}
        };
        double[][] non_keyComponentJudgmentMatrix = {
                {1.0, 3.0, 2.0, 1.0 / 2.0, 2.0, 1.0, 3.0, 3.0},
                {1.0 / 3.0, 1.0, 2.0, 1.0, 2.0, 2.0, 2.0, 2.0},
                {1.0 / 2.0, 1.0 / 2.0, 1.0, 1.0 / 2.0, 1.0, 1.0 / 2.0, 3.0, 3.0},
                {2.0, 1.0, 2.0, 1.0, 3.0, 1.0 / 2.0, 3.0, 3.0},
                {1.0 / 2.0, 1.0 / 2.0, 1.0, 1.0 / 3.0, 1.0, 1.0, 2.0, 2.0},
                {1.0, 1.0 / 2.0, 2.0, 2.0, 1.0, 1.0, 2.0, 2.0},
                {1.0 / 3.0, 1.0 / 2.0, 1.0 / 3.0, 1.0 / 3.0, 1.0 / 2.0, 1.0 / 2.0, 1.0, 2.0},
                {1.0 / 3.0, 1.0 / 2.0, 1.0 / 3.0, 1.0 / 3.0, 1.0 / 2.0, 1.0 / 2.0, 1.0 / 2.0, 1.0}
        };
        double[][] componentWeights = {
                {0.7, 0.3},
                {0.6, 0.4},
                {0.55, 0.45},
        };
        double[] keyComponentTrustworthiness = {8.430, 8.530, 6.042, 9.094, 8.289};
        double[] non_keyComponentTrustworthiness = {6.192, 8.020, 7.984, 8.713, 9.211, 7.777, 7.897, 8.075};
        double[] keyComponentWeightVector = CalculatingOptimalWeightVector.finalOptimalWeightVector(keyComponentJudgmentMatrix);
        double[] non_keyComponentWeightVector = CalculatingOptimalWeightVector.finalOptimalWeightVector(non_keyComponentJudgmentMatrix);

        for (double[] componentWeight : componentWeights) {
            double T = calculateSystemTrustworthinessMeasurementValue(componentWeight, keyComponentWeightVector, non_keyComponentWeightVector, keyComponentTrustworthiness, non_keyComponentTrustworthiness);
            System.out.println("关键组件组与非关键组件组的权重取" + Arrays.toString(componentWeight) + "的情况下，游戏服务器系统的可信度量值T为：" + T + "；可信等级Level为：" + getLevel(T, keyComponentTrustworthiness));
        }
    }

    public static double calculateSystemTrustworthinessMeasurementValue(double[] componentWeight, double[] keyComponentWeightVector, double[] non_keyComponentWeightVector, double[] keyComponentTrustworthiness, double[] non_keyComponentTrustworthiness) {
        double keyComponent = 1.0;
        double non_keyComponent = 1.0;
        for (int i = 0; i < keyComponentWeightVector.length; i++) {
            keyComponent *= Math.pow(keyComponentTrustworthiness[i], keyComponentWeightVector[i]);
        }
        for (int i = 0; i < non_keyComponentWeightVector.length; i++) {
            non_keyComponent *= Math.pow(non_keyComponentTrustworthiness[i], non_keyComponentWeightVector[i]);
        }
        return keyComponent * componentWeight[0] + non_keyComponent * componentWeight[1];
    }
    
    public static int getLevel(double T, double[] keyComponents) {
        if (T >= 9.5 && levelDivide(5, keyComponents)) {
            return 5;
        } else if (T >= 8.5 && levelDivide(4, keyComponents)) {
            return 4;
        } else if (T >= 7.0 && levelDivide(3, keyComponents)) {
            return 3;
        } else if (T >= 4.5 && levelDivide(2, keyComponents)) {
            return 2;
        } else {
            return 1;
        }
    }

    public static boolean levelDivide(int level ,double[] keyComponents) {
        int count = 0;
        boolean flag = true;
        if (level == 1) {
            return true;
        } else if (level == 2) {
            for (double attribute : keyComponents) {
                if (attribute < 4.5) {
                    count++;
                }
            }
            return count <= keyComponents.length - Math.ceil(keyComponents.length * 2.0 / 3.0);
        } else if (level == 3) {
            for (double attribute : keyComponents) {
                if (attribute < 7.0) {
                    count++;
                }
                if (attribute < 4.5) {
                    flag = false;
                }
            }
            return count <= keyComponents.length - Math.ceil(keyComponents.length * 2.0 / 3.0) && flag;
        } else if (level == 4) {
            for (double attribute : keyComponents) {
                if (attribute < 8.5) {
                    count++;
                }
                if (attribute < 7.0) {
                    flag = false;
                }
            }
            return count <= keyComponents.length - Math.ceil(keyComponents.length * 2.0 / 3.0) && flag;
        } else {
            for (double attribute : keyComponents) {
                if (attribute < 9.5) {
                    count++;
                }
                if (attribute < 8.5) {
                    flag = false;
                }
            }
            return count <= keyComponents.length - Math.ceil(keyComponents.length * 2.0 / 3.0) && flag;
        }
    }
}

package org.example;

import Jama.EigenvalueDecomposition;
import Jama.Matrix;

import java.util.Random;

public class CalculatingOptimalWeightVector {

//    public static void main(String[] args) {
//        double[][] data = {
//                {1.0, 1.0/2.0, 3.0, 2.0, 1.0/2.0},
//                {2.0, 1.0, 2.0, 3.0, 2.0},
//                {1.0/3.0, 1.0/2.0, 1.0, 2.0, 1.0/3.0},
//                {1.0/2.0, 1.0/3.0, 1.0/2.0, 1.0, 2.0},
//                {2.0, 1.0/2.0, 3.0, 1.0/2.0, 1.0}
//        };
//
//        double[] EV_weight = EV_OptimalWeightVector(data);
//        double[] LLSM_weight = LLSM_OptimalWeightVector(data);
//        double[] CSM_weight = CSM_OptimalWeightVector(data);
//        System.out.println("EV_weight: " + java.util.Arrays.toString(EV_weight));
//        System.out.println("LLSM_weight: " + java.util.Arrays.toString(LLSM_weight));
//        System.out.println("CSM_weight: " + java.util.Arrays.toString(CSM_weight));
//
//        double EV_accuracy = strengthEvaluateCriteria(data, EV_weight);
//        double LLSM_accuracy = strengthEvaluateCriteria(data, LLSM_weight);
//        double CSM_accuracy = strengthEvaluateCriteria(data, CSM_weight);
//        System.out.println("EV_accuracy: " + EV_accuracy);
//        System.out.println("LLSM_accuracy: " + LLSM_accuracy);
//        System.out.println("CSM_accuracy: " + CSM_accuracy);
//
//        double result = Math.min(EV_accuracy, Math.min(LLSM_accuracy, CSM_accuracy));
//        String resultStr = result == EV_accuracy ? "EV" : result == LLSM_accuracy ? "LLSM" : "CSM";
//        System.out.println("最优的权重向量是: " + resultStr);
//    }

    public static double[] finalOptimalWeightVector(double[][] data) {

        double[] EV_weight = EV_OptimalWeightVector(data);
        double[] LLSM_weight = LLSM_OptimalWeightVector(data);
        double[] CSM_weight = CSM_OptimalWeightVector(data);
        System.out.println("EV_weight: " + java.util.Arrays.toString(EV_weight));
        System.out.println("LLSM_weight: " + java.util.Arrays.toString(LLSM_weight));
        System.out.println("CSM_weight: " + java.util.Arrays.toString(CSM_weight));

        double EV_accuracy = strengthEvaluateCriteria(data, EV_weight);
        double LLSM_accuracy = strengthEvaluateCriteria(data, LLSM_weight);
        double CSM_accuracy = strengthEvaluateCriteria(data, CSM_weight);
        System.out.println("EV_accuracy: " + EV_accuracy);
        System.out.println("LLSM_accuracy: " + LLSM_accuracy);
        System.out.println("CSM_accuracy: " + CSM_accuracy);

        double result = Math.min(EV_accuracy, Math.min(LLSM_accuracy, CSM_accuracy));
        String resultStr = result == EV_accuracy ? "EV" : result == LLSM_accuracy ? "LLSM" : "CSM";
        double[] resultWeightVector = result == EV_accuracy ? EV_weight : result == LLSM_accuracy ? LLSM_weight : CSM_weight;
        System.out.println("最优的权重向量是: " + resultStr);

        return resultWeightVector;
    }

    public static double[] EV_OptimalWeightVector(double[][] data) {
        // 直接使用输入的 double 数组构造 Matrix 对象
        Matrix A = new Matrix(data);

        // 计算特征值和特征向量
        EigenvalueDecomposition eig = A.eig();
        Matrix D = eig.getD(); // 特征值矩阵
        Matrix V = eig.getV(); // 特征向量矩阵

        // 找到最大特征值及其对应的特征向量
        double maxEigenvalue = Double.NEGATIVE_INFINITY;
        int maxEigenvalueIndex = -1;
        for (int i = 0; i < D.getRowDimension(); i++) {
            if (D.get(i, i) > maxEigenvalue) {
                maxEigenvalue = D.get(i, i);
                maxEigenvalueIndex = i;
            }
        }

        // 最大特征值对应的特征向量
        Matrix eigenvector = V.getMatrix(0, V.getRowDimension() - 1, maxEigenvalueIndex, maxEigenvalueIndex);

        // 获取特征向量的数组表示
        double[][] eigenvectorArray = eigenvector.getArray();
        double[] eigenvectorVector = new double[eigenvectorArray.length];
        for (int i = 0; i < eigenvectorArray.length; i++) {
            eigenvectorVector[i] = eigenvectorArray[i][0];
        }

        // 归一化处理
        double sumOfAbsoluteValues = 0;
        for (double value : eigenvectorVector) {
            sumOfAbsoluteValues += Math.abs(value);
        }

        double[] normalizedVector = new double[eigenvectorVector.length];
        for (int i = 0; i < eigenvectorVector.length; i++) {
            normalizedVector[i] = Math.abs(eigenvectorVector[i] / sumOfAbsoluteValues);
        }

        return normalizedVector;
    }

    public static double[] LLSM_OptimalWeightVector(double[][] data) {

        double[] A = new double[data.length];
        for (int i = 0; i < data.length; i++) {
            double product = 1.0;
            for (int j = 0; j < data[i].length; j++) {
                product *= data[i][j];
            }
            A[i] = Math.pow(product, 1.0 / data[i].length);
        }

        double sum = 0;
        for (double v : A) {
            sum += v;
        }

        double[] w = new double[A.length];
        for (int i = 0; i < A.length; i++) {
            w[i] = A[i] / sum;
        }

        return w;
    }

    public static double[] CSM_OptimalWeightVector(double[][] data) {
        double epsilon = 1e-10;  // 迭代精度
        int maxIterations = 1000;  // 最大迭代次数限制

        double[] w = new double[data.length];
        Random random = new Random();
        double sum = 0;
        for (int i = 0; i < data.length; i++) {
            w[i] = random.nextDouble();  // 随机初始化解
            sum += w[i];
        }
        for (int i = 0; i < data.length; i++) {
            w[i] /= sum;  // 归一化
        }

        int iteration = 0;
        while (iteration < maxIterations) {
//            System.out.println("Iteration " + iteration + ": w = " + java.util.Arrays.toString(w));
            int m = -1;
            double maxVal = -1.0;
            for (int i = 0; i < data.length; i++) {
                double val = 0;
                for (int j = 0; j < data[i].length; j++) {
                    val += (1 + data[j][i] * data[j][i]) * (w[i] / w[j]) - (1 + data[i][i] * data[i][i]) * (w[j] / w[i]);
                }
                val = Math.abs(val);
                if (maxVal == -1 || val > maxVal) {
                    maxVal = val;
                    m = i;
                }
            }
            if (maxVal <= epsilon) {
                break;
            }

            double up = 0;
            double bottom = 0;
            for (int j = 0; j < data.length; j++) {
                if (j != m) {
                    up += (1 + data[m][j] * data[m][j]) * (w[j] / w[m]);
                    bottom += (1 + data[j][m] * data[j][m]) * (w[m] / w[j]);
                }
            }
            double T = Math.pow(up / bottom, 1.0 / 2);
            double[] X = w.clone();
            X[m] *= T;
            sum = 0;
            for (int i = 0; i < data.length; i++) {
                sum += X[i];
            }
            for (int i = 0; i < data.length; i++) {
                w[i] = X[i] / sum;
            }

            iteration++;
        }

        if (iteration >= maxIterations) {
//            System.out.println("达到最大迭代次数限制，可能未收敛");
        }

        return w;
    }

    public static double strengthEvaluateCriteria(double[][] data, double[] weight) {

        double result = 0;
        for (int i = 0; i < data.length; i++) {
            for (int j = 0; j < data[i].length; j++) {
                result += Math.abs(data[i][j] - weight[i]/weight[j]);
            }
        }

        return result;
    }
}

运行结果

EV_weight: [0.17276899543845872, 0.20021897469030842, 0.16090764808578253, 0.10824147110711889, 0.35786291067833154]
LLSM_weight: [0.16020622338782942, 0.1995738491931742, 0.16020622338782942, 0.11195645349939282, 0.3680572505317743]
CSM_weight: [0.15419976038001187, 0.22068013571004072, 0.21423159815422463, 0.15921403290363184, 0.251674472852091]
EV_accuracy: 11.411122021707987
LLSM_accuracy: 11.376383332147004
CSM_accuracy: 14.367286549368558
最优的权重向量是: LLSM
EV_weight: [0.19053688357561377, 0.15544138299287066, 0.1024342806572344, 0.1895940790972254, 0.09457869275270668, 0.1542833022115746, 0.06135727698762504, 0.05177410172514951]
LLSM_weight: [0.18791561772034962, 0.1534324593715871, 0.10621331697844344, 0.18791561772034962, 0.09948864114022907, 0.14801301469802347, 0.06356758120738136, 0.05345375116363638]
CSM_weight: [0.19858023599711344, 0.15035415634188057, 0.12626501083363526, 0.18906511184074648, 0.08133444881799352, 0.12542805023497544, 0.06420014182674112, 0.06477284410691417]
EV_accuracy: 22.505995725156936
LLSM_accuracy: 21.95620770909283
CSM_accuracy: 23.07993133107597
最优的权重向量是: LLSM
关键组件组与非关键组件组的权重取[0.7, 0.3]的情况下，游戏服务器系统的可信度量值T为：7.967173859639105；可信等级Level为：3
关键组件组与非关键组件组的权重取[0.6, 0.4]的情况下，游戏服务器系统的可信度量值T为：7.946533396594098；可信等级Level为：3
关键组件组与非关键组件组的权重取[0.55, 0.45]的情况下，游戏服务器系统的可信度量值T为：7.936213165071594；可信等级Level为：3

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Windows.old 文件夹是什么？它可以手动删除吗？

Windows.old 文件夹是什么？它可以手动删除吗？

当我们在 Windows 系统中进行重大更新&#xff0c;如从 Windows 7 升级到 Windows 10&#xff0c;或者在 Windows 10 中执行某些系统重置操作后&#xff0c;会在系统盘&#xff08;通常是 C 盘&#xff09;中发现一个名为 “Windows.old” 的文件夹。那么&#xff0c;这个文件夹…
阅读更多...
Android13 允许桌面自动旋转

Android13 允许桌面自动旋转

一&#xff09;需求-场景 Android13 实现允许桌面自动旋转 Android13 版本开始后&#xff0c;支持屏幕自动旋转&#xff0c;优化体验和兼容性&#xff0c;适配不同屏幕 主界面可自动旋转 二&#xff09;参考资料 android framework13-launcher3【06手机旋转问题】 Launcher默…
阅读更多...
Goland2024.3 发布，有点东西

Goland2024.3 发布，有点东西

好多人夸我嘴甜&#xff0c;你要不要尝尝~ 上周&#xff0c;Goland2024 年最后的一个大版本正式发布了。 虽然这次的更新并不是很丰富&#xff0c;但是仍然有几个值得我们关注的几个亮点。 第一个&#xff0c;支持循环导入的检查 循环导入的出现往往是不经意的&#xff0c;但是…
阅读更多...
数据结构之算法复杂度(超详解)

数据结构之算法复杂度(超详解)

文章目录 1. 算法复杂度1.1 数据结构1.2 算法1.3 二者的重要性 2. 算法效率开胃小菜&#xff1a;复杂度概念 3. 时间复杂度3.1 大O表示法3.2 时间复杂度示例练习例1例2例3例4例5例6例7 4. 空间复杂度4.1 空间复杂度示例练习例1例2 5. 开胃小菜扩展5.1 思路2&#xff1a;采用空间…
阅读更多...
【C++笔记】map和set的使用

【C++笔记】map和set的使用

【C笔记】map和set的深度剖析 &#x1f525;个人主页&#xff1a;大白的编程日记 &#x1f525;专栏&#xff1a;C笔记 文章目录 【C笔记】map和set的深度剖析前言一.set1.1 序列式容器和关联式容器1.2 set系列的使用1.3 set类的介绍1.4 set的构造和迭代器1.5 set的增删查1.6…
阅读更多...
最新AI自动无人智享直播系统 —— 视频自动播软件热门之选

最新AI自动无人智享直播系统 —— 视频自动播软件热门之选

在当今数字化浪潮汹涌澎湃的时代&#xff0c;直播行业正经历着前所未有的变革与创新。而最新的 AI 自动无人智享直播系统&#xff0c;无疑成为了视频自动播软件中的热门之选&#xff0c;正引领着直播领域迈向新的高度。 这款 AI 自动无人智享直播系统&#xff0c;其核心优势在于…
阅读更多...
气膜球幕：科技与艺术的完美融合，沉浸式体验引领未来—轻空间

气膜球幕：科技与艺术的完美融合，沉浸式体验引领未来—轻空间

在现代化展览和活动中&#xff0c;如何突破传统展示方式&#xff0c;吸引观众的目光&#xff0c;带来前所未有的沉浸式体验&#xff1f;气膜球幕作为一种创新的科技展示平台&#xff0c;凭借其独特的球形结构和多功能应用&#xff0c;正在成为各大展览、活动和娱乐项目的首选。…
阅读更多...
计算机视觉硬件知识点整理六：工业相机选型

计算机视觉硬件知识点整理六：工业相机选型

文章目录 前言一、工业数字相机的分类二、相机的主要参数三、工业数字摄像机主要接口类型四、选择工业相机的考量因素六、实例分析 前言 随着科技的不断进步&#xff0c;工业自动化领域正经历着前所未有的变革。作为工业自动化的重要组成部分&#xff0c;工业相机在工业检测、…
阅读更多...
Mysql读写分离分库分表

Mysql读写分离分库分表

读写分离 什么是读写分离 读写分离主要是为了将对数据库的读写操作分散到不同的数据库节点上。 这样的话&#xff0c;就能够小幅提升写性能&#xff0c;大幅提升读性能。一般情况下&#xff0c;我们都会选择一主多从&#xff0c;也就是一台主数据库负责写&#xff0c;其他的从…
阅读更多...
【C语言】结构体（四）

【C语言】结构体（四）

本篇重点是typedef关键字 一&#xff0c;是什么&#xff1f; typedef用来定义新的数据类型&#xff0c;通常typedef与结构体的定义配合使用。 简单来说就是取别名 ▶ struct 是用来定义新的数据类型——结构体 ▶ typedef是给数据类型取别名。 二&#xff0c;为什么&#xf…
阅读更多...
普中51单片机——LED流水灯模块

普中51单片机——LED流水灯模块

1、GPIO概念 GPIO&#xff08;general purpose intput output&#xff09;是通用输入输出端口的简称&#xff0c;可以通过软件来控制其输入和输出。51 单片机芯片的 GPIO 引脚与外部设备连接起来&#xff0c;从而实现与外部通讯、 控制以及数据采集的功能。 1.1、GPIO分类 &a…
阅读更多...
Linux入门系列--压缩与解压

Linux入门系列--压缩与解压

一、前言 为了使传输的文件大小尽可能地小&#xff0c;我们采用压缩的方式生成压缩文件&#xff0c;然后将压缩包传输过去就可以了。衡量压缩方法地好坏主要有两点综合考量&#xff1a;一是压缩速度&#xff0c;二是压缩程度。很好理解&#xff0c;压缩一个文件&#xff0c;我…
阅读更多...
云服务器重装系统后 一些报错与解决[ vscode / ssh / 子用户]

云服务器重装系统后 一些报错与解决[ vscode / ssh / 子用户]

碰见的三个问题&#xff1a; 1.vscode连接失败 2.登录信息配置 3.新建子用户的一些设置 思考&#xff1a;遇见问题&#xff0c;第一反应 应该如何解决 目录 1. 错误 解决方法 原因 步骤 1&#xff1a;找到known_hosts文件并编辑 步骤 2&#xff1a;通过VSCode终端输入…
阅读更多...
【包教包会】CocosCreator3.x——重写Sprite，圆角、3D翻转、纹理循环、可合批调色板、不影响子节点的位移旋转缩放透明度

【包教包会】CocosCreator3.x——重写Sprite，圆角、3D翻转、纹理循环、可合批调色板、不影响子节点的位移旋转缩放透明度

一、效果演示 重写Sprite组件&#xff0c;做了以下优化&#xff1a; 1、新增自变换&#xff0c;在不影响子节点的前提下位移、旋转、缩放、改变透明度 新增可合批调色板&#xff0c;支持色相、明暗调节 新增圆角矩形、3D透视旋转、纹理循环 所有功能均支持合批、原生平台&…
阅读更多...
南昌榉之乡托养机构解读：自闭症与看电视并无必然联系

南昌榉之乡托养机构解读：自闭症与看电视并无必然联系

在探讨自闭症的成因时&#xff0c;有人会问&#xff1a;自闭症是多看电视引起的吗&#xff1f;今天&#xff0c;就让我们来看看南昌榉之乡托养机构对此有何见解。 榉之乡大龄自闭症托养机构在江苏、广东、江西等地都有分校&#xff0c;一直致力于为大龄自闭症患者提供专业的支持…
阅读更多...
卷积神经网络（CNN）的层次结构

卷积神经网络（CNN）的层次结构

卷积神经网络&#xff08;CNN&#xff09;是一种以其处理图像和视频数据的能力而闻名的深度学习模型&#xff0c;其基本结构通常包括以下几个层次&#xff0c;每个层次都有其特定的功能和作用&#xff1a; 1. 输入层&#xff08;Input Layer&#xff09;&#xff1a; 卷积神经网…
阅读更多...
Milvus×OPPO：如何构建更懂你的大模型助手

Milvus×OPPO：如何构建更懂你的大模型助手

01. 背景 AI业务快速增长下传统关系型数据库无法满足需求。 2024年恰逢OPPO品牌20周年&#xff0c;OPPO也宣布正式进入AI手机的时代。超千万用户开始通过例如通话摘要、新小布助手、小布照相馆等搭载在OPPO手机上的应用体验AI能力。 与传统的应用不同的是&#xff0c;在AI驱动的…
阅读更多...
数据结构之二叉树详解：从原理到实现

数据结构之二叉树详解：从原理到实现

1. 什么是二叉树&#xff1f; 二叉树&#xff08;Binary Tree&#xff09;是一种树形数据结构&#xff0c;其中每个节点最多有两个子节点&#xff0c;分别被称为左子节点和右子节点。二叉树可以用来表示层次关系&#xff0c;如文件目录、组织结构&#xff0c;或用于快速查找、…
阅读更多...
CTF-PWN: WEB_and_PWN [第一届“吾杯”网络安全技能大赛 Calculator] 赛后学习(不会)

CTF-PWN: WEB_and_PWN [第一届“吾杯”网络安全技能大赛 Calculator] 赛后学习(不会)

附件 calculate.html <!DOCTYPE html> <html lang"en"> <head><!-- 设置字符编码为 UTF-8&#xff0c;支持多语言字符集 --><meta charset"UTF-8"><!-- 设置响应式视图&#xff0c;确保页面在不同设备上自适应显示 --&…
阅读更多...
用于LiDAR测量的1.58um单芯片MOPA（一）

用于LiDAR测量的1.58um单芯片MOPA（一）

--翻译自M. Faugeron、M. Krakowski1等人2014年的文章 1.简介 如今&#xff0c;人们对高功率半导体器件的兴趣日益浓厚&#xff0c;这些器件主要用于遥测、激光雷达系统或自由空间通信等应用。与固态激光器相比&#xff0c;半导体器件更紧凑且功耗更低&#xff0c;这在低功率供…
阅读更多...
最新文章

Copyright @ 2022~2023