Численные методы

Реализация алгоритмов вычисления математических объектов на конкретных вычислительных машинах. Числовые данные в практических задачах. Анализ математических моделей, связанных с применением вычислительных машин в различных областях научной деятельности.

Рубрика Программирование, компьютеры и кибернетика
Вид курсовая работа
Язык русский
Дата добавления 13.01.2018
Размер файла 369,3 K

Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже

Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.

Размещено на http://www.allbest.ru/

Содержание

Введение

1. Описание вычислительной проблемы

2. Описание изучаемого метода

3. Разработка схемы программы

4. Разработка листинга программы

5. Решение контрольной задачи

6. Решение задачи повышенной сложности

Заключение

Список используемой литературы

Приложение

Введение

Численные методы - часть более широкой математической дисциплины, которая называется вычислительной математикой. Вычисления - получение какого-либо ответа в виде чисел, а также получение каких-либо конструктивных и объективных приближений для математической модели.

Математическая модель - отображение в виде формул и данных какого-либо процесса из практики или объективной реальности. Такие модели, как правило, являются достаточно сложными для реализации их решения вручную или напрямую с помощью вычислительных машин.

Для таких случаев пригождается вычислительная математика, которая занимается решением таких типовых задач, как:

- Проблема нахождения приближения того или иного математического объекта для более удобного вычисления.

- Оценка трудоёмкости вычисления объектов из математической модели, способы уменьшить эту трудоёмкость.

- Реализация алгоритмов вычисления математических объектов на конкретных вычислительных машинах.

Поскольку вычислительные машины на самом низком уровне могут оперировать лишь логическими и арифметическими операциями, перед теоретиками и практиками становится задача найти такой алгоритм, который бы в конечном итоге затрагивал только такие типы операций, при этом был достаточно простой для реализации на конкретной машине.

Числовые данные в практических задачах часто бывают не вполне точны, обладая рядом погрешностей. Такое поведение числового представления данных называют ошибкой или погрешностью, т.е. разностью между истинным значением какого-либо объекта из математической модели и его значением на практике представления в процессе вычисления.

Вычислительная математика анализирует математические модели, связанные с применением вычислительных машин в различных областях научной и практической деятельности, разрабатывает методы и алгоритмы для решения типовых задач, возникающих при исследовании этих моделей.

При анализе изучают постановку задачи, выбирают модель, анализируют выходную и выходную информацию, численной решение задач.

Пусть исходная математическая задача поставлена корректно, т.е. ее решение существует, единственно и непрерывно зависит от входных данных. Тогда дискретная модель этой задачи должна быть построена таким образом, чтобы свойство корректности сохранялось. Следовательно, в понятие корректности численного метода включаются свойства однозначной разрешимости соответствующей системы уравнений и ее устойчивости. Под устойчивостью понимается непрерывная зависимость от входных данных.

Вторая группа требований, предъявляемых к численным методам, связана с возможностью реализации данной дискретной модели на данном компьютере, т.е. с возможностью получить численное решение за приемлемое время. Основным препятствием для реализации корректно поставленного алгоритма является ограниченный объем оперативной память ЭВМ и ограниченное время счета. алгоритм вычисление математический

Для вычислительных машин численные методы должны обладать свойствами экономичности по числу операций и требуемому объёму памяти. Как правило сложные задачи делятся на более лёгкий, средства решения которых давно уже найдены и легко реализуемы на ЭВМ.

1. Описание вычислительной проблемы

К вычислительным задачам линейной алгебры относят задачи решения систем линейных алгебраических уравнений (СЛАУ) , вычисления обратных матриц , вычисления определителей , задачи вычисления собственных чисел и собственных векторов матриц. Эти задачи имеют очень важное теоретическое и прикладное значение. Трудности решения указанных задач, как правило, связаны с большой размерностью матриц. Чаще всего вычислительные задачи линейной алгебры решают точными и итерационными методами:

- Метод называется точным, если в предположении отсутствия ошибок округлений, получается точное решение за конечное число шагов.

- Метод называется итерационным, если решение получается в виде предела элементов некоторой последовательности.

В точных методах матрицу исходной системы уравнений эквивалентными преобразованиями приводят к более простой матрице или раскладывают на произведение более простых матриц. Большинство точных методов относятся к так называемым методам исключения. В этих методах, последовательно исключая неизвестные, исходную систему приводят к системе с треугольной или диагональной матрицей. Очевидно, что последние легко разрешимы.

В общем случае СЛАУ имеет вид:

Такие системы разделяются по своим качественным характеристикам на:

- Однородные - все свободные члены равны нулю.

- Неоднородные - хотя бы один свободный член не равен нулю.

- Квадратные - количество переменных равно количеству уравнений.

- Прямоугольные - количество переменных не равно количеству уравнений.

- Недоопределённые - количество переменных меньше количества уравнений.

- Переопределённые - количество переменных больше количества уравнений.

Решением же СЛАУ является нахождение значения количества переменных таких, что при подстановке этих переменных на свои места в систему все уравнения превращаются в тождества. Отсюда следуют, что СЛАУ также можно разделить ещё на несколько категорий:

- Совместные имеют хотя бы одно решение.

- Несовместные не имеют решений.

- Определённые имеют одно решение.

- Неопределённые имеют множество решений.

Самым сложным является реализация решения неопределённых СЛАУ, так как результат решения может зависеть от многих факторов:

- Способ реализации алгоритма.

- Конкретная реализация арифметических и логических операций на вычислительной машине.

- Используемое программное обеспечение.

2. Описание изучаемого метода

Метода Гаусса для решения СЛАУ представляет собой метод последовательного исключения переменных, суть которого сводится к приведению расширенной матрицы к верхнетреугольному виду. Причём главная диагональ матрицы А расширенной матрицы Ab заполнена единицами. Такая матрица легко поддаётся нахождению решения СЛАУ, что и происходит на обратном ходе метода.

Как уже было сказано выше, метод Гаусса разделяется на прямой и обратный ход.

На прямом ходе метода Гаусса матрица приводится к верхнетреугольному виду. Получается это в ходе следующего алгоритма:

- Проходимся по каждой строке расширенной матрицы

- Запоминаем значение элемента на главной диагонали:

(1).

- Делим всю строку на это значение:

(2).

- Проходимся по строкам ниже текущей.

- Проходимся по всем столбцам, чьи номера больше номера текущей строки.

- Запоминаем значение (3).

- Вычисляем значения каждого элемента расширенной матрицы по формуле:

(4).

Когда матрица приведена к верхнетреугольному виду решением СЛАУ будет считаться проход в обратном порядке в следующем цикле:

- Проходимся по каждой строке в обратном порядке.

- Проходимся по каждому столбцу в обратном порядке.

- Вычисляем значения переменных Xпо формуле:

(5).

В итоге получаем значения всех переменных X.

Данный метод отлично подходит для вычисления матриц малого размера и прост в реализации на вычислительных машинах. Однако, при матрицах большой размерности недостатки его более очевидны. Например, большая ошибка округления при очень большом количестве операций. К тому же метода не подходит для решения СЛАУ с матрицами, в которых существуют нулевые элементы на главной диагонали.

3. Разработка схемы программы

При разработке программы было решено выполнять её реализацию при помощи парадигмы объектно-ориентированного программирования(ООП). При реализации данной парадигмы структуры данных разбиваются на классы, которые обладают всеми нужными методами и свойствами для отображения математической модели или объективной реальности в программный код. При этом логика программы разбивается не на отдельно стоящие функции или процедуры, а разделяется между реализациями классов.

Таким образом, реализация делится на:

- Создание класса комплексного числа, в котором реализуются основные операции над комплексными числами.

- Создание класса матрицы, в котором реализуются основные операции для создания матриц, их ввод и вывод на экран.

- Реализация алгоритма, соответствующего методу Гаусса для решения систем линейных алгебраических уравнений.

Ниже приведены блок-схемы, отображающие прямой и обратных ход методы Гаусса:

Рисунок 1 - Прямой ход

Основные идентификаторы:

- - матрица коэффициентов.

- _b-- столбец свободных членов.

- i, j, k - счётчики для циклов.

- Tmp - переменная для хранения промежуточных результатов в виде комплексного числа.

- indexes - столбец индексов.

В общем виде алгоритм выглядит следующим образом:

1. Находим столбец с ведущим элементом.

2. Меняем местами текущий столбец и столбец с ведущим элементом.

3. Меняем местами значения индексов.

4. Делим текущую строку на ведущий элемент.

5. Вычисляем значения элементов ниже текущей строки и правее текущего столбца по формуле (4).

На выходе данного алгоритма получается верхнетреугольная матрица.

Рисунок 2 - Обратный ход

Основные идентификаторы:

- _x --столбец переменных x СЛАУ.

- _b --столбец свободных членов.

- _A - матрица коэффициентов.

- x --столбец для хранения решения СЛАУ.

- indexes - столбец индексов.

- i, j, k - счётчики для циклов.

В общем виде алгоритм выглядит следующим образом:

1. Запоминаем значение элемента столбца свободных членов в текущей строке.

2. Вычитаем значение по формуле (5).

3. Получаем столбец переменных.

4. Меняем местами элементы столбца переменных в соответствии со значениями столбца индексов.

На выходе получаем столбец переменных и решение СЛАУ.

4. Разработка листинга программы

Код программы поделён на несколько файлов, каждый из которых содержит реализацию определённого класса:

- Complex.h - объявление класса для хранения комплексного числа.

- Complex.cpp - реализация класса для хранения комплексного числа.

- Matrix.h - объявление класса для хранения матрицы.

- Matrix.cpp - реализация класса для хранения матрицы.

Complex.h и Complex.cpp содержат:

- Методы создания комплексного числа и расположения его в памяти:

- complex().

- complex(double, double).

- complex(constcomplex&).

- Перегрузки операторов для реализации основных арифметических операций:

- complex& operator +(const complex&, const complex&).

- complex& operator -(const complex&, const complex&).

- complex& operator /(const complex&, const complex&).

- complex& operator *(const complex&, const complex&).

- Перегрузки операторов ввода/вывода:

- ostream& operator "(std::ostream&, const complex&).

- istream& operator "(std::istream&, complex&).

- Поля для хранения значений действительной и мнимой частей:

- doublere.

- doubleim.

Matrix.hиMatrix.cpp содержат:

- Методы создания матрицы и расположения её в памяти:

- matrix().

- matrix(int).

- matrix(int, int).

- matrix(constmatrix&).

- Перегрузки операторов ввода/вывода:

- istream& operator "(std::istream&, matrix&).

- ostream& operator "(std::ostream&, matrix&).

- Поля для хранения элементов матрицы:

- std::vector<std::vector<complex" array.

- intsizeN.

- intsizeM.

- Методы для нахождения столбца с ведущим элементом и перемены местами столбцов:

- mainColumn(constint&) const.

- swapColumn(constint&, constint&).

5. Решение контрольной задачи

Решение вручную

На входе получаем матрицу:

Находим ведущий элемент. Ведущий элемент находится в столбце 2, меняем столбцы местами. Запоминаем значение элемента . Делим всю первую строку расширенной матрицы на этот элемент. Вычисляем значения всех остальных элементов матрицы по формулам прямого хода метода:

Находим ведущий элемент. Ведущий элемент находится в столбце 3, меняем столбцы местами. Запоминаем значение элемента . Делим всю вторую строку расширенной матрицы на этот элемент. Вычисляем значения всех остальных элементов матрицы по формулам прямого хода метода:

Находим ведущий элемент. Ведущий элемент находится в столбце 3, меняем столбцы местами. Запоминаем значение элемента . Делим всю вторую строку расширенной матрицы на этот элемент. Вычисляем значения всех остальных элементов матрицы по формулам прямого хода метода:

Исходя из того, что мы меняли местами столбцы, поменялись местами и переменные. Поэтому после того, как мы вычислим значения столбца X, мы должны поменять его элементы местами.

Теперь на обратном ходе метода вычисляем значения переменных СЛАУ.

Меняем местами:

Решение СЛАУ найдено.

Решение с помощью программы

Рисунок 3 - Решение контрольной задачи в программе

Как видно из представленных скриншотов разработанное программное обеспечение позволяет решать СЛАУ с помощью матриц. При этом программа предоставляет достаточную точность результатов, о чём свидетельствует проверка при помощи калькулятора или иного программного обеспечения. Программа реализует все операции над комплексными числами, поэтому пользоваться ими ничуть не сложнее, чем вещественными. При этом достигается хорошая скорость предоставления результата решения.

6. Решение задачи повышенной сложности

Рисунок 4 - Исходная матрица в программе

Рисунок 5 - Решение задачи повышенной сложности в программе

Рисунок 6 - Исходная матрица в MATLAB

Рисунок 7 - Решение задачи повышенной сложности в MATLAB

Как видно из представленных выше рисунков, разработанное программное обеспечение реализует метод Гаусса для решения СЛАУ и при этом обладает точностью решения сопоставимой с MATLAB.

Заключение

При написании курсовой работы была изучена проблемы вычисления значений корней систем линейных алгебраических уравнений и один из методов для реализации этого решения на вычислительных машинах.

Метод Гаусса обладает достаточно большой скоростью при обработке матриц, построенных из СЛАУ, малых размеров, однако, как выяснилось, не очень хорошо справляется при больших размерностях. Также основным недостатком метода Гаусса является невозможность обработки матриц с нулевыми элементами на главной диагонали. Однако, этот недостаток устраняется при реализации выбора ведущего элемента, который несколько замедляет выполнение программы, но делает результат более точным, а сам алгоритм более устойчивым.

Разработанное программное обеспечение продемонстрировало хорошие и точные результаты для матриц малых размеров, что вполне соответствует ожиданиям при реализации метода Гаусса.

Список используемой литературы

1 Амосов А.А., Дубинский Ю.А., Копченова Н.В. Вычислительные методы: учеб. пособие. - М.: Издательский дом МЭИ, 2008. - 672 с.

2 Бахвалов Н.С., Жидков Н.П., Кобельков Г.М. Численные методы: учеб. пособие для вузов. - М.: БИНОМ. Лаборатория знаний, 2006. - 624 с.

3 Турчак Л.И., Плотников П.В. Основы численных методов: учеб. пособие. - М.: Физматлит, 2005.

4 Бьёрн Страуструп. Язык программирования C++ = TheC++ ProgrammingLanguage / Пер. с англ. - 3-е изд. - СПб.; М.: Невский диалект - Бином, 1999. - 991 с. - 3000 экз. - ISBN 5-7940-0031-7 (Невский диалект), ISBN 5-7989-0127-0 (Бином), ISBN 0-201-88954-4 (англ.).

5 Бьёрн Страуструп. Язык программирования C++. Специальноеиздание = The C++ programming language. Special edition. - М.: Бином-Пресс, 2007. - 1104 с. - ISBN 5-7989-0223-4.

Приложение А

Листинг

Main.cpp

#include <cstdlib>

#include "matrix.h"

using namespace std;

matrix gauss(const matrix& A, const matrix& b)

{

matrix _A = A;

matrix _b = b;

matrix _x(_A.getSizeM(),1);

vector<int> indexes(_A.getSizeM());

intindex{0};

complex tmp{0,0};

for(inti{0}; i< (int)indexes.size(); i++) indexes[i] = i;

for(int k{0}; k < _A.getSizeN(); k++)

{

index = _A.mainColumn(k);

_A.swapColumn(index,k);

swap(indexes[k], indexes[index]);

tmp = _A[k][k];

for(int j{0}; j < _A.getSizeM(); j++) _A[k][j] = _A[k][j]/tmp;

_b[k][0] = _b[k][0]/tmp;

for(inti{k+1}; i< _A.getSizeN(); i++)

{

tmp = _A[i][k];

for(int j{k}; j < _A.getSizeM(); j++)

{

_A[i][j] = _A[i][j] - _A[k][j] * tmp;

}

_b[i][0] = _b[i][0] - _b[k][0] * tmp;

}

}

cout""Result:""endl;

cout""A:""endl"_A"endl;

cout""b:""endl"_b"endl;

_x = _b;

for(inti{_A.getSizeN()-1}; i>= 0; i--)

{

for(int j{_A.getSizeM()-1}; j >i; j--)

{

_x[i][0] = _x[i][0] - _x[j][0] * _A[i][j];

}

}

matrix x(_x.getSizeN(),1);

for(inti{0}; i< _x.getSizeN(); i++)

{

x[indexes[i]] = _x[i];

}

return x;

}

intmain() {

matrix A, b;

while(true)

{

cout""A = ";

cin"A;

if(cin.fail() || cin.bad())

{

cin.clear();

cin.sync();

}

else break;

}

while(true)

{

cout""b = ";

cin"b;

if(cin.fail() || cin.bad())

{

cin.clear();

cin.sync();

}

else break;

}

cout""A:""endl"A"endl;

cout""b:""endl"b"endl;

matrix x = gauss(A,b);

cout""x:""endl"x"endl;

system("pause");

return 0;

}

Complex.h

#pragma once

#include <iostream>

#include <iomanip>

#include <cmath>

class complex

{

private:

double re;

double im;

public:

complex();

complex(double, double);

complex(const complex&);

double Re() const;

double Re();

double Im() const;

double Im();

double Abs() const;

complex& operator = (const complex&);

friend complex& operator +(const complex&, const complex&);

friend complex& operator -(const complex&, const complex&);

friend complex& operator /(const complex&, const complex&);

friend complex& operator *(const complex&, const complex&);

friend std::ostream& operator "(std::ostream&, const complex&);

friend std::istream& operator "(std::istream&, complex&);

};

std::istream&errorprint(std::istream&, const char*);

Complex.cpp

#include "complex.h"

complex::complex():re{0.0},im{0.0}

{}

complex::complex(double r, double i):re{r},im{i}

{}

complex::complex(const complex& value):re{value.Re()},im{value.Im()}

{}

double complex::Re(){return re;}

double complex::Im(){return im;}

double complex::Re()const{return re;}

double complex::Im()const{return im;}

double complex::Abs() const

{

return double{std::sqrt(re*re+im*im)};

}

complex&complex::operator =(const complex& right)

{

if(this != &right)

{

re = right.Re();

im = right.Im();

}

return *this;

}

complex& operator + (const complex& left, const complex& right)

{

return (*new complex{left.Re()+right.Re(), left.Im()+right.Im()});

}

complex& operator - (const complex& left, const complex& right)

{

return (*new complex{left.Re()-right.Re(), left.Im()-right.Im()});

}

complex& operator * (const complex& left, const complex& right)

{

double _re = left.Re() * right.Re() - left.Im() * right.Im();

double _im = left.Re() * right.Im() + left.Im() * right.Re();

return *new complex(_re,_im);

}

complex& operator / (const complex& left, const complex& right)

{

double tmp = right.Re() * right.Re() + right.Im() * right.Im();

double _re = (left.Re() * right.Re() + left.Im() * right.Im())/tmp;

double _im = (left.Im() * right.Re() - left.Re() * right.Im())/tmp;

return *new complex(_re,_im);

}

std::ostream& operator "(std::ostream& out, const complex& value)

{

char op;

double _im = value.im;

if(value.im<0)

{

op = '-';

_im *= (-1);

}

else op = '+';

out"value.Re()"std::setw(2)"op"std::setw(10)"_im"'i';

return out;

}

std::istream& operator "(std::istream& in, complex& value)

{

char op = ' ', i = ' ';

double _re, _im;

in"_re"op"_im"i;

if(in.fail())

{

in.clear(std::ios_base::failbit);

}

else if(op != '-' && op!='+')

{

return errorprint(in,"!!!ERROR: Invalid input(Missing '-' or '+')!!!");

}

else if(i != 'i') return errorprint(in,"!!!ERROR: Invalid input(Missing 'i')!!!");

else if(in.bad()) std::cout""!!!ERROR: Stream is corrupted""std::endl;

else

{

if(op == '-') _im *= (-1);

value = complex(_re,_im);

}

return in;

}

std::istream&errorprint(std::istream&in, const char *error)

{

in.clear(std::ios_base::badbit);

std::cout"error"std::endl;

return in;

}

Matrix.h

#pragma once

#include "complex.h"

#include <vector>

#include <algorithm>

#include <cstdlib>

#include <string>

class matrix

{

private:

std::vector<std::vector<complex" array;

intsizeN;

intsizeM;

public:

matrix();

matrix(int);

matrix(int, int);

matrix(const matrix&);

~matrix();

intmainColumn(constint&) const;

void swapColumn(constint&, constint&);

intgetSizeN() const;

intgetSizeM() const;

std::vector<complex>& operator [](int);

matrix& operator = (const matrix&);

friend std::istream& operator "(std::istream&, matrix&);

friend std::ostream& operator "(std::ostream&, matrix&);

};

Matrix.cpp

#include "matrix.h"

matrix::matrix():sizeN{0}, sizeM{0}, array{std::vector<std::vector<complex"(0,std::vector<complex>(0))}

{

}

matrix::matrix(int _size):sizeN{_size}, sizeM{_size}, array{std::vector<std::vector<complex"(_size,std::vector<complex>(_size))}

{

}

matrix::matrix(int _sizeN, int _sizeM):sizeN{_sizeN}, sizeM{_sizeM}, array{std::vector<std::vector<complex"(_sizeN,std::vector<complex>(_sizeM))}

{

}

matrix::matrix(const matrix& value):matrix(value.sizeN, value.sizeM)

{

std::copy(value.array.begin(),value.array.end(),array.begin());

}

matrix::~matrix()

{

array.clear();

}

intmatrix::getSizeN() const

{

return sizeN;

}

intmatrix::getSizeM() const

{

return sizeM;

}

intmatrix::mainColumn(constint& index) const

{

int _index{0};

complex max{0,0};

for(inti = index; i<sizeM; i++)

{

if(max.Abs()<array[index][i].Abs())

{

max = array[index][i];

_index = i;

}

}

return _index;

}

void matrix::swapColumn(constint&i, constint& j)

{

for(int z{0}; z <sizeN; z++)

{

std::swap(array[z][i],array[z][j]);

}

}

std::vector<complex>& matrix::operator [] (inti)

{

if(i<sizeN&&i>=0) return array[i];

}

matrix&matrix::operator =(const matrix& right)

{

if(this!=&right)

{

sizeN = right.sizeN;

sizeM = right.sizeM;

array = std::vector<std::vector<complex"(sizeN,std::vector<complex>(sizeM));

std::copy(right.array.begin(),right.array.end(),array.begin());

}

return *this;

}

std::istream& operator "(std::istream& in, std::vector<complex>&dest)

{

if(dest.size()!=0) dest.clear();

complex _data;

char c = ' ';

inti{0};

for(_data; in"_data;)

{

dest.push_back(_data);

i++;

}

if(in.bad())

{

std::string err = "!!!ERROR: Invalid element input in column "+std::to_string(i)+" !!!";

return errorprint(in,err.c_str());

}

if(in.fail())

{

in.clear();

in"c;

if(c != ';')

{

in.unget();

in.clear(std::ios_base::failbit);

if(dest.size() != 0)

{

dest.clear();

return errorprint(in,"!!!ERROR: Invalid input(Missing ';')");

}

}

}

return in;

}

std::istream& operator "(std::istream& in, matrix& value)

{

std::vector<complex> _strdata;

matrix _matdata;

inti{0};

char c = ' ';

in"c;

if(c!= '[')

{

return errorprint(in,"!!!ERROR: Invalid input(Missing '[')!!!");

}

for(_strdata; in"_strdata;)

{

_matdata.array.push_back(_strdata);

if(i == 0) _matdata.sizeM = _matdata.array[i].size();

i++;

}

if(in.bad())

{

std::string err = "!!!ERROR: Invalid element input in string "+std::to_string(i)+" !!!";

return errorprint(in,err.c_str());

}

if(in.fail())

{

in.unget();

in.clear();

in"c;

if(c != ']') return errorprint(in,"!!!ERROR: Invalid input(Missing ']')!!!");

else

{

_matdata.sizeN = i;

value = _matdata;

}

}

return in;

}

std::ostream& operator "(std::ostream& out, matrix& value)

{

out.precision(4);

out"std::fixed;

for(inti{0};i<value.sizeN;i++)

{

out""[";

for(int j{0}; j<value.sizeM;j++)

{

out"std::setw(12)"value.array[i][j];

}

out""]""std::endl"std::endl;

}

return out;

}

Размещено на Allbest.ru


Подобные документы

  • Принципы разработки математических моделей, алгоритмов и программ. Составление программы вычисления функции с использованием нестандартных функций. Нахождение значения корней нелинейного уравнения по методу касательных. Программа для вычисления интеграла.

    курсовая работа [568,3 K], добавлен 07.03.2015

  • Периодизация развития электронных вычислительных машин. Счетные машины Паскаля и Лейбница. Описаний эволюционного развития отечественных и зарубежных пяти поколений электронных вычислительных машин. Сущность внедрения виртуальных средств мультимедиа.

    доклад [23,6 K], добавлен 20.12.2008

  • Классификация ЭВМ: по принципу действия, этапам создания, назначению, размерам и функциональным возможностям. Основные виды электронно-вычислительных машин: суперЭВМ, большие ЭВМ, малые ЭВМ, МикроЭВМ, серверы.

    реферат [22,8 K], добавлен 15.03.2004

  • Основные этапы развития вычислительных машин. Роль абстракции в вычислительной технике. Понятие "алгоритм" в контексте понятия "вычислительная техника". Изобретатели механических вычислительных машин. Многообразие подходов к процессу программирования.

    презентация [104,7 K], добавлен 14.10.2013

  • Математическое моделирование технических объектов. Понятие математических моделей, классификация и свойства. Численные методы, система MathCAD и её основные функции. Алгоритмический анализ задачи, анализ реализации базовой модели электрической цепи.

    дипломная работа [755,4 K], добавлен 25.07.2012

  • Ранние приспособления и устройства для счета. Появление перфокарт, первые программируемые машины, настольные калькуляторы. Работы Джона Фон Неймана по теории вычислительных машин. История создания и развития, поколения электронно-вычислительных машин.

    реферат [37,7 K], добавлен 01.04.2014

  • Построение графика функции. Поиск корней уравнения методом половинного деления. Определение минимума функции методом перебора и значения аргумента. Вычисление определенного интеграла на заданном отрезке с использованием метода правых прямоугольников.

    контрольная работа [316,1 K], добавлен 13.11.2014

  • Структуры вычислительных машин и систем. Фон-неймановская архитектура, перспективные направления исследований. Аналоговые вычислительные машины: наличие и функциональные возможности программного обеспечения. Совокупность свойств систем для пользователя.

    курсовая работа [797,5 K], добавлен 05.11.2011

  • Анализ средств построения динамически масштабируемых ВС. Разработка алгоритма, обеспечивающего устойчивость функционирования информационно-вычислительных сетей в условиях воздействий компьютерных атак, использующих фрагментированные пакеты сообщений.

    дипломная работа [3,8 M], добавлен 21.12.2012

  • Пути достижения параллелизма вычислений. Понятие и разновидности, а также сферы и особенности использования суперкомпьютеров. Параллельные вычисления как процессы решения задач, в которых могут выполняться одновременно несколько вычислительных операций.

    презентация [8,3 M], добавлен 11.10.2014

Работы в архивах красиво оформлены согласно требованиям ВУЗов и содержат рисунки, диаграммы, формулы и т.д.
PPT, PPTX и PDF-файлы представлены только в архивах.
Рекомендуем скачать работу.