Ответы на билеты

Класс valarray

Для эффективной работы с массивами чисел в стандартной библиотеке определен шаблонный класс ​vаlarray.​Операции с этим классом реализованы с расчетом на их поддержку в архитектурах высокопроизводительных систем. В библиотеке описаны также четыре вспомогательных класса, позволяющих получить различные подмножества ​valarray: slice_array, gslice_array, mask_array и indirect_array.​Все эти классы реализованы как шаблоны классов с параметром, представляющим собой тип элемента массива.

Для использования класса ​valarray​и связанных с ним средств требуется подключить к программе заголовочный файл ​<valаггау>.​В нем описаны, кроме перечисленных шаблонов классов, классы ​slice​и ​gslice,​задающие подмножества индексов массива, а также заголовки функций, предназначенных для работы с этими шаблонами и классами.

Шаблон ​slice_array​представляет собой строку, столбец или другое регулярное подмножество элементов ​valarray​​(например, его четные элементы). С помощью этого шаблона можно представлять ​valarray​как матрицу произвольной размерности. Шаблон ​gslice_array​позволяет задавать более сложные законы формирования подмножества массива, а ​mask_array​— произвольные подмножества с помощью битовой маски. Шаблон ​indirect_array​содержит не сами элементы массива, и их индексы.

Вклассе ​valarrayопределены ​конструкторы​, позволяющие создавать пустой массив

имассив, заполненный одинаковыми или заданными значениями:

tempiate<class Т> class valarray{ public:

//Массив нулевого размера: valarray();

//Массив из n элементов (к каждому применяется конструктор по умолчанию): explicit valarray(size_t n);

//Массив из n элементов со значением v: valarray(const Т&v, size__t n);

//Массив из n элементов со значениями из массива m: valarray(const Т* m, size_t n);

//Конструктор копирования valarray (const valarray&);

//Массив со значениями из среза:​??????????

valarray(const slice_array<T>&);

//Массив со значениями из обобщенного среза: ?????

valarray(const gslice_array<T>&); //Массив со значениями из подмножества: valarray(const mask_array<T>&);

//Массив со значениями из indirect_array: Valarray (const indirect_array<T>&);

Примеры создания массивов

valarray <double> v1; //пустой массив

valarray <int> v2(100);//массив из 100 элементов, каждый по умолчанию обнулен valarray <int> v3(5,100);//массив из 100 элементов, равных 5

cons tint m={4,4,3,6,2};

valarray <int> v4(m,5);массив из 5 элементов: 4,4,3,6,2

В массивах определены операции ​доступа по индексу и присваивания​:

Т operator[](size_t) const; Т& operator[](size_t);

// Копирование массива:

valarray<T>& operator=(const valarray<T>&); //Присваивание одного и того же значения всем элементам: valarray<T>& operator=(const Т&);

//Присваивание подмножеств массиву valarray: valarray<T>& operator=(const slice_array<T>&); valarray<T>& operator=(const gslice_array<T>&); valarray<T>& operator=(const mask_array<T>&); valarray<T>& operator=(const inclirect_array<T>&);

Нумерация элементов массива ​valarray​начинается с 0. Проверка выхода за пределы диапазона не производится.

Кроме приведенных выше, определены операции обобщенной индексации, или извлечения подмассивов из ​valarray:​

indirect_array<T> operator[](const valarray<size_t>&);

Формы операций с ​const​возвращают подмножество как новый массив типа ​valarray,​ а формы без ​const​— как массив соответствующего типа.

Определены ​унарные операции +,­,~и !, ​бинарные операции +, ­, *, /, %, ^, &, |, «, », а

также соответствующие ​сложные присваивания ​(+=, '^= и т. д.), вторым операндом которых может быть как число, так и массив, например:

valarray<T>& opGrator+= (const Т&); valarray<T>& operator+= (const valarray<T>&);

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

определен. Операции ​<<​и ​>>​обозначают поразрядный сдвиг каждого элемента (то есть не сдвиг элементов и не ввод/вывод).

Примеры:

v4+=1;//результат ­ 5,5,4,7,2 (v4 описан выше) v2+=v3;//v2[i]=v2[i]+v3[i] для i=1,..,100 v4>>=1;//результат – 2,2,2,3,1

В классе ​valarray​определены следующие ​методы​: zize_t size() const;//размер массива

T sum() const;//сумма элементов

T min() const;//наименьшее значение T max() const;//наибольшее значение

//Логический сдвиг на 1 элементов (влево, если 1>0): valarray<T> shiftdnt 1)const;

//Циклический сдвиг на 1 элементов (влево, если 1>0): valarray<T> cshiftdnt) const;

//Применение функции func к каждому элементу массива: valarray<T> apply(Т func(T)) const;

valarray<T> apply(Т func(const T&)) const;

//повторная инициализация (все элементы заменяются на значение по умолчанию, размер вектора – sz):

void res1ze(size_t sz, Т с = T()) ;

Функции сдвига ​shift​и ​cshlft​и применение функции ​apply​возвращают новый массив, при этом исходный остается без изменений. При логическом сдвиге освободившиеся значения заполняются значением по умолчанию для данного типа элементов.

Повторная инициализация с помощью ​resize​не предназначена для того, чтобы динамически изменять размер существующего массива. Предполагается, что ​valarray используется для быстрой работы с числами и его размер остается постоянным в течение всего времени его использования.

К массивам можно применять функции ​abs, acos, asin,atari,atan2,cos,cosh, exp, log, loglO, pow, sin, sinh, sqrt, tan, tanh,​например:

v2=cos(v3);//v2[i]=cos(v3[i]) для i=1,..,100

Поскольку элементы массива val array представляют собой последовательность, к нему применимы все ​стандартные алгоритмы и итераторы​, рассмотренные в предыдущих разделах. Но более эффективно работать с массивом через срезы и подмножества, рассматриваемые в следующем разделе.

Для ​valarray определены ​логические операции <, >, ==, != и т. д., дающие в результате массив типа ​bool,​каждый элемент которого равен результату операции, примененной к паре соответствующих элементов сравниваемых массивов, например:

tempiate<class Т> valarray<bool>

operator== (const valarray<T>&, const valarray<T>&); tempiate<class T> valarray<bool>

operator!= (const valarray<T>&, const valarray<T>&);

Если размеры массивов, участвующих в операции, не совпадают, результат не определен.

Вспомогательные классы

Класс ​slice​(​срез​) позволяет задать подмножество индексов элементов массива: class slice{

public:

slice();

slice(size_t star, size_t size, size_t stride); size_t star() const;//индекс первого элемента size_t size() const;//число элементов

size_t stride() const;//шаг

};

Шаг — это расстояние между двумя элементами среза. Например, ​slice(3, 4, 2) задает срез, состоящий из элементов массива с номерами 3, 5, 7, 9, а ​sliced.(1, 3, 4)

— с номерами 1, 5, 9. Таким образом, с помощью срезов можно представить массив как матрицу, задав в нем строку или столбец.

Теперь можно привести пример операции индексации подмножеств массива ​valarray,​ описанной в предыдущем разделе: оператор ​a[slice(l. 5. 3)] = b​выполнит присваивание массива b только элементам массива а, заданным срезом.

Для удобной работы с подмножеством элементов массива введен шаблон класса slice_array.​Самостоятельные объекты этого класса не создаются, все обращения к ним на самом деле переадресуются на исходный массив:

slice_array<double>& s1=v2[slice(0,v.size()/10,10)] //увеличить на 5 первый столбец матрицы 10Х10: s1+=5;

slice_array<double>& s2=v2[slice(0,v.size()/10,1)]

//увеличить в 2 раза каждый элемент первой строки матрицы 10Х10: s2*=2;

В шаблоне ​sliсе_агray​определены сложные операции присваивания (+=, *=, >= и т. д.), например:

void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const;

Они выполняют указанные действия с аргументом и элементами исходного массива, заданными срезом, на которые ссылается ​slice_array.​Кроме того, определена операция присваивания скалярного значения, которая выполняет присваивание всем элементам исходного массива, входящим в срез.

Стандартная библиотека не предоставляет средств для работы с матрицами, но с помощью абстракций, задаваемых срезами, можно эффективно работать с массивом valarray​как с матрицей произвольной размерности.

Если требуется работать с подмножеством, которое нельзя задать одним срезом, используется шаблон ​gslice​— ​обобщенный срез​:

class gslice{ public:

gslice():

gslice(size_t s. const valarray<size_t>& len,

const valarray<size_t>& d);

size_t start() const; // индекс первого элемента valarray<size_t> size() const; // число элементов в измерении

valarray<size_t> stride() const; // шаги для индекса[0]. индекса[1]....

};

Обобщенный срез задает несколько срезов. Индекс начального элемента указывается первым параметром ​s,​размеры срезов передаются через массив ​len,​а шаги — через массив ​d.​Размерности массивов, определяющие количество задаваемых срезов, должны совпадать.

Например, если задать параметры

start = 0

len ={2. 3}

d = {4. 1}

получим последовательность индексов массива

k = (0,1) x 4 + (0,1,2) x 1

которые дадут в результате матрицу 2x3 из левого верхнего угла матрицы 3x4, расположенной в памяти по столбцам (первый срез с длиной 2 и шагом 4 описывает два элемента строки, второй — с длиной 3 и шагом 1 — описывает три элемента

00 10 20 30 01 11 21 31 02 12 22 32

Теперь, чтобы, например, обнулить элементы подматрицы 2x3, можно записать: valarray<double> v(1,12); // Создаем массив из единиц

int length[] = {2, 3}; int str[]={4,1};

valarray<int> len (length,2); valarray<int> d (str,2);

//обнуляем элементы v[0],v[1],v[2],v[4],v[5],v[6]: v[gslice(0,len,d)]=0;

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

Если требуется задать произвольное подмножество элементов массива, для которого нельзя описать закон изменения индексов, используют ​логический массив mask_array,​который представляет собой ​valarray<bool>.​Элемент этого массива, равный ​true,​означает, что соответствующий элемент ​valarray​включается в под​

множество. Для ​mask_array​определен тот же набор полей и методов класса, что и для gslice_array.​

Объекты этого класса получаются в результате использования в операциях обобщенной индексации ​valarray,​описанных в предыдущем разделе, например:

bool m[] = {true, true, false, true, false}; valarray<bool> mask (m, 5);

//Элементам номер 0. 1 и 2 массива v6 присваивается значение синуса соответствующих элементов массива v4

valarray<int> v6 = sin(v4[mask]);

Другой способ выделения произвольного подмножества, позволяющий переупорядочивать элементы ​valarray,​является ​косвенный массив ​indirect_array.​ В нем задается последовательность индексов массива. Объект этого класса создается при использовании в качестве индекса ​valarray<size_t>,​например:

int i[]={3,2,4,0,1}; valarray<int> index (i, 5); valarray<int> v7 = v4[index];

// v7[0] = v4[3], v7[l] = v4[2], v7[2] = v4[4], v7[3] = v4[0], v7[4] = v4[l]

Число элементов массива, используемого в качестве индекса, не должно превышать число элементов в индексируемом массиве.

Перечисленные классы — ​slice_array,​​gsl1ce_array,​​mask_array​и ​indirect_array

— нельзя создавать впрямую и копировать. Они прозрачны для пользователя и создаются в результате использования в качестве индекса массива va1array срезов, обобщенных срезов, логических массивов ​valarray​и массивов типа ​size_t соответственно.

Бизнес проект ­ практическая задача АЗС

­Use case

­Диаграмма деятельности

­RUP докуметация(???​ ​)

­потребности заинтересованных лиц (для кого и зачем)

­видение

­риски

Диаграмма Ганта

●допустим 3 месяца

●начальная стадия ­ составление документов и тд

●проектирование ­ формулирование требований к системе, спецификация

●диаграмма классов по спецификации

●разработка

●тестирование

О_О анализ

­use­case

­диаграмма деятельности

­диаграмма классов

­диаграмма последовательностей

­диаграмма объектов

­диаграмма пакетов

­диаграмма развертывания

­диаграмма компонентов