Скрины к программе

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
// обработка события OnPaint
void __fastcall TForm1::FormPaint(TObject *Sender)
{
 Grafik();
}
// обработка события OnResize
void __fastcall TForm1::FormResize(TObject *Sender)
{
 TRect ret = Rect(0,0, ClientWidth, ClientHeight) ;
 Canvas ->FillRect(ret); // стереть
 Grafik();
}
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 Grafik() ;
}
//---------------------------------------------------------------------------
 
 
#include "math.h" // для доступа к sin и ехр
// функция, график которой надо построить
 float f(float x)
{
return sin(x)+x*x;
}
void TForm1::Grafik()
{
 float xmin,xmax,ymin,ymax;// преременные для рассчета мин и макс на заданном
                           //с клавиатуры промежутке
 float z,t,a,j;//координаты вывода таблицы
 float x1, x2; // границы изменения аргумента функции
 float y1, y2; // границы изменения значения функции
 float x; // аргумент функции
 float y; // значение функции в точке х
 float dx; // приращение аргумента
 int l, b; // левый нижний угол области вывода графика
 int w, h; // ширина и высота области вывода графика
 float mx, my; // масштаб по осям X и Y
 int x0, y0; // начало координат
 // область вывода графика
 l = 10; // X — координата левого верхнего угла
 b = Form1->ClientHeight-20; // Y — координата левого нижнего угла
 h = Form1->ClientHeight-100; // высота
 w = Form1->Width -400; // ширина
 
 xmin=StrToFloat(Edit3->Text);// запоминаем начало промежутка
 xmax=StrToFloat(Edit4->Text);// запоминаем конец промежутка
 dx=StrToFloat(Edit5->Text);// запоминаем шаг
 
 //найдем мин макс значения функции на данном промежутке
 x=xmin;
 ymax=f(x);
 ymin=f(x);
 
 z=700;
 t=75;
 a=850;
 j=75;
 
 
 do
 {
  y=f(x);
  if (y<ymin) ymin=y;
  if (y>ymax) ymax=y;
 Canvas->TextOutA(z-7,t, (x));
 Canvas->TextOutA(a-50,j, (y));
 Canvas->MoveTo(z-10,t-5);
 
 
  x+=dx;
 
  t+=20;
  j+=20;
 
 Canvas->LineTo(z-10,t-2) ;
 Canvas->LineTo(a+50,j-2);
 
 }
while (x<=xmax);
 z=700;
 t=75;
 
Canvas->MoveTo(900,j-2);
Canvas->LineTo(900,70);
Canvas->LineTo(900,70);
Canvas->LineTo(z-10,t-5);
Canvas->MoveTo(z+90,70);
Canvas->LineTo(z+90,j);
 
 Edit1->Text=ymin;//выводим полученное мин значение
 Edit2->Text=ymax;//выводим полученное макс значение
 
 x1 = -5; // нижняя граница диапазона аргумента
 x2 = 5; // верхняя граница диапазона аргумента
 dx = 0.628; // шаг аргумента
 // найдем максимальное и минимальное значение
 // функции на отрезке [xl,x2]
 x = x1;
 y1 = f(x); // минимум
 y2 = f (x); // максимум
 
 do
 {
   y = f (x);
   if ( y < y1) y1 = y;
   if ( y > y2) y2 = y;
   x+= dx;
 }
  while (x <= x2);
 // вычислим масштаб
  my = (float)h/abs(y2-y1); // масштаб по оси Y
  mx = w/abs(x2-x1); // масштаб по оси X
 // оси
 x0 = 1+abs (x1*mx) ;
 y0 = b-abs (y1*my) ;
 Canvas->MoveTo (x0+5,b) ; Canvas ->LineTo (x0+5,b-h) ;
 Canvas ->MoveTo (l-2,y0) ;Canvas->LineTo (l+w,y0) ;
 Canvas->TextOutA(x0+5,b-h, FloatToStrF(y2, ffGeneral, 6,3));
 Canvas->TextOutA(x0+5,b, FloatToStrF(y1, ffGeneral, 6, 3)) ;
 // построение графика
 x = x1;
 Canvas->Pixels [x0+x*mx] [y0-y*my] = clRed;
 Canvas->MoveTo ((x0+x*mx),(y0-y*my));
 
 do
 {
  y = f (x);
  Canvas ->LineTo ((x0+x*mx),(y0-y*my)) ;
  x+= dx;
 }
 while (x <= x2) ;
 Edit1->Text=ymin;
 Edit2->Text=ymax;
 
}
 
 
 
//---------------------------------------------------------------------------

#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<stdlib.h>
#include<alloc.h>
#include<math.h>
#include<graphics.h>
#include<dos.h>
#define MAXPOINTS 2000       /* максимальное количество точек */
#define LINEGRAPH           /* строить линейный     график */
float *x, *y;           /* указатели на массивы для точек графика */
              
int Xe0, Ye0, Xe1, Ye1;      /* координаты окна вывода графика: левый    верхний угол и правый нижний */
float MaxX,MaxY,MinX,MinY;
/* максимальное и минимальное
значение аргумента и функции */
    
int n;  /*количество точек в графике */
float a, b,  /* пределы построения графика */
ax, ay;     /* коэффициенты
масштабирования */
char * teststr = "+000000000.000";
/* тестовая строка для вывода оцифровки */
/*   Установка графического режима    */
void grinit(void)
{
int gd = DETECT,             /* выбрираемый драйвер */
gm,                     /*выбираемый режим */
errcode;                /* код ошибки */
initgraph(&gd, &gm, "");    /* инициализируем графический режим */
 
errcode = graphresult();        /* получаем код ошибки */
 
if(errcode!=grOk)           /* если произошла ошибка */
 
 {
Puts(“Ошибка инициализации графического режима!”);
exit(-1);           /* прерываем программу */ 
}
 }
/*   Выбор размеров и положения окна      */
void setlimits(void)
{
Xe0 = textwidth(teststr)+10;           /* слева оцифровка + зазор */
Ye0 = 10;                               /* cверху зазор */
Xe1 = getmaxx() – 40  /* справа зазор + окончание подписи
оси */
Ye1 = getmaxy() - 2*textheight(teststr)-10;  /* снизу две строки подписи + зазор */
}
/*   Выделение памяти     */
int allocatememory(void)
{
int ret=0;  /* возвращаемое значение */
if(coreleft() >= 2*(n+1)*sizeof(float)) /* если памяти достаточно */
{   
x=(float*)calloc(n+1,sizeof(float)); /* выделяем */
y=(float*)calloc(n+1,sizeof(float));
ret = 1;     /* признак успешно выделенной
памяти */
} 
return ret;
 }
/*   Освобождение памяти   */
void freememory(void)
{
free(x);
free(y);
}
/*===== Функция, график которой строим на экране =====*/
float myfunc(float x)
/* Примечание: локальная переменная x перекрывает глобальный
указатель на массив x , поэтому обращаться к массиву x[] в этой
функции нельзя */
{
float y;
y=sin(x/2)*x;
return y;
}
/*  Заполнение массивов точками графика */
void fillarray(void)
{
float *xp=x, *yp=y; /* указатели на массивы точек графика */
float t, dt;    /* текущее значение аргумента и шаг изменения */
int i; 
MaxY=-1E20;     /* задаем заведомо нереальные */
MinY=-MaxY; /* пределы изменения
значений функции */
/* Чтобы получилось ровно n точек надо организовать цикл по i,
иначе из-за погрешности вычисления dt и сравнения t<=b может
рассчитаться только n-2 точки, либо будет рассчитана n-я
точка, для которой не выделена память*/
 
dt=(b-a)/(n-1); /* шаг перемещения по отрезку */
for (t=a,i=0;i<n;i++,t+=dt,xp++,yp++)
{                   /* от начала до конца отрезка */
*xp=t;              /* запоминаем аргумент */
*yp=myfunc(t);          /* вычисляем значение функции */
if(*yp>MaxY)            /* сразу определяем */
MaxY=*yp;           /* максимальное */
if(*yp<MinY)            /* и минимальное значения функции*/
MinY=*yp;
}
MinX=a;                 /* в данном случае пределы изменения */
Maxx=b;             /* аргумента известны */
}
/*   Функция масштабирования по X    */
float xscreen(float x)
{
return Xe0 + (int)((x-MinX)*ax);
}
/*   Функция масштабирования по Y    */
float yscreen(float y)
{
return Ye1 - (int)((y-MinY)*ay);
}
/*   Процедура вывода фона, сетки и оцифровки      */
void drawbg(char * xwrite, char * ywrite, char * gwrite)
{
int i, temp,
xn,yn;  /* количество чисел на осях */
float xo[30], yo[30],   /* массивы для оцифровки */
dt;  /* шаг изменения аргумента */
char s[40];     /* буфер для формирования строки
                                из числа */
/* выводим обрамление графика */
setcolor(14);    /* желтый цвет */
setlinestyle(SOLID_LINE, 0, 1); /* сплошная тонкая линия */
rectangle(Xe0, Ye0, Xe1, Ye1);  /* прямоугольник вокруг окна
вывода */ /*
setcolor(15);   /* белый цвет */
/* тип линии остался неизменным - сплошная тонкая */
temp = yscreen(0);   /* положение оси Х */
if(temp>Ye0 && temp <Ye1) )     /* если попадает на экран */
line(Xe0,temp,Xe1,temp);      /* нарисовать ось */
temp = xscreen(0);   /* положение оси Y */
if(temp>Xe0 && temp<Xe1)        /* если попадает на экран */
line(temp,Ye0,temp,Ye1);        /* нарисовать ось */
/* подготавливаем оцифровку: расчетное количество точек */
xn = 1 + (int)((Xe1-Xe0)/textwidth(teststr));
if(xn > 9)  /* не более 9 точек по горизонтали */
xn = 9;
yn = 1 + (int)((Ye1-Ye0)/textheight(teststr)/3);
if(yn>11)   /* не более 11 по вертикали */
yn = 11;
dt = (MaxX - MinX) / xn ;   /* создаем оцифровку по оси Х */
xo[0] = MinX;    /* с начала отрезка с шагом dt */
for(i=1;i<xn+1;i++) /* заполняем xn+1 элемент массива*/
xo[i]=xo[i-1]+dt;
dt = (MaxY - MinY) / yn;     /* создаем оцифровку по оси Y */
yo7[0] = MinY;
for(i=1;i<yn+1;i++) 
yo[i]=yo[i-1]+dt;
/*   выводим сетку и оцифровку     */
/*    устанавливаем    выравнивание    текста    по    центру    по горизонтали и по верхней линии по вертикали */
settextjustify(CENTER_TEXT,TOP_TEXT);
setcolor(7);     /* серый цвет */
for(i=0;i<=xn;i++)  /* по оси Х */
{
temp = xscreen(xo[i]);  /* положение линии сетки */
if(i>0 && i<xn)  /* если не первая и не последняя */
{
setlinestyle(DOTTED_LINE, 0, 1);
/* точечная тонкая линия */
line(temp,Ye0,temp,Ye1);
/* вывести линию сетки */
}
setlinestyle(SOLID_LINE,0,1);
/* сплошная тонкая линия */
 
sprintf(s,”%6.2f”,xo[i];     /* сформировать из числа строку */
outtextxy(temp,Ye1+3, s);   /* вывести на экран */
}
/* устанавливаем выравнивание текста вправо по горизонтали и
по центру по вертикали */
settextjustify(RIGHT_TEXT,CENTER_TEXT);
for(i=0;i<=yn;i++)  /* по оси Y */
{
temp = yscreen(yo[i]);  /* положение линии сетки */
if(i>0 && i<yn)  /* если не первая и не последняя */
{
setlinestyle(DOTTED_LINE, 0, 1);
/* точечная тонкая линия */
line(Xe0, temp, Xe1, temp);
/* вывести линию сетки */
}
setlinestyle(SOLID_LINE, 0, 1);
/* сплошная тонкая линия 
sprintf(s,"%6.2f",yo[i]);        /* сформировать из числа строку */
outtextxy(Xe0 - 3, temp, s);        /* вывести на экран */
}
setlinestyle(SOLID_LINE, 0, 1);
/* сплошная тонкая линия –
для вывода текста */
/* устанавливаем выравнивание текста вправо по горизонтали и по верхней линии по вертикали */
settextjustify(RIGHT_TEXT,TOP_TEXT);
/* выводим подпись оси Х */
outtextxy(Xe1,Ye1+6+textheight(xwrite),xwrite);
/* устанавливаем выравнивание текста влево по горизонтали и
по нижней линии по вертикали */
settextjustify(LEFT_TEXT,BOTTOM_TEXT);
/* выводим подпись оси Y */
outtextxy(Xe0, Ye0, ywrite);
/*    устанавливаем    выравнивание    текста    по    центру    по
горизонтали и по нижней линии по вертикали */
settextjustify(CENTER_TEXT,BOTTOM_TEXT);
/* выводим подпись графика */
outtextxy(getmaxx()/2,getmaxy()-3,gwrite);
}
/*   Процедура рисования графика    */
void drawgraph(void)
{
int xs1, ys1, xs2, ys2, i;
setcolor(15);    /* установить белый цвет */
#ifdef LINEGRAPH    /* если кусочно-линейный график */
setlinestyle(SOLID_LINE, 0, 3);   /* толстая сплошная линия */
xs1 = xscreen(x[0]);     /* запомнить координаты первой */
ys1 = yscreen(y[0]);     /* точки графика */
for(i=1;i<n;i++)    /* ко всем остальным точкам */
{   /* последовательно провести */
xs2 = xscreen(x[i]);     /* кусочки прямых линии */
 
ys2 = yscreen(y[i]);
line(xs1,ys1,xs2,ys2);
xs1 = xs2;  /* запоминая их координаты */
ys1 = ys2;
}
#else
for(i=0;i<n;i++)    * все точки графика */
{   /* вывести на экран */
putpixel(xscreen(x[i]), yscreen(y[i]), 15);
}
#endif
}
/*   Примеры пользовательских процедур    */
void do_F1_proc(void)
/* эта процедура для примера только подает специфический
звуковой    сигнал, но в реальной программе может выполнять
действительно       необходимые   операции,   например,   выдачу
подсказки */
{
sound(220); delay(300); 
sound(440) delay(300); 
sound(660); delay(300); 
sound(888); delay(300); 
nosound(); 
}
void do_else_proc(void)
/* эта процедура для примера только подает звуковой сигнал, но в реальной программе может подсказать, что нажата клавиша, обработка которой не предусмотрена */
{
sound(350); delay(500);
nosound();
/*============= Основная программа ================*/
}
void main() 
{
char gwrite[40], xwrite[40], ywrite[40]; 
int key, lMore; 
clrscr();
puts (“Пример программы построения графика”);
/* пробуем инифиализировать графический режим */
grinit();
/* если не произошло аварийного останова в функции grinit(), то режим инициализирован и можно установить границы экранного окна в зависимости от   установленного разрешения и размера экрана */
setlimits();
/* выбираем количество точек в зависимости от типа графика */
#ifdef LINEGRAPH    /* если кусочно-линейный */
n=(Xe1 - Xe0)/8;            /* точек требуется меньше */
#else   /* иначе */
n=(Xe1 - Xe0)/2;     /* значительно больше */
#endif
if(!allocatememory())   /* распределяем память */
{   /* если не вышло */
puts("Недостаточно памяти");
exit(-2);   /* завершаем программу */
} 
/* устанавливаем пределы построения графика */
 a = -3;
 b = 2;
/*  вычисляем  значения  графика  во  всех  точках  и  заполняем
массивы x и y*/
fillarray();
/* вычисляем масштабные коэффициенты */
ax = (Xe1 - Xe0) / (MaxX - MinX);
ay = (Ye1 - Ye0) / (MaxY - MinY);
/* назначаем подписи для осей и графика */
strcpy(xwrite,"Ось X");
strcpy(ywrite,"Ось Y");
strcpy(gwrite,"Пример вывода графика");
/* создаем поле вывода графиков */
drawbg(xwrite, ywrite, gwrite);
/* выводим график */
drawgraph();
/* основной цикл обработки команд с клавиатуры */
lMore = 1; /* признак продолжения цикла */
do 
{
while(kbhit())      /* очистить буфер клавиатуры */
            
getch();
key=getch();    /* получить нажатую клавишу */
if(key==0)      /* если расширенный код */
key=getch();    /* считать его */
switch(key)         /* в зависимости от нажатой */
{           /* клавиши */
case 27 :       /*клавиша Esc*/
 
lMore = 0; 
break; /* прекратить цикл */
case 59 :   /*клавиша F1*/
do_F1_proc(); 
break;
deafult:     /* все остальные клавиши */
 
do_else_proc();
break; 
}
}
while(lMore);
/* освободить память */
freememory();
/* восстановить текстовый экран */
closegraph();
puts("Программа окончила работу");
}

// Unit1.cpp
//---------------------------------------------------------------------------
 
#include <vcl.h>
#include "math.h" // для доступа к sin и ехр
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
 
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
    Edit1->Text = 0;
    Edit2->Text = 0;
    Edit3->Text = 3.14;
    Edit4->Text = -3.14;
    Edit5->Text = 0.314;
    Label1->Caption = "Начало промежутка";
    Label2->Caption = "Конец промежутка";
    Label3->Caption = "Шаг";
    Label4->Caption = "min y";
    Label5->Caption = "max y";
    Form1->Color = clInfoBk;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender)
{
//  Grafik();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormResize(TObject *Sender)
{
    TRect ret = Rect(0,0, ClientWidth, ClientHeight) ;
    Canvas ->FillRect(ret); // стереть
    Grafik();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
    Grafik() ;
}
//---------------------------------------------------------------------------
// функция, график которой надо построить
float f(float x)
{
    return sin(x)+x*x;
}
//---------------------------------------------------------------------------
void TForm1::Grafik()
{
    int x0, y0; // начало координат
    int l,b,h,w;
    float xmin,xmax,ymin,ymax;// преременные для рассчета мин и макс на заданном
    //с клавиатуры промежутке
    float t,z,k,a,j;//координаты вывода таблицы
    float x1, x2; // границы изменения аргумента функции
    float y1, y2; // границы изменения значения функции
    float x; // аргумент функции
    float y; // значение функции в точке х
    float dx; // приращение аргумента
    float mx, my; // масштаб по осям X и Y
    l, b; // левый нижний угол области вывода графика
    w, h; // ширина и высота области вывода графика
    // область вывода графика
    l = 10; // X — координата левого верхнего угла
    b = Form1->ClientHeight-20; // Y — координата левого нижнего угла
    h = Form1->ClientHeight-100; // высота
    w = Form1->Width -400; // ширина
 
    xmin=StrToFloat(Edit3->Text);// запоминаем начало промежутка
    xmax=StrToFloat(Edit4->Text);// запоминаем конец промежутка
    dx=StrToFloat(Edit5->Text);// запоминаем шаг
 
    //найдем мин макс значения функции на данном промежутке
    x=xmin;
    ymax=f(x);
    ymin=f(x);
 
    h=700;
    k=75;
    a=850;
    j=75;
 
 
    do
    {
    y=f(x);
    if (y<ymin) ymin=y;
    if (y>ymax) ymax=y;
    Canvas->TextOut(z-7,t, (x));
    Canvas->TextOut(a-50,j, (y));
    Canvas->MoveTo(z-10,t-5);
 
 
    x+=dx;
 
    k+=20;
    h+=20;
 
    Canvas->LineTo(h-10,k-2) ;
    Canvas->LineTo(a+50,j-2);
 
    }
    while (x<=xmax);
    h=700;
    k=75;
 
    Canvas->MoveTo(900,j-2);
    Canvas->LineTo(900,70);
    Canvas->LineTo(900,70);
    Canvas->LineTo(z-10,t-5);
    Canvas->MoveTo(z+90,70);
    Canvas->LineTo(z+90,j);
 
    Edit1->Text=ymin;//выводим полученное мин значение
    Edit2->Text=ymax;//выводим полученное макс значение
 
    x1 = -5; // нижняя граница диапазона аргумента
    x2 = 5; // верхняя граница диапазона аргумента
    dx = 0.628; // шаг аргумента
    // найдем максимальное и минимальное значение
    // функции на отрезке [xl,x2]
    x = x1;
    y1 = f(x); // минимум
    y2 = f (x); // максимум
 
    do
    {
        y = f (x);
        if ( y < y1) y1 = y;
        if ( y > y2) y2 = y;
        x+= dx;
    }
    while (x <= x2);
    // вычислим масштаб
    my = (float)h/abs(y2-y1); // масштаб по оси Y
    mx = w/abs(x2-x1); // масштаб по оси X
    // оси
    x0 = 1+abs (x1*mx) ;
    y0 = b-abs (y1*my) ;
    Canvas->MoveTo (x0+5,b) ; Canvas ->LineTo (x0+5,b-h) ;
    Canvas ->MoveTo (l-2,y0) ;Canvas->LineTo (l+w,y0) ;
    Canvas->TextOut(x0+5,b-h, FloatToStrF(y2, ffGeneral, 6,3));
    Canvas->TextOut(x0+5,b, FloatToStrF(y1, ffGeneral, 6, 3)) ;
    // построение графика
    x = x1;
    Canvas->Pixels [x0+x*mx] [y0-y*my] = clRed;
    Canvas->MoveTo ((x0+x*mx),(y0-y*my));
 
    do
    {
        y = f (x);
        Canvas ->LineTo ((x0+x*mx),(y0-y*my)) ;
        x+= dx;
    }
    while (x <= x2) ;
    Edit1->Text=ymin;
    Edit2->Text=ymax;
 
}
//---------------------------------------------------------------------------

// Unit1.h
//---------------------------------------------------------------------------
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:    // IDE-managed Components
    TEdit *Edit1;
    TEdit *Edit2;
    TButton *Button1;
    TEdit *Edit3;
    TEdit *Edit4;
    TEdit *Edit5;
    TLabel *Label1;
    TLabel *Label2;
    TLabel *Label3;
    TLabel *Label4;
    TLabel *Label5;
    void __fastcall FormPaint(TObject *Sender);
    void __fastcall FormResize(TObject *Sender);
    void __fastcall Button1Click(TObject *Sender);
    void __fastcall FormCreate(TObject *Sender);
private:    // User declarations
    void Grafik();
public:     // User declarations
    __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif