Заключение

В данной работе была описана спецификация программы преобразователь действительных (конвертор р_10) чисел, осуществляющая перевод из p-ичной системы исчисления в десятичную. В разделе «Техническое задание» были прописаны основные требования, предъявляемые к приложению, к программной документации. Были перечислены требования к техническим средствам, на которых будет запущена данная программа. Также были перечислены основные этапы разработки. В разделе «Программа и методика испытаний» были описаны проведенные испытания над программным продуктом и соотнесены с ранее установленными к нему функциональными требованиями. В разделах «Руководство системного программиста» и «Руководство пользователя» были перечислены необходимые программные средства и оборудование, необходимые системному программисту и пользователя соответственно.

Программа «Конвертор p_10» работает согласно приведенной спецификации, без каких-либо сбоев и удовлетворяет заявленным требованиям.

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

1. ГОСТ 19.201 – 78. Техническое задание. Требования к содержанию и оформлению [Текст]. – Москва: Изд-во стандартов, 1980. – 2 с.

2. ГОСТ 19.301– 79. Программа и методика испытаний. Требования к содержанию и оформлению [Текст]. – Москва: Изд-во стандартов, 1980. – 2 с.

3. ГОСТ 19.503– 79. Текст программы. Требования к содержанию и оформлению [Текст]. – Москва: Изд-во стандартов, 1980. – 1 с.

4. ГОСТ 19.503– 79. Руководство системного программиста. Требования к содержанию и оформлению [Текст]. – Москва: Изд-во стандартов, 1980. – 2 с.

5. ГОСТ 19.505– 79. Руководство оператора. Требования к содержанию и оформлению [Текст]. – Москва: Изд-во стандартов, 1980. – 2 с.

Приложение а

Код программы

program Project1;

uses

Forms,

Unit1 in '..\Конвертор25.10.14\Unit1.pas' {Form1};

{$R *.res}

begin

Application.Initialize;

Application.CreateForm(TForm1, Form1);

Application.Run;

end.

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

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls, ComCtrls,Ucontrol,UEdit,UHistory,Utp_to_10;

type

TForm1 = class(TForm)

TrackBar1: TTrackBar;

Edit1: TEdit;

Edit2: TEdit;

Button1: TButton;

Label1: TLabel;

Label2: TLabel;

Label3: TLabel;

Label4: TLabel;

Memo1: TMemo;

Button2: TButton;

Button3: TButton;

Button4: TButton;

Button5: TButton;

Button6: TButton;

Button7: TButton;

Button8: TButton;

Button9: TButton;

Button10: TButton;

Button11: TButton;

Button12: TButton;

Button13: TButton;

Button14: TButton;

Button15: TButton;

Button16: TButton;

Button17: TButton;

Button18: TButton;

Button19: TButton;

Button20: TButton;

Button21: TButton;

procedure TrackBar1Change(Sender: TObject);

procedure Button1Click(Sender: TObject);

procedure FormCreate(Sender: TObject);

procedure Button15Click(Sender: TObject);

procedure Button16Click(Sender: TObject);

procedure Button17Click(Sender: TObject);

procedure Button18Click(Sender: TObject);

procedure Button19Click(Sender: TObject);

procedure Button14Click(Sender: TObject);

procedure Button2Click(Sender: TObject);

procedure Button3Click(Sender: TObject);

procedure Button4Click(Sender: TObject);

procedure Button5Click(Sender: TObject);

procedure Button6Click(Sender: TObject);

procedure Button7Click(Sender: TObject);

procedure Button8Click(Sender: TObject);

procedure Button9Click(Sender: TObject);

procedure Button10Click(Sender: TObject);

procedure Button11Click(Sender: TObject);

procedure Button20Click(Sender: TObject);

procedure Button13Click(Sender: TObject);

procedure Button12Click(Sender: TObject);

procedure Button21Click(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

H: THistory;

E: TEditor;

implementation

{$R *.dfm}

procedure TForm1.TrackBar1Change(Sender: TObject);

begin

Label4.Caption:=IntToStr(TrackBar1.Position);

end;

function DoConvert(digit: String;FC: Tp_10; H:THistory): extended;

begin

H.add(TRecord.Create(digit,Fc.p,Fc.DoTransfer(digit)));

DoConvert:=Fc.DoTransfer(digit);

end;

procedure TForm1.Button1Click(Sender: TObject);

var

i: integer;

begin

Edit2.Text:=FloatToStr(DoConvert(Edit1.Text,Tp_10.Create(TrackBar1.Position),H));

Memo1.Clear;

for i:=0 to H.Count-1 do Memo1.Lines.Add(H.readH(i));

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

H:=THistory.Create;

E:=TEditor.Create;

Edit1.Text:=E.Number;

end;

procedure TForm1.Button15Click(Sender: TObject);

begin

E.Digits(10);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button16Click(Sender: TObject);

begin

E.Digits(11);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button17Click(Sender: TObject);

begin

E.Digits(12);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button18Click(Sender: TObject);

begin

E.Digits(13);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button19Click(Sender: TObject);

begin

E.Digits(14);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button14Click(Sender: TObject);

begin

E.Digits(15);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button2Click(Sender: TObject);

begin

E.Digits(1);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button3Click(Sender: TObject);

begin

E.Digits(2);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button4Click(Sender: TObject);

begin

E.Digits(3);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button5Click(Sender: TObject);

begin

E.Digits(4);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button6Click(Sender: TObject);

begin

E.Digits(5);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button7Click(Sender: TObject);

begin

E.Digits(6);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button8Click(Sender: TObject);

begin

E.Digits(7);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button9Click(Sender: TObject);

begin

E.Digits(8);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button10Click(Sender: TObject);

begin

E.Digits(9);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button11Click(Sender: TObject);

begin

E.Digits(0);

Edit1.Text:=E.Number;

end;

procedure TForm1.Button20Click(Sender: TObject);

begin

E.Sign;

Edit1.Text:=E.Number;

end;

procedure TForm1.Button13Click(Sender: TObject);

begin

E.Clear;

Edit1.Text:=E.Number;

end;

procedure TForm1.Button12Click(Sender: TObject);

begin

E.Backspace;

Edit1.Text:=E.Number;

end;

procedure TForm1.Button21Click(Sender: TObject);

begin

E.Comma(Length(E.Number));

Edit1.Text:=E.Number;

end;

end.

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

unit Utp_to_10;

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

interface

Uses SysUtils,Dialogs;

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

type

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

TBase=2..16;

Tp_10 = class//Преобразователь числа из с.сч.с основанием р в десятичное

private

Fp: TBase; // основание системы счисления

function PCharToInt(d: char):Integer; //переводит символ в его числовое представление //в системах счислени с основаниями от 2 до 16

function PFracTo10(f: String):real; //переводит p-ичную дробь в число

function PIntTo10(r: String):comp; //переводит р-ичное целое в число

procedure SetP(new: TBase); //устанавливает основание системы счисления

public

property p: TBase read Fp write SetP; //чтение/запись основания с.сч.

function DoTransfer(r: String):extended ; //Управляет переводом числа//вычисляет результат

constructor Create(p: TBase); //создаёт объект и нициирует поле Fp

end;

implementation

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

constructor Tp_10.Create(p: TBase);

begin

Fp:=p;

end;

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

function Tp_10.PCharToInt(d: char):Integer; // получить числовое представление разряда в 10 системе

begin

if ((Ord(d)-48)<=9) and ((Ord(d)-48>=0)) then // если код символа d лежит в интервале от 0 до 9 то

result:=Ord(d)-48; // результат равен код символа d - код символа 0

if (Ord(d)<=70) and (Ord(d)>=65) then // если код символа d лежит в интервале от кодов от кода A до F то

result:=Ord(d)-55; // получаем 10-ное представление буквы

end;

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

function Tp_10.PIntTo10(r: String):comp; // получить целую часть числа r

var

i,n,p:integer;

begin

result:=0; // зануляем результат

p:=1; // текущий множитель равен 1

n:=length(r); // получаем количество разрядов

for i:=1 to n do // для всех разрядов (всех символов строки)

begin

result:=result+PCharToInt(r[n])*p; // прибавляем в сумму текущий разряд * множитель

p:=p*Fp; // получаем след множитель

n:=n-1; // переход к след разряду

end;

end;

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

function Tp_10.PFracTo10(f: String):real; // получить дробную часть

var

i,n:integer;

p:extended;

begin

result:=0;

p:=1/Fp; // в -1 степени

n:=length(f);

for i:=1 to n do

begin

result:=result+PCharToInt(f[i])*p;

p:=p/Fp; // переход к след множителю

end;

end;

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

procedure Tp_10.SetP(new: TBase);

begin

Fp:=new;

end;

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

function Tp_10.DoTransfer(r: String):extended; // получает строку с числом по основанию p, возвращает число в десятичной системе

var

m:integer; // отрицательность числа

n:integer; // номер текущего символа

l:integer; // длина входной стоки

t:integer; // была ли обнаружена точка

g:string;

f:string;

z:string; // рабочая строка (копия входной)

begin

z:=r; // копируем входную строку в строку z

l:=length(r); // длина строки r

t:=0; // точка не обнаружена

f:=r;

n:=1;

result:=0; // зануляем результат (сумму)

m:=0; // говорим что число неотрицательное

// обработка отрицательности

if r[1] = '-' then // если число отрицательное то

begin

m:=1; // запоминаем, что оно отрицательное

delete(r,1,1); // удаляем 1 символ -

end;

// поиск точки

while (n<>l) do // пока не дошли до конца строки

begin // делаем алгоритм анализа 1 символа(текущего) и убираем его из строки z

if z[1]='.' then t:=1; // если обнаружена точка то запоминаем эту ситуацию

delete(z,1,1); // убираем из z певый символ

n:=n+1; // переход к след символу

end;

// получаем модуль числа

g:=''; // зануяем строку

if t=1 then // если точка была обнаружена то

begin

// копирыем в g всю входную строку до точки

while r[1]<>'.' do // пока первый символ(текущий) не будет точкой

begin

g:=g+r[1]; // приклеиваем в g текущий символ

delete(r,1,1); // удаляем из входной строки 1 символ

end;

delete(r,1,1); // удаляем точку

result:=PIntTo10(g); // в результат пишем целую часть числа

result:=result+PFracTo10(r); // в результат прибавляем дробную часть

end

else // если число не дробное (те целое)

begin

result:=PIntTo10(r); // в результат пишем целую часть

end;

// учитываем знак

if m=1 then result:=result*(-1); // если число отрицательное то учитываем это

end;

end.

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

unit Ucontrol;

interface

uses SysUtils, Utp_to_10, UEdit,UHistory;

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

type

TState = (cEditing,cEndEditing);//Редактирование,РедактированиеЗавершено

TCtrl = class // класс управления для конвертора

private

FE: TEditor; // Редактор

FState: TState; // Состояние

FC: Tp_10; // Конвертор

H:THistory; // история

procedure SetP(new: TBase);//Установить основание с.сч.

public

property State: TState read FState write FState;//Свойство Состояние

property P: TBase write SetP;//Свойство Основание. Запись основания с.сч.

constructor Create;//Создание объекта Управление класса TCtrl

function DoCommand: String;//Выполнить команду

destructor Destroy;override;//Удаление объекта из памяти

end;

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

var Control: TCtrl;

implementation

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

constructor TCtrl.Create;

begin

FE:=TEditor.Create;

FState:=cEditing;

FC:=Tp_10.Create(2);

H:=THistory.Create;

end;

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

procedure TCtrl.SetP(new: TBase);

//устанавливает основание системы счисления

begin

FC.p:=new;

end;

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

function TCtrl.DoCommand: String;

var

i, j, k : integer; //fc(tp_10), fe(TEditor)

m, r, s, v: string;

g:TBase;

begin

m:='0';

while m<>'exit1' do

begin

writeln('1 - Edit number');

writeln('2 - Transfer number to decimal system');

writeln('3 - Change numerical system');

writeln('4 - History');

writeln('5 - Exit');

readln(i);

case i of

1 : FE.Edit;

2 :

begin

v:= FE.Number;

FC.DoTransfer(FE.Number);

writeln('chislo ',v,' s osnovaniem ',FC.p,' = ',FC.DoTransfer(FE.Number));//,FE.Number);

// модифицируем историю

H.add(TRecord.Create(FE.Number,FC.p,FC.DoTransfer(FE.Number)));

end;

3 :

begin

write('vvedite osnovanie sistemi schisleniya ');

readln(g);

FC.p:=g;

end;

4:

begin

for i:=0 to H.Count-1 do Writeln(H.readH(i));

end;

5 : m:='exit1';

end;

end;

end;

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

destructor TCtrl.Destroy;

begin

end;

initialization

Control:= TCtrl.Create;

finalization

Control.Free;

end.

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

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

unit UEdit;//редактор

interface

uses SysUtils;

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

const

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

cBegString = '0,';//начальная строка

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

type

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

EOverSizingIn = class(Exception);//превышение допустимой длины числа

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

TEditor = class//Редактор чисел представленных в с.сч с основанием от 2..16

private

public

FNumber: String;//вводимая и редактируемая строка - р-ичное число

function Backspace(): String;//удаляет символ справа

function Clear: String;//удаляет введённое значение - очистка строки

function Comma(p:integer): String;//добавить запятую к вводимому числу

function IsComma():boolean;//определяет, есть ли точка

function Sign(): String;//добавить знак к вводимому числу

procedure AddZero;//добавить '0' к вводимому числу

function IntToChar(p: integer): Char;// число в р-ичный символ

function Digits(p: integer): String;//добавить символ к вводимому числу

function LenNum(): Cardinal;//количество разрядов для представления числа

function Edit(): String;//управляет вводом и редактированием

function Get(): String;//Читает число

property Number: String read Get write FNumber;

constructor Create;//инициирует строку начальным значением

end;

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

implementation

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

procedure TEditor.AddZero; //добавить '0' к вводимому числу

begin

Fnumber:=Fnumber+'0';

end;

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

function TEditor.Backspace(): String; //удаляет символ справа

begin

delete(FNumber,Length(FNumber),1);

result:=Fnumber;

end;

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

function TEditor.Clear: String; //удаляет введённое значение - очистка строки

begin

FNumber:='';

result:=FNumber;

end;

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

function TEditor.Comma(p:integer): String; //добавить запятую к вводимому числу

var

m,i:integer;

r,l:string;

begin

if IsComma then

begin

writeln('tochka uzhe est!');

exit;

end;

if (length(FNumber)<p)then

begin

result:=FNumber;

exit;

end;

r:=FNumber;

if r[1] = '-' then

begin

m:=1;

delete(r,1,1);

end;

if p=1 then

result:='0.'+Number else

begin

for i:=1 to p-1 do

begin

l:=l+r[1];

delete(r,1,1)

end;

result:=l+'.'+r;

end;

if m=1 then

result:='-'+result;

Number:=result;

end;

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

function TEditor.IsComma():boolean; //определяет, есть ли точка

var

l:string;

i:integer;

begin

l:=FNumber;

result:=false;

for i:=1 to length(l) do

begin

if l[1]='.' then

result:=true;

delete(l,1,1);

end;

end;

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

constructor TEditor.Create; // конструктор

begin

FNumber:='';

end;

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

function TEditor.Digits(p: integer): String; //добавить символ к вводимому числу

begin

Fnumber:=Fnumber+IntToChar(p);

result:=Fnumber;

end;

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

function TEditor.IntToChar(p: integer):Char; // получить представление разряда в виде символа

begin

if (p<=9) and (p>=0) then

result:=Chr(p+48);

if (p<=15) and (p>=10) then

result:=Chr(p+55);

end;

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

function TEditor.LenNum(): Cardinal; //количество разрядов для представления числа

var

r,t,i:integer;

s:string;

begin

t:=0;

s:=FNumber;

r:=length(FNumber);

// получаем информацию о том, есть ли точка в числе

for i:=1 to r do

begin

if s[1]='.' then

t:=1;

delete(s,1,1);

end;

// определяем длину строки без учера знака

if FNumber[1]='-' then

result:=length(FNumber)-1

else

result:=length(FNumber);

// учитываем точку

if t <> 0 then result:=result-1; // если точка есть то от результата отнимаем 1 (чтобы точку не учесть)

end;

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

function TEditor.sign:String;

begin

if FNumber[1]='-' then

delete(FNumber,1,1) else

FNumber:='-'+FNumber;

end;

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

function TEditor.Get(): String; // получить результирующую строку

begin

result:=FNumber;

end;

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

function TEditor.Edit(): String; // функция выбора команды

var

s,j:string;

i, p,l:integer;

begin

while j<>'exit' do

begin

j:='0';

// выводим меню

writeln('Vibirete nujnoe deystvie');

writeln('-----------------------------------------');

writeln('1 - vvesti chislo');

writeln('2 - dobavit znak(Sign)');

writeln('3 - dobavit 0(AddZero');

writeln('4 - dobavit simvol(Digits)');

writeln('5 - kol-vo razryadov(LenNum)');

writeln('6 - udalit znachenie(Clear)');

writeln('7 - udalit simvol sprava(BackSpace)');

writeln('8 - dobavit zapyatuu(Comma)');

writeln('9 - Vihod');

// читаем команду

readln(i);

// обработка команды

case i of

1 :

begin

write('chislo = ');

readln(s); Number:=s;

writeln('chislo posle vvoda = ', number);

end;

2 :

begin

Sign;

writeln('Chislo posle izmeneniya znaka=', Number);

end;

3 :

begin

AddZero;

writeln(' chislo posle dobavleniya nulya = ', Number);

end;

4 :

begin

write('vvedite chislo =');

readln(p);

writeln('chislo posle dobavleniya 5 =', Digits(p));

end;

5 : writeln('kol-vo razryadov =', LenNum);

6 : writeln('Clear =', Clear);

7 : writeln('chislo posle udaleniya sprava =', BackSpace);

8 :

begin

write('pered kakim razryadom postavit tochku? = ');

readln(l);

Comma(l);

writeln('Chislo posle dobavleniya zapyatoy=', Number);

end;

9 : j:='exit';

else writeln('takoy komandi net');

end;

readln;

end;

end;

end.

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

unit UHistory;

interface

uses SysUtils, Classes;

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

type

TBase=2..16; // тип основания системы счисления

TRecord = class //Запись в историю

CH: string; //Число в с.сч. с основнием OSN

OSN: TBase; //Основание системы счисления представления числа

RES: real; //Число в с.сч. с основнием 10

constructor Create(a:string; b:TBase; c:real); // конструктор

function TRecToStr:string; // преобразовать в строку

end;

THistory = class(TList) //История работы приложения за сеанс (наследник от TList)

procedure add(R:TRecord); // вставка записи

procedure ClearRec; // очистка истории

function readH(i:integer):string; // получить i-ю запись истории

end;

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

implementation

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

constructor TRecord.Create(a:string; b:TBase; c:real); // конструктор класса одной записи

begin

CH:=a;

OSN:=b;

RES:=c;

end;

function TRecord.TRecToStr:string; // получить строку записи

begin

result:='osn='+IntToStr(Osn)+'; ish. chislo='+CH+'; result='+FloatToStr(RES)+';';

end;

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

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

procedure THistory.add(R:TRecord);

begin

inherited add(R); // вызываем унаследованный метод add

end;

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

function THistory.readH(i:integer):string; // получить строку i-й записи истории

begin

result:=TRecord(Items[i]).TRecToStr; // берем неопределенный указатель Items[i], потом уточняем его тип, говорим что он указывает на нашу запись TRecord(Items[i])

end;

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

procedure THistory.ClearRec;

var

i:integer;

begin

for i:=0 to count do // для всех указателей списка Items (Items,count - унаследовано)

TRecord(Items[i]).Free; // удаляем элемент на который указывает i-й указатель списка

Clear; // очищаем список (унаследованый метод)

end;

end.

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