全加器的逻辑功能是两个同位的二进制数及来自低位的进位三者相加。
全加器用门电路实现两个二进制数相加并求出和的组合线路，称为一位全加器。一位全加器可以处理低位进位，并输出本位加法进位。多个一位全加器进行级联可以得到多位全加器。常用二进制四位全加器74LS283。
logisim是一款非常好用的电路设计软件，它主要的功能是基于教育的数字逻辑电路设计模拟，使用这款软件可以创建通俗易懂的电路图，使用简单、便于学习，拥有最基本的概念与逻辑电路！
logisim软件特色：
这是免费的！（Logisim开源（GPL）。
运行在任何机器中支持Java5或更高的特殊MacOSX和Windows版本。的双曲馀弦值。学生有跨平台当然是重要的家庭/宿舍计算机系统。
画面界面是基于直观的工具栏。彩色电线有助于模拟和调试电路。
自动布线工具绘制横纵电线，与其他电线连接组件。很容易画电路！
完成电路可以保存在文件中，出口到GIF文件或印刷在打印机上。
电路布局可用作子回路回路，设计分层回路。
包括电路组件包括输入和输出、盖茨、多重复用器、算术电路、拖鞋和RAM内存。
包括组合分析模块允许之间的转换电路、真实价值表和逻辑表达。
床头区域:床头区域留有足够的插孔,以免日后麻烦。首先是电话线插孔,要在床头柜上方预留,并采用5孔插线板带开关为宜。然后还要预留足够的插孔和开关,能控制各个区域的电路单独开闭。除此之外,不要忘记,如果双床头柜,对称设置。
梳妆区域:梳妆台方上应该预留一个能够连接吹风机的电源,此外梳妆镜上方有反射灯,也应设置一个单独开关控制。
打开Altium Designer 18软件中的原理图设计页面,执行放置-页面符命令,...
2.
将光标放到需要放置的位置单击两次,确定图形形状,此时初步画出一个方块电路。
3.
双击电路上面的名字可以弹出界面进行更改,改动一下,得到自己需要的名称,便于后续区分。
4.
同样,双击边框,可以对其属性进行设置,如长宽尺寸,边框类型,填充颜色等信息。
在家装或者装修中，厨房电路设计是一个非常重要的环节。电路设计合理与否，不仅关系到日常使用的便利性，更关系到安全性。本文将从以下几个方面介绍厨房电路设计的注意事项。
厨房电路设计需要遵循以下原则：
这些原则需要在具体设计中考虑到并体现出来。
1: 厨房电器用电量估算
在设计厨房电路之前，需要先估算厨房电器的用电量。根据厨房电器的功率和使用频率，可以大致估算出每个电器的用电量。用电量的估算是电路设计的基础，只有准确的估算才能保证后续的电路设计合理。
2: 厨房电器用电位置规划
在估算出厨房电器的用电量后，需要规划好每个电器的用电位置。不同电器的用电位置应该分开设计，避免因为集中用电导致电路过载。同时，需要考虑到电器的使用频率和使用场景，将常用的电器放在使用方便的位置，避免不必要的麻烦。
3: 厨房插座数量规划
插座数量的规划需要根据厨房电器的用电量和用电位置来确定。需要注意的是，插座数量不能太多也不能太少。太多的插座会影响美观，太少的插座则会影响使用。一般来说，每个用电位置都需要有一个插座。
4: 厨房电路容量规划
厨房电路容量的规划需要根据厨房电器的用电量来确定。一般来说，厨房的总电路容量不应该低于3kW。如果厨房电器的用电量很大，需要考虑分路供电。
以上是厨房电路设计的几个注意事项，希望能够对大家有所帮助。
国内几乎都是用这三个软件画原理图和PCB：
1. Altium Designer (Protel 99) 。界面很炫，板的3D效果不错，然并卵。。估计学生及小公司用得多。
2. Pads。也挺好用，界面没Altium友好，但是很流畅，多层板换层高亮时从不会卡。中大型公司用得多。
3. Cadence Orcad。在多层板，高速PCB设计及仿真上很牛叉，也是中大型公司用得多。初学的建议选第一个，简单易学好上手，教程也多。特别是手工做板的时候，设置打印PCB各层很方便。
这个专业考研选择还是挺多的，本专业有模拟集成电路设计方向、数字集成电路设计方向、射频集成电路设计方向、混合信号集成电路设计方向、微电子器件方向、集成电路工艺方向、人工智能算法方向。此外电气工程方向、电子方向、通信方向、软件开发、计算机、自动化都可以跨考。
所谓“分频”，就是把输入信号的频率变成成倍数地低于输入频率的输出信号。文献资料上所谓用计数器的方法做“分频器”的方法，只是众多方法中的一种。它的原理是：把输入的信号作为计数脉冲，由于计数器的输出端口是按一定规律输出脉冲的，所以对不同的端口输出的信号脉冲，就可以看作是对输入信号的”分频“。至于分频频率是怎样的，由选用的计数器所决定。
如果是十进制的计数器那就是十分频，如果是二进制的计数器那就是二分频，还有四进制、八进制、十六进制等等。以此类推。
变送器电路设计是工业自动化领域中非常关键的一部分。变送器是将传感器所感知到的物理量转换成标准信号输出，用来反映被测量物理量的状态的装置。在各种工业控制系统中，变送器起着至关重要的作用，因为它们能够将非电信号转换成电信号，实现传感器和控制器之间的有效连接。
对于变送器电路设计来说，要充分考虑到工业环境下的各种因素以确保系统的稳定性和可靠性。以下是变送器电路设计的几个重要因素：
变送器电路设计需要遵循一些基本原则，以确保设计的稳定性和可靠性：
变送器电路设计广泛应用于各种工业自动化系统中，如压力变送器、温度变送器、流量变送器等。以温度变送器为例，它将温度传感器所感知到的温度转换成对应的电信号输出。这些电信号可以通过工业控制系统进行采集、传输和处理，实现温度数据的监测和控制。
在变送器电路设计中，还需要考虑到通信协议的选择。现代工业控制系统多使用数字通信协议进行数据传输，如HART、FOUNDATION Fieldbus和Profibus等。变送器电路设计应根据具体应用需求选择适合的通信协议，并设计相应的通信接口。
变送器电路设计对于工业自动化领域具有重要意义。通过合理、稳定、可靠的电路设计，可以提高控制系统的性能和效率，同时降低故障率和维护成本。因此，对于工程师而言，掌握变送器电路设计的基本原理和技术是至关重要的。
希望本文对读者了解变送器电路设计有所帮助，同时也希望读者能够在实际应用中灵活运用这些原理和技术，提高工业自动化系统的性能和可靠性。
之前看了Mahout官方示例 20news 的调用实现；于是想根据示例的流程实现其他例子。网上看到了一个关于天气适不适合打羽毛球的例子。
训练数据：
Day Outlook Temperature Humidity Wind PlayTennis
D1 Sunny Hot High Weak No
D2 Sunny Hot High Strong No
D3 Overcast Hot High Weak Yes
D4 Rain Mild High Weak Yes
D5 Rain Cool Normal Weak Yes
D6 Rain Cool Normal Strong No
D7 Overcast Cool Normal Strong Yes
D8 Sunny Mild High Weak No
D9 Sunny Cool Normal Weak Yes
D10 Rain Mild Normal Weak Yes
D11 Sunny Mild Normal Strong Yes
D12 Overcast Mild High Strong Yes
D13 Overcast Hot Normal Weak Yes
D14 Rain Mild High Strong No
检测数据：
sunny，hot，high，weak
结果：
Yes=》 0.007039
No=》 0.027418
于是使用Java代码调用Mahout的工具类实现分类。
基本思想：
1. 构造分类数据。
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
接下来贴下我的代码实现=》
1. 构造分类数据：
在hdfs主要创建一个文件夹路径 /zhoujainfeng/playtennis/input 并将分类文件夹 no 和 yes 的数据传到hdfs上面。
数据文件格式，如D1文件内容： Sunny Hot High Weak
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
这三步，代码我就一次全贴出来；主要是两个类 PlayTennis1 和 BayesCheckData = =》
package myTesting.bayes;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.util.ToolRunner;
import org.apache.mahout.classifier.naivebayes.training.TrainNaiveBayesJob;
import org.apache.mahout.text.SequenceFilesFromDirectory;
import org.apache.mahout.vectorizer.SparseVectorsFromSequenceFiles;
public class PlayTennis1 {
private static final String WORK_DIR = "hdfs://192.168.9.72:9000/zhoujianfeng/playtennis";
/*
* 测试代码
*/
public static void main(String[] args) {
//将训练数据转换成 vector数据
makeTrainVector();
//产生训练模型
makeModel(false);
//测试检测数据
BayesCheckData.printResult();
}
public static void makeCheckVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"testinput";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeTrainVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"input";
String output = WORK_DIR+Path.SEPARATOR+"tennis-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeModel(boolean completelyNB){
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-vectors"+Path.SEPARATOR+"tfidf-vectors";
String model = WORK_DIR+Path.SEPARATOR+"model";
String labelindex = WORK_DIR+Path.SEPARATOR+"labelindex";
Path in = new Path(input);
Path out = new Path(model);
Path label = new Path(labelindex);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
if(fs.exists(label)){
//boolean参数是，是否递归删除的意思
fs.delete(label, true);
}
TrainNaiveBayesJob tnbj = new TrainNaiveBayesJob();
String[] params =null;
if(completelyNB){
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow","-c"};
}else{
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow"};
}
ToolRunner.run(tnbj, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("生成训练模型失败！");
System.exit(3);
}
}
}
package myTesting.bayes;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.mahout.classifier.naivebayes.BayesUtils;
import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;
import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;
import org.apache.mahout.common.Pair;
import org.apache.mahout.common.iterator.sequencefile.PathType;
import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirIterable;
import org.apache.mahout.math.RandomAccessSparseVector;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.Vector.Element;
import org.apache.mahout.vectorizer.TFIDF;
import com.google.common.collect.ConcurrentHashMultiset;
import com.google.common.collect.Multiset;
public class BayesCheckData {
private static StandardNaiveBayesClassifier classifier;
private static Map<String, Integer> dictionary;
private static Map<Integer, Long> documentFrequency;
private static Map<Integer, String> labelIndex;
public void init(Configuration conf){
try {
String modelPath = "/zhoujianfeng/playtennis/model";
String dictionaryPath = "/zhoujianfeng/playtennis/tennis-vectors/dictionary.file-0";
String documentFrequencyPath = "/zhoujianfeng/playtennis/tennis-vectors/df-count";
String labelIndexPath = "/zhoujianfeng/playtennis/labelindex";
dictionary = readDictionnary(conf, new Path(dictionaryPath));
documentFrequency = readDocumentFrequency(conf, new Path(documentFrequencyPath));
labelIndex = BayesUtils.readLabelIndex(conf, new Path(labelIndexPath));
NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);
classifier = new StandardNaiveBayesClassifier(model);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("检测数据构造成vectors初始化时报错。。。。");
System.exit(4);
}
}
/**
* 加载字典文件，Key: TermValue； Value：TermID
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<String, Integer> readDictionnary(Configuration conf, Path dictionnaryDir) {
Map<String, Integer> dictionnary = new HashMap<String, Integer>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
String name = path.getName();
return name.startsWith("dictionary.file");
}
};
for (Pair<Text, IntWritable> pair : new SequenceFileDirIterable<Text, IntWritable>(dictionnaryDir, PathType.LIST, filter, conf)) {
dictionnary.put(pair.getFirst().toString(), pair.getSecond().get());
}
return dictionnary;
}
/**
* 加载df-count目录下TermDoc频率文件，Key: TermID； Value：DocFreq
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<Integer, Long> readDocumentFrequency(Configuration conf, Path documentFrequencyDir) {
Map<Integer, Long> documentFrequency = new HashMap<Integer, Long>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
return path.getName().startsWith("part-r");
}
};
for (Pair<IntWritable, LongWritable> pair : new SequenceFileDirIterable<IntWritable, LongWritable>(documentFrequencyDir, PathType.LIST, filter, conf)) {
documentFrequency.put(pair.getFirst().get(), pair.getSecond().get());
}
return documentFrequency;
}
public static String getCheckResult(){
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String classify = "NaN";
BayesCheckData cdv = new BayesCheckData();
cdv.init(conf);
System.out.println("init done...............");
Vector vector = new RandomAccessSparseVector(10000);
TFIDF tfidf = new TFIDF();
//sunny，hot，high，weak
Multiset<String> words = ConcurrentHashMultiset.create();
words.add("sunny",1);
words.add("hot",1);
words.add("high",1);
words.add("weak",1);
int documentCount = documentFrequency.get(-1).intValue(); // key=-1时表示总文档数
for (Multiset.Entry<String> entry : words.entrySet()) {
String word = entry.getElement();
int count = entry.getCount();
Integer wordId = dictionary.get(word); // 需要从dictionary.file-0文件（tf-vector）下得到wordID，
if (StringUtils.isEmpty(wordId.toString())){
continue;
}
if (documentFrequency.get(wordId) == null){
continue;
}
Long freq = documentFrequency.get(wordId);
double tfIdfValue = tfidf.calculate(count, freq.intValue(), 1, documentCount);
vector.setQuick(wordId, tfIdfValue);
}
// 利用贝叶斯算法开始分类,并提取得分最好的分类label
Vector resultVector = classifier.classifyFull(vector);
double bestScore = -Double.MAX_VALUE;
int bestCategoryId = -1;
for(Element element: resultVector.all()) {
int categoryId = element.index();
double score = element.get();
System.out.println("categoryId:"+categoryId+" score:"+score);
if (score > bestScore) {
bestScore = score;
bestCategoryId = categoryId;
}
}
classify = labelIndex.get(bestCategoryId)+"(categoryId="+bestCategoryId+")";
return classify;
}
public static void printResult(){
System.out.println("检测所属类别是："+getCheckResult());
}
}
