6164

Редактор логических схем алгоритмовАвтоматизация проектирования компьютерных систем

Лабораторная работа

Информатика, кибернетика и программирование

Автоматизация проектирования компьютерных систем Краткое описание программы Интерфейс пользователя: Пользователь может выполнить одно из следующих действий: Открыть существующий файл для просмотра и дальнейшего редактирования алгоритма. ...

Русский

2012-12-30

125.74 KB

16 чел.

Автоматизация проектирования компьютерных систем

Краткое описание программы

Интерфейс пользователя:

  1.  Пользователь может выполнить одно из следующих действий:
  2.  Открыть существующий файл для просмотра и дальнейшего редактирования алгоритма.
  3.  Создать новый файл.
  4.  Сохранить измененный алгоритм в указанный  файл.
  5.  Редактировать алгоритм.
  6.  Редактировать файл в который в дальнейшем будет сохранен файл.

Скриншот программы:

Формат записи алгоритма

ЛСА (логическая схема алгоритма) - это компактная запись алгоритма, хотя и с потерей наглядности, представляет собой конечную строку символов. Строка начинается символом B (начало) и заканчивается символом Е (конец).

Внутри строки записывают буквы входного и выходного алфавитов (Хi и Yi), между которыми могут располагаться стрелки с индексами ( >i и <i ). Стрелки с одинаковыми индексами создают неразрывную пару, соответствующую условному (если стрелка расположена после Хi) или безусловному переходу (если стрелка расположена после Yi).

Формат вершин алгоритма: “X1”, “Y1”,”Y5,Y6,Y7”, “B”,”E”.

Основные методы класса AlgProcessor.

public String parse( String str) – преобразует исходную строку в массив лексем.

Возвращает строку «suceeded» если входные данные корректны или сообщение об ошибки.

public void saveAlgorithm(String fileName) – преобразует массив лексем в объект алгоритма ( матрица переходов, матрица соотношения сигналов и список управляющих сигналов. А также пробует записать алгоритм в файл.

public void loadAlgorithm(String fileName)  - пытается считать готовый алгоритм из файла.

public String createLSA() – преобразовывает алгоритм в строку для вывода.

Листинг программы:

import javax.swing.*;

public class Program{

 

 public static void main(String[] args) {

 MainFrame frame = new MainFrame();

 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

 frame.setVisible(true);

}

}

import java.awt.Dimension;

import java.awt.Image;

import java.awt.Toolkit;

import java.awt.event.*;

import javax.swing.*;

public class MainFrame extends JFrame {

private static final long serialVersionUID = 1L;

 

private JPanel colPanel;

 

public MainFrame() {

 Toolkit kit = Toolkit.getDefaultToolkit();

 Dimension screenSize = kit.getScreenSize();

 colPanel = new LSAPanel();

 add(colPanel);

 

 setTitle("Proga Chuba");

 setBounds(300, 200, screenSize.width/3, screenSize.height/6);

 Image im = kit.getImage("dinamo.gif");

 setIconImage(im);

 

 JMenuBar menuBar = new JMenuBar();

 setJMenuBar(menuBar);

 JMenu fileMenu = new JMenu("File");

 JMenuItem newItem = fileMenu.add(new AbstractAction("New"){

  public void actionPerformed(ActionEvent event){

   ((LSAPanel) colPanel).newA();

  }

 });

 fileMenu.addSeparator();

 JMenuItem saveItem = fileMenu.add(new AbstractAction("Save"){

  public void actionPerformed(ActionEvent event){

   ((LSAPanel) colPanel).save();

  }

 });

 JMenuItem loadItem = fileMenu.add(new AbstractAction("Load"){

  public void actionPerformed(ActionEvent event){

   ((LSAPanel) colPanel).load();

  }

 });

 fileMenu.addSeparator();

 JMenuItem exitItem = fileMenu.add(new AbstractAction ("Exit"){

  public void actionPerformed(ActionEvent event){

   System.exit(0);

  }

 });

 JMenu helpMenu = new JMenu("Help");

 //JMenuItem aboutItem = helpMenu.add("About...");

 JMenuItem aboutItem = helpMenu.add(new AbstractAction("About..."){

  public void actionPerformed(ActionEvent event){

   about();

  }

 });

 menuBar.add(fileMenu);

 menuBar.add(helpMenu);

 setResizable(false);

 

}

public void about(){

       JOptionPane.showMessageDialog(this,

               "Computer-aided Designing of Computer Systems\nCopyright (c) 2011 Alexander Chub",

               "About", JOptionPane.INFORMATION_MESSAGE);

}

}

import java.awt.Color;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JTextField;

public class LSAPanel extends JPanel{

 

 private static final long serialVersionUID = 1L;

 

JTextField  inputField;

JTextField folderField;

JLabel messageBox, messageBoxInp, messageBoxFol, messageBoxNul;

 public LSAPanel(){

 

 JButton checkButton = new JButton("Check");

 

 setBackground(Color.LIGHT_GRAY);

 inputField = new JTextField();

 folderField = new JTextField();

 messageBoxInp = new JLabel("            Input field:");

 messageBoxFol = new JLabel("            Name of file:");

 messageBox = new JLabel("");

 this.setLayout((new GridLayout(3,2)));

 this.add(messageBoxInp);

 this.add(inputField);

 this.add(messageBoxFol);

 this.add(folderField);

 this.add(messageBox);

 add(checkButton);

 checkButton.addActionListener(new ActionListener(){

  public void actionPerformed(ActionEvent event) {

   check();

  }

 });

}

 public void newA(){

 inputField.setText("");

 folderField.setText("");

}

 

 private void check(){

 AlgProcessor proc = new AlgProcessor();

 String inputLine = inputField.getText();

 messageBox.setText(proc.parse(inputLine));

 proc.createAlgorithm();

 messageBox.setText(proc.checkValid());

}

 

 public void save(){

 AlgProcessor proc = new AlgProcessor();

 String fileName = folderField.getText();

 String inputLine = inputField.getText();

 messageBox.setText(proc.parse(inputLine));

 proc.createAlgorithm();

 proc.saveAlgorithm(fileName);

 

}

 

 public void load(){

 AlgProcessor proc = new AlgProcessor();

 String fileName = folderField.getText();

 proc.loadAlgorithm(fileName);

 if(fileName.equals(""))

  messageBox.setText("            File not found");

 String str = proc.createLSA();

 inputField.setText(str);

 }

}

import java.io.Serializable;

import java.util.ArrayList;

public class Algorithm implements Serializable{

 

 private static final long serialVersionUID = 1L;

 

 private int[][] mConnections;

 private int[][] mSignals;

 private ArrayList<String> signals;

 

 

 public Algorithm(){

}

 

 public Algorithm(int[][] mC, int[][] mS, ArrayList<String> signs){

 System.out.println("Connection matrix:  ");

 

 mConnections =mC;

 mSignals = mS;

 signals = signs;

}

 

 

 public void AlgOutput(){

 System.out.println("Connection matrix:  "+ mConnections.length);

 int nNodes = mConnections.length;

 for(int i = 0; i < nNodes; i++){

  

  for(int j = 0; j < nNodes; j++){

   System.out.print(mConnections[i][j]+"  ");

  }

  System.out.println();

 }

 System.out.println("Signals matrix:  "+ mSignals[0].length);

 for(String s:signals)

  System.out.print(s+" ");

 int nExNodes = mSignals.length;

 int nSignals =mSignals[0].length;

 System.out.println();

 for(int i = 0; i < nExNodes; i++){

  for(int j = 0; j < nSignals; j++){

   System.out.print(mSignals[i][j]+"  ");

  }

  System.out.println();

 }

 

}

 

 @Override

 public String toString(){

 ArrayList<String> lexems = new ArrayList<String>();

 int nExNodes = mSignals.length;

 int nSignals =mSignals[0].length;

 lexems.add("B/");

 

 for(int i = 0; i < nExNodes; i++){

  String s = "";

  for(int j = 0; j < nSignals; j++){

   if(mSignals[i][j] ==1){

    s+=","+signals.get(j);

   }

  }

  

  s=s.substring(1,s.length())+"/";

  lexems.add(s);

 }

 lexems.add("E");

 

 

 int nNodes = mConnections.length;

 int pointer = 1;

 for(int out = 0; out < nNodes; out++){

  

  for(int in = 0; in < nNodes; in++){

   if((mConnections[out][in]==1)&&(out!=in)){

    String s = lexems.get(out);

    s = s+">"+pointer+"/" +

      "";

    lexems.set(out, s);

    s = lexems.get(in+1);

    s = "<" + pointer+"/"+s;

    lexems.set(in+1, s);

    pointer++;

   }

   //System.out.print(mConnections[i][j]+"  ");

  }

  System.out.println();

 }

 

 

 String returnLine = "";

 for(String s:lexems){

  returnLine+=s;

 }

 return returnLine;

}

 

 private boolean isY(int[] mas){

 int sum = 0;

 for(int i = 0; i<mas.length;i++) {

  sum+= mas[i];

 }

 if(sum>1) return false;

 else return true;

 

}

 

 public String findInfiniteLoop(){

 String messageLine="algorithm is correct";

 int nNodes = mConnections.length;

 

 //int pointer = 1;

 for(int out = 0; out < nNodes; out++){

  if(!isY(mConnections[out])) continue;

  for(int in = 0; in < nNodes; in++){

   int current = mConnections[out][in];

   if((current==1)&&(out>in)){

    messageLine = " infinite loop at  "+out;

    return messageLine;

   }

  }

 }  

 return messageLine;

}

 

}

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.util.ArrayList;

import java.util.regex.Pattern;

public class AlgProcessor {

 private ArrayList<String> parsedAlg;

 private TableCreator creator;

 private Algorithm alg;

 

 

 public AlgProcessor() {

 creator =new TableCreator();

}

 

 

 // parsing string variable to algorithm lexems

 public String parse( String str){

 

 Pattern pat = Pattern.compile("/");

 String[] lexems = pat.split(str);

 

 parsedAlg = new ArrayList<String>();

 for(int i = 0;i<lexems.length;i++) {

  parsedAlg.add(lexems[i]);

  System.out.println(lexems[i]);

 }

 

 return checkLexValid();

}

 

 //creating algorithm

 public void createAlgorithm(){

 

 int[][] mConnections;

 int[][] mSignals;

 ArrayList<String> signals;

 creator.connect(parsedAlg);  

 mConnections = creator.connectNodes(parsedAlg);

 mSignals = creator.connectSignals();

 signals = creator.fromXYSetsToArray();

 

 alg = new Algorithm(mConnections, mSignals, signals);

 alg.AlgOutput();

 //from parsedAlg to two matrix incapsulated into an object of class Algorithm

 

 }

 

 public void saveAlgorithm(String fileName){

 FileOutputStream fos;

 ObjectOutputStream oos;

 try {

  fos = new FileOutputStream(fileName);

  oos = new ObjectOutputStream(fos);

  oos.writeObject(alg);

  oos.flush();

  oos.close();

 } catch (IOException e) {

  e.printStackTrace();

 }

 

}

 

 public void loadAlgorithm(String fileName) {

 FileInputStream fis;

 ObjectInputStream ois;

 //Algorithm alg1;

 try {

  fis = new FileInputStream(fileName);

  ois = new ObjectInputStream(fis);

   alg =(Algorithm)ois.readObject();

 } catch (IOException e) {

  e.printStackTrace();

 } catch (ClassNotFoundException e) {

  e.printStackTrace();

 }

 

 //alg1.AlgOutput();

}

 

 public String createLSA(){

 return alg.toString();

}

 

 

 public String checkValid(){

 return alg.findInfiniteLoop();

}

 

 

 private String checkLexValid(){

 String str = "succeded";

 if(!parsedAlg.get(0).equals("B")){

  str = "Algorithm must beginned with B";

  return str;

 }

 if(!parsedAlg.get(parsedAlg.size()-1).equals("E")){

  str = "Algorithm must ended  with E";

  return str;

 }

 

 for(int i = 1; i<parsedAlg.size()-1;i++){

  String s = parsedAlg.get(i);

  if(s.length()<2){

   str = s +"  Not valid lexeme at "+ i;

   return str;

  }

 }

 return str;

}

}

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Set;

import java.util.regex.Pattern;

import nodes.*;

public class TableCreator {

 

 private ArrayList<Node> nodes;

 private int counter;

 private Set<String> xSignals;

 private Set<String> ySignals;

//-----------------------------------------------------------------------------

 

 private boolean isExec(String a){

 if((a.charAt(0)!='>')&&(a.charAt(0)!='<'))

  return true;

 else return false;

}

 

 

 boolean isArrUp(String a){

 if(a.charAt(0)=='>')

  return true;

 else return false;

 }

 

 boolean isArrDown(String a){if(a.charAt(0)=='<')

 return true;

 else return false;

 }

 

 

 private int getType(String a){

 if((a.charAt(0)=='B')) return 0;

 if((a.charAt(0)=='X')) return 1;

 if((a.charAt(0)=='Y')||(a.charAt(0)=='(')) return 2;

 if((a.charAt(0)=='E')) return 3;

 else return 100;

}

//----------------------------------------

 private ArrayList<String> parseSignals(String s){

 //TODO

 Pattern pat = Pattern.compile(",");

 String[] tokens = pat.split(s);

 ArrayList<String> listY = new ArrayList<String>();

 for(int i = 0;i<tokens.length;i++) listY.add(tokens[i]);

 return listY;

}

 

//---------------------------------------------

 

 public ArrayList<Node> connect(ArrayList<String> parsedAlg){

 nodes = new ArrayList<Node>();

 xSignals = new HashSet<String>();

 ySignals = new HashSet<String>();

 int type;

 //Node node;

 

 

 int  j = 0;

 for(String lexeme:parsedAlg){

  

  if(isExec(lexeme)){

   type = getType(lexeme);

   switch(type){

    case 0: {

     BeginNode bNode =new BeginNode(counter);

     nodes.add(bNode);

     bNode.setZCode(j);

  

     break;

    }

    case 1: {

     XNode xNode = new XNode(counter, lexeme);

     xSignals.add(lexeme);

     xNode.setZCode(j);

     nodes.add(xNode);

     break;

    }

    case 2:{

     YNode yNode = new YNode(counter);

     ArrayList<String> outSignals = parseSignals(lexeme);

     yNode.setConds(outSignals);

     ySignals.addAll(outSignals);

     yNode.setZCode(j);

     nodes.add(yNode);

     

     break;

    }

    case 3:{

     EndNode eNode = new EndNode(counter);

     nodes.add(eNode);

     eNode.setZCode(j);

     

    }

   }

   counter++;

  }

  j++;

 }

 return nodes;

}

 

 public void testConnect(ArrayList<String> parsedAlg){

 connectNodes(parsedAlg);

}

 

 public void testSignals(){

 int[][] mSignals = connectSignals();

 int n = mSignals.length;

 int m = mSignals[0].length;

 System.out.println("n= "+n+"   m= "+m);

 for(int i = 0; i<n;i++){

  for(int j = 0; j<m;j++){

   System.out.print(mSignals[i][j]+" ");

  }

  System.out.println();

 }

}

 

 private int getIdFromZCode(int zCode){

 for(Node node:nodes){

  if(node.getZCode()==zCode){

   return node.getId();

  }

 }

 return -1;

}

 

 public int[][] connectSignals(){

 ArrayList<String> signals = this.fromXYSetsToArray();

 int nHigh = nodes.size()-2;

 int nWidth = signals.size();

 int[][] mSignals = new int[nodes.size()-2][signals.size()];

 for(int i = 0; i<nHigh;i++){

  if(nodes.get(i+1) instanceof XNode){

   XNode xNode =(XNode)nodes.get(i+1) ;

   String x = xNode.getXCondition();

   for(int j = 0; j<nWidth; j++) {

    if(signals.get(j).equals(x)){

     mSignals[i][j] =1;

    }else{

     mSignals[i][j] = 0;

    }

   }

  }

  if(nodes.get(i+1) instanceof YNode){

   YNode yNode = (YNode)nodes.get(i+1);

   ArrayList<String> ys =yNode.getConds();

   for(int j = 0; j<nWidth; j++) {

    mSignals[i][j] = 0;

    for(String y:ys){

     if(signals.get(j).equals(y)){

      mSignals[i][j] = 1;

      break;

     }

    }

   }

  }

 }

 

 return mSignals;

}

 

 public int[][] connectNodes(ArrayList<String> parsedAlg){

 

 int nOfArr = (parsedAlg.size() - nodes.size())/2;

 int[] fromArr = new int[nOfArr];

 int[] toArr = new int[nOfArr];

 //arrowConnection[] arrCon = new arrowConnection[numOfArr];

 fromArr =this.getAllFromArrow(parsedAlg, nOfArr);

 toArr = this.getAllToArrow(parsedAlg, fromArr);

 for(int i =0; i<nOfArr; i++){

  fromArr[i] =getFromNode(fromArr[i],parsedAlg);

  toArr[i] = getNodeTo(toArr[i],parsedAlg);

 }

 

 for(int i =0; i<nOfArr; i++){

  fromArr[i] =getIdFromZCode(fromArr[i]);

  toArr[i] = getIdFromZCode(toArr[i]);

 }

 

 int n = nodes.size()-1;

 int[][] matrixConnect = new int[n][n];

 for(int i = 0; i<n;i++){

  for(int j = 0; j<n;j++){

   matrixConnect[i][j] = 0;

  }

 }

 

 

 for(int i =0; i<nOfArr; i++){

  if(nodes.get(fromArr[i]) instanceof XNode){

   XNode xNode = (XNode)nodes.get(fromArr[i]);

   xNode.setSecondRef(nodes.get(toArr[i]));

   nodes.set(fromArr[i], xNode);

  }else{

   Node node =nodes.get(fromArr[i]);

   node.setRef(nodes.get(toArr[i]));

   nodes.set(fromArr[i], node);

  }

  matrixConnect[fromArr[i]][toArr[i]-1] = 1;;

 }

 

 for(int i =0; i<nodes.size()-1; i++){

  if(nodes.get(i).getRef()==null){

   nodes.get(i).setRef(nodes.get(i+1));

   matrixConnect[i][i] = 1;

  }

 }

 for(int i = 0; i<n;i++){

  for(int j = 0; j<n;j++){

   System.out.print(matrixConnect[i][j]+" ");

  }

  System.out.println();

 }

 return matrixConnect;

}

 

 public ArrayList<String> fromXYSetsToArray(){

 ArrayList<String> signals = new ArrayList<String>();  

 Iterator<String> it = xSignals.iterator();

 while(it.hasNext()){

  signals.add(it.next());

 }

 it =ySignals.iterator();

 while(it.hasNext()){

  signals.add(it.next());

 }

 return signals;

}

 

 

 private int[] getAllFromArrow(ArrayList<String> parsedAlg,int nOfArr ){

 int[] arrsFrom = new int[nOfArr];

 int currentAr = 0;

 for(int i = 0; i<parsedAlg.size();i++){

  if(currentAr>=parsedAlg.size()){

   System.out.println("Error to ou of bounds");

  }

  if(isArrUp(parsedAlg.get(i))){

   arrsFrom[currentAr] = i;

   currentAr++;

  }

 }

 return arrsFrom;

}

 

 

 

 private int[] getAllToArrow(ArrayList<String> parsedAlg,int[] arrsFrom ){

 int[] arrsTo = new int[arrsFrom.length];

 for(int i = 0; i<arrsTo.length;i++){

  String arrFrom = parsedAlg.get(arrsFrom[i]);

  for(int j = 0; j<parsedAlg.size();j++){

   if (isArrDown(parsedAlg.get(j))){

    String arrTo = parsedAlg.get(j);

    if(arrTo.charAt(1)==arrFrom.charAt(1)){

     arrsTo[i]= j;

     break;

    }

   }

  }

 }

 return arrsTo;

}

 

 private int getFromNode(int pArrFrom, ArrayList<String> parsedAlg){

 int pointer =pArrFrom--;

 

 while(pointer>=0){

  String s = parsedAlg.get(pointer);

  if(isExec(s)){

   return pointer;

  }

  pointer--;

 }

 return -1;

}

 

 private int getNodeTo(int pArrTo, ArrayList<String> parsedAlg){

 int pointer =pArrTo++;

 while(pointer<parsedAlg.size()){

  String s = parsedAlg.get(pointer);

  if(isExec(s)){

   return pointer;

  }

  pointer++;

 }

 return -1;

}

 

}

package nodes;

public abstract class Node {

 protected int id;

 protected Node ref;

 protected int zCode;

 

 /**Constructors*/

 public Node(){

}

 

 public Node(int id){

 this.id = id;

}

 

 public Node(int id, Node ref){

 this.id = id;

 this.ref = ref;

}

 

 /**Get and Set functions*/

 public int getId(){

 return id;

}

 

 public void setId(int a){

 id=a;

}

 

 

 public Node getRef(){

 return ref;

}

 

 public void setRef(Node ref){

 this.ref = ref;

}

 

 public int getZCode(){

 return zCode;

}

 

 public void setZCode(int a){

 zCode=a;

}

}

package nodes;

public class BeginNode extends Node{

 public BeginNode(){

 super();

}

 

 public BeginNode(int id){

 super(id);

}

 

 /*public String toString(){

 return id+" "+"Begin  "+zCode+"   "+ref.id;

}*/

}

package nodes;

public class EndNode extends Node{

 public EndNode(int id){

 super(id);

}

 

 /*public String toString(){

 return id+"  "+" End "+ +zCode;

}*/

}

package nodes;

public class XNode extends Node {

 private Node ref2;

 private String xCond;

 

 

 public XNode(){

 super();

}

 

 public XNode(int id){

 super(id);

}

 

 public XNode(int id, Node ref, String xCond){

 this.id = id;

 this.ref = ref;

 this.xCond = xCond;

}

 

 public XNode(int id, String xCond){

 this.id = id;

 this.xCond = xCond;

}

 public void setSecondRef(Node ref){

 ref2=ref;

}

 

 public Node getSecondRef(){

 return ref2;

}

 

 public void setCondition(String cond) {

 xCond = cond;

}

 

 public String getXCondition(){

 return xCond;

}

 

// @Override

// public String toString(){

//  return id+"  "+xCond+ "  "+ zCode+"   "+ref.id+"   "+ref2.id;

// }

 

}

package nodes;

import java.util.ArrayList;

public class YNode extends Node{

 // There can be list of outputSignals

 private ArrayList<String> yConds = new ArrayList<String>();

 

 

 public YNode(){

 super();

}

 

 public YNode(int id){

 super(id);

}

 

 public YNode(int id, Node ref, ArrayList<String> conds){

 this.id = id;

 this.ref = ref;

 this.yConds = conds;

}

 

 

 /** getters setters*/

 public void addYCond(String cond){

 yConds.add(cond);

}

 

 public ArrayList<String> getConds(){

 return yConds;

}

 

 public String getCond(int id){

 return yConds.get(id);

}

 

 public void setConds(ArrayList<String> a){

 yConds = a;

}

 

 /*public String toString(){

 return id+"  "+yConds.get(0)+" " + zCode+"   "+ref.id;

 }*/

}


 

А также другие работы, которые могут Вас заинтересовать

73200. Основы молекулярно-кинетической теории. Термодинамические параметры. Масса и размеры молекул 348 KB
  Все тела -– твёрдые жидкие и газообразные –- представляют собой совокупность большого числа атомов и молекул. При изучении свойств тел и физических явлений происходящих с телами возможны два направления исследований: а молекулярно-кинетическое устанавливает законы протекания различных...
73201. Идеальные газы 136.5 KB
  Используя выводы рассмотренных вопросов разберем основные законы для газов. Основные газовые законы. Из основного уравнения кинетической теории газов можно вывести все газовые законы ранее установленные экспериментально.
73202. Основы термодинамики, Связь теплоты и работы. Механический эквивалент тепла 134.5 KB
  Термодинамика, в отличие от статистической физики, не рассматривает конкретные молекулярные картины. На основании опытных данных формулируются основные законы (принципы или начала). Эти законы и их следствия применяются к конкретным физическим явлениям, связанным с превращением энергии...
73203. Процессы в газах 161.5 KB
  Если тело не получает извне никакой энергии, то работа А при расширении совершается за счет внутренней энергии U (U = кинетической энергии теплового движения атомов вещества + потенциальной энергии их взаимодействия друг с другом).
73204. Второй закон термодинамики 155.5 KB
  Первое начало термодинамики ничего не говорит о направлении теплообмена – от какого из двух различно нагретых тел должна передаваться теплота. Оно допускает переход теплоты как от горячих к холодным, так и наоборот.
73206. Волновое движение 1.28 MB
  В механике волновой процесс происходит в среде, частицы которой связаны между собой упругими силами. Общий характер волновых процессов обычно рассматривается на примере возникновения и распространения механических волн.
73207. Поляризация света. Естественный и поляризованный свет 240 KB
  Поляризация света –- физическая характеристика оптического измерения описывающая поперечную анизотропию световых волн т. источниками света являются атомы а их количество в источнике N то пространственную ориентацию для произвольно выбранного момента расположение векторов источника...
73208. Дисперсия света 170.5 KB
  Под действием энергии электромагнитной волны электроны атомов, молекул и ионов среды начинают совершать гармонические колебания и становятся источником вторичных электромагнитных волн. Электроны атомов, молекул и ионов – это внешние, слабосвязанные электроны называются оптическими электронами.