Microsoft Word - PASCAL_gramata_3.doc

Transkripts

1

2 RĪGAS TEHNISKĀ UNIVERSITĀTE Būvm ehānikas katedra F. Bulavs, I. Kiščenko, I. Radiņš SKAITLISKO APRĒĶINU REALIZĀCIJAS METODES būvniecības specialitātes studentiem Rīga, 2008

3 Izdevumā apkopotais materiāls ir palīglīdzeklis Būvniecības fakultātes studentiem apgūstot datormācības kursu pirmajā un otrajā semestros. Materiāls satur programmēšanas valodas PASCAL pamatelementus, MATHCAD pielietojuma un izmantošanas principus un būvelementu piepūļu aprēķinu piemērus. Ir izklāstīti stieņu sistēmu piepūļu, spriegumu un pārvietojumu aprēķinu realizācijas programmas ANALYSIS for WINDOVS 1.9 pielietojuma metodika un piemēri. Izklāstītais materiāls ilustrēts ar programmu piemēriem un to komentāriem, kā arī ar konkrētu darinājumu piepūļu aprēķinu piemēriem. Veiksmīgas vielas apgūšanas kontrolei studentam tiek piedāvāta virkne paškontroles uzdevumu ar atbildēm. Iespiests saskaņa ar Būvmehanikas katedras gada 17. maija sedes lēmumu Nr. 05/07. 2

4 SATURS 1. PROGRAMMĒŠANAS PAMATI PASCAL VIDĒ Ievads Algoritmizācija Pascal valodas pamatelementi Datu tip i Standartfunkcijas Programmas struktūra Apraksta d a ļa Operatoru daļa Operatori Procedūru operatori Vienkāršāko programmu piemēri...17 Paškontroles uzdevumi Sazarojumu operatori Izvēles operators CASE... OF... EN D Paškontroles uzdevumi Cikla operatori Operators FOR... TO... DO Operators WHILE... D O Operators REPEAT... UNTIL...29 Paškontroles uzdevumi M asīvi Darbības ar masīviem Masīvu aizpildīšana Masīvu aizpildīšanas piemēri Masīvu apstrāde Masīvu sakārtošana Elementu izslēgšana un ievietošana masīvā...43 Paškontroles uzdevumi Funkcijas un procedūras Paškontroles uzdevumi Pielikumi...53 Paškontroles uzdevumu atbildes Darbs ar programmu...57 Paziņojumu kodi par kļūdām Turbo Pascal valodas programmās Literatūra UNIVERSĀLĀ MATEMĀTISKO APRĒĶINU SISTĒMA M ATHCAD Ievads Mathcad galvenais izvēles logs Instrumentu panelis Mathcada iespējas Darbs ar Mathcad apgabaliem Matemātisko un teksta apgabalu veidošana Mainīgo definēšana

5 Funkciju definēšana Matemātisko izteiksmju veidošana Izteiksmju rediģēšana Skaitlisku un simbolisku izteiksmju ievadīšanas piem ēri Funkcijas vērtību noteikšana un vērtību tabulas izveidošanas piem ēri Mainīgo un funkciju definēšanas piem ēri Funkciju grafiku konstruēšana Funkciju grafiku konstruēšana lietojot mainīgo diapazonus Vairāku funkciju grafiku vienlaicīga veidošana Grafiku konstruēšanas piemēri Grafiki polārajās koordinātēs Apvienoti grafiki Virsmu grafiki Vienādojumu sakņu noteikšana skaitliskā veidā Nelineāra vienādojuma un vienādojumu sistēmu sakņu noteikšana Vienādojumu sakņu aprēķins dotajā intervālā ar funkciju (vai operatoru) root (root(f(x),x)) Vienādojuma sakņu noteikšana, izmantojot komandu Given... F ind Darbs ar vektoriem un matricām Vektoru un matricu definēšana Darbs ar matricām Darbības ar matricām Vienādojumu sistēmas atrisināšana izmantojot matricu algebru Matemātiskās analīzes uzdevumi Funkciju atvasināšana (diferencēšana) Summu un integrāļu aprēķins Funkcijas robežu noteikšana Mērvienību lietošana...90 Literatūra STIEŅU SISTĒMU SKAITLISKO APRĒĶINU METODIKA IMANTOJOT GALĪGO ELEMENTU PROGRAMMU ANALYSIS FOR W INDOW S Programmas īss raksturojums Komandu grupa F ile Komandu grupa Structure Darbs dialoga režīmā Komandu grupa D raw ing Komandu grupa Calculate Komandu grupa Results Komandu grupa P rin t Stieņu sistēmu piepūļu aprēķina piemērs

6 1. PRO G RAM M ĒŠANAS PAM ATI PASCAL VIDĒ 1.1. Ievads XX g.s. 40-tajos gados notika principiāls pavērsiens skaitļošanas tehnikas attīstībā. Radās pirmās elektroniskās skaitļojamās mašīnas. Pirmā ESM tika radīta gada beigās ASV un tātad jau 60 gadus ilgst ESM tehnisko iespēju pilnveidošanas un attīstības periods. Straujā datoru attīstība un to plaša ieviešana dažādās saimniecības nozarēs radīja priekšnosacījumus jaunas zinātnes nozares - informātikas izveidei un attīstībai. Datori faktiski ir informācijas apstrādes darbarīki un to veiksmīga izmantošana lielā mērā saistīta ar datoru matemātiskā aprīkojuma kvalitāti. Tas aktualizē problēmas par informācijas apstrādes algoritmizāciju un skaitļojamo programmu izstrādi un pilnveidošanu. Risinot konkrētus uzdevumus ar datoru palīdzību vispirms jāsastāda šī uzdevuma atrisināšanas algoritms, t.i. precīzs un nepārprotams priekšraksts jeb norādījums izpildītājam veikt kādu darbību virkni, lai sasniegtu nepieciešamo rezultātu. Dators nevar atrisināt uzdevumu, kuru tā risinātājs pats neizprot un nevar noformulēt tā atrisināšanas algoritmu. Bet arī tad, ja šāds algoritms ir noformulēts, tas jāievada datorā tam saprotamā formā. Šāda forma ir programma, kas kopā ar izejas datiem tiek ierakstīta datora atmiņā. Diemžēl, datori, pat paši gudrākie, nesaprot nevienu no cilvēku sazināšanās valodām. Līdz ar to rodas nepieciešamība izveidot mākslīgu valodu, ko sauc par algoritmisko jeb programmēšanas valodu. Kā viena no pirmajām jāmin Basic valoda, kuras pirmais variants tika radīts gadā iesācējiem, vienkāršu programmu sastādīšanai. Eksistē simtiem šīs valodas versiju, kuras bieži vien maz savietojamas savā starpā. Basic guvis plašu pielietojumu mikrokalkulatoros. Šī valoda nav domāta lielu, sarežģītu programmu sastādīšanai. Plaši tiek lietotas Quick Basic (firma Microsoft), Turbo Basic (firma Borland) un Visual Basic valodas gadā Cīrihes Federālā Tehnoloģiskā institūta profesors Niklavs Virts studentu apmācīšanai programmēšanā izstrādāja valodu Pascal. Valodas nosaukums tika izvēlēts par godu franču matemātiķim un filozofam Blēzam Paskālam ( ), kurš jau 17. gs. izvirzīja ideju par informācijas datu mehānisku apstrādi un ņēma dalību aritmometra izveidošanā un pilnveidošanā. Šai valodā programmas viegli lasāmas un tās satur visus stingra programmēšanas stila ievērošanai nepieciešamos elementus. Sākotnēji šī valoda bija ar visai ierobežotām iespējām, bet laika gaitā tā tika papildināta un uzlabota, radās tās versijas. Firma Borland radīja versiju Turbo Pascal ar visai plašām iespējām. Šī versija ir augsta līmeņa strukturēta valoda, kas ļauj uzrakstīt jebkura garuma un grūtuma programmas. Programmēšanas valodu Pascal var uzskatīt par universālu. Tai ir vienkārša konstrukcija, plašas iespējas izveidoto programmu pareizības kontrolei kā to kompilācijas (programmas translācijas mašīnas kodu valodā), tā arī izpildes laikā. Valoda ietver sevī galvenos programmēšanas jēdzienus un konstrukcijas, taj ā izmantoti strukturālās programmēšanas principi un tā pielietojama dažāda profila uzdevumu risināšanai, pie kam nezaudējot vienu no savām galvenajām īpašībām - relatīvu vienkāršību. 5

7 1.2. Algoritmizācija Cilvēku rīcību ikdienas dzīvē lielā mērā regulē instrukcijas, t.i., iepriekš izstrādātas operācijas un to izpildes kārtība, kas ļauj sasniegt vēlamo rezultātu. Kā piemēru var minēt mobilā telefona ekspluatāciju. Tikai precīzi izpildot atbilstošas instrukcijas var sasniegt vēlamo rezultātu. Lai iegūtu matemātiska rakstura uzdevuma atrisinājumu, ir jāzina šī uzdevuma atrisināšanas algoritms. Par algoritm u var uzskatīt konkrētas secības d arb īb u kopum u, k u ra pielietojum s dotiem objektiem, nodrošina m eklējam a rezultāta iegūšanu. Algoritma pierakstam jābūt sadalītam precīzos nošķirtos soļos, kur katrā solī ir paredzēts izpildīt vienu vienkāršu norādījumu. K a tru šādu norādījum u sauc p ar kom andu. Sastādot, labojot un uzlabojot sarežģītākus algoritmus, to pieraksts teksta formā nav pietiekami uzskatāms un viegli lasāms. Tāpēc nereti programmēšanai paredzētos algoritmus veido ar grafisku elementu palīdzību. Algoritma pierak sta grafiska form a ir blokshēm a, kura veidota no atsevišķiem tipizētiem elementiem. Attēlā redzami blokshēmās izmantojamie grafiskie elementi. Strukturētā teksta pierakstā tiek pieņemts, ka pēc katras komandas izpildes algoritma izpildītājam jāpāriet pie komandas, kas atrodas nākamajā rindā, ja vien nav bijis norādījums izpildīt kādu citu komandu. Tāds pats pieņēmums ir spēkā arī Pascal programmās. Vispārīgā gadījumā katra algoritma komanda sastāv no divām daļām: izpildam as darbības un norades uz vietu algoritma pierakstā, kur atrodas nākamā izpildāmā komanda. Blokshēmās uz katru nākamo izpildāmo komandu norāda bultiņa, kura "iziet" no izpildītās komandas. Katram blokshēm as elementam var pienākt viena bultiņa (izņēmums ir sākuma elements, kuram nepienāk neviena bultiņa). No k atra blokshēmas elementa iziet tikai viena bultiņa (izņēmums ir beigu elements, no kura neiziet neviena bulti ņa un sazarošanās elements, no kura iziet divas bultiņas). Algoritmus, kuru komandas tiek izpildītas tādā secībā, kādā tās pierakstītas, sauc par lineāriem algoritmiem. Blokshēmās lineāro algoritmu pierakstā nelieto sazarošanās elementus. Parasti algoritmi netiek rakstīti vienam konkrētam gadījumam vai uzdevumam, bet gan veselai līdzīgu uzdevumu grupai. Algoritma blokshēmas piemērs, atbilstoši kurai nosaka funkcijas t=2ab+5c vērtību, redzams attēlā. Bieži vien vienu un to pašu rezultātu var sasniegt pēc formas dažādos veidos. Formas izmaiņa dod iespēju meklēt racionālāko risinājuma variantu konkrētā uzdevuma atrisināšanai ar mērķi taupīt datora resursus un radīt ērtas programmas. Tā, piemēram, vidējo vērtību var noteikt kā vi 6

8 su lielumu algebriskās summas dalījumu ar summējamo lielumu skaitu, a v = (S a i ) / n, vai arī summējot katra lieluma n-tās daļas a v = S a jn. Otrajā gadījumā tiek veikta (n- 1) papildus aritmētiska darbība. No algebras zinām, ka lielums c = a 2 - b 2 iegūstams gan kā c = a a - b b, gan kā c = (a - b \ a + b ). Šai piemērā darbību skaits abos gadījumos ir vienāds, atšķirīga ir izpildes secība Pascal valodas pamatelementi Programmēšanas valodas pieraksta, līdzīgi kā sarunu valodas pieraksta, pamatelementi ir burti, no kuriem tiek veidoti vārdi. Vārdi veido teikumus, bet no teikumiem sastāv jebkurš teksts. Pascal valodas alfabētu veido sekojoši simboli: - 26 latīņu alfabēta burti ( a,... z); - 10 a rā b u cipari (0,1,2,3,4,5,6,7,8,9); - pasvītrojum a zīme ( _ ); - speciālie simboli. Speciālie simboli Attēls Nosaukums Attēls Nosaukums Attēls Nosaukums + pluss # numura zīme [ ] kvadrātiekavas - mīnuss $ dolāra zīme { } figūriekavas * zvaigznīte = vienāds := piešķiršana / slīpa svītra > lielāks.. divi punkti. punkts < mazāks (**) Iekava - zvaigznīte, komats >= lielāks vai vienāds (..) Iekava - punkts : kols <= mazāks vai adreses zīme ; semikols <> nevienāds apostrofs ( ) apaļās iekavas Tikai no šiem simboliem tiek veidoti programmās izmantojamo objektu vārdi (identifikatori). Identifikatori tiek veidoti no burtiem, cipariem un pasvītrojuma zīmes (bet ne speciāliem simboliem). Identifikatora garums nav ierobežots, bet to salīdzināšanai tiek ņemti vērā tikai pirmie 63 simboli. Identifikatora pirmajam simbolam j ābūt burtam vai pasvītrojuma zīmei (bet ne ciparam). Mazie un lielie burti ir līdzvērtīgi. Turbo Pascal valodā ir vairāk kā 60 rezervētu vārdu, tādu kā and,, case, const, div, do, else, end, for, goto, if, label, mod, not, of, or, repeat, then, var, write, until, u.c., kuri lietojami tikai tiem paredzētā nolūkā. 7

9 1.4. Datu tipi Pascal valodā izmantojamie dati iedalāmi trīs grupās: skalārie, strukturētie un pārsūtām ie. Skalārie dati ir: veselo skaitļu tips - tā atslēgas vārds ir integer; reālo skaitļu tips - tā atslēgas vārds ir real; loģiskais tips - tā atslēgas vārds ir boolean; simbolu tips - tā atslēgas vārds ir char. Veselo skaitļu tips. Turbo Pascal versijā ir pieci veselo skaitļu tipi. Ši grupa apvieno veselo skaitļu kopumu dažādos diapazonos. Tips D iapazons Aizņemtās atm iņas apjoms shortint baits integer baiti longint baiti byte baits w ord baiti Ar šiem veselo skaitļu tipa mainīgajiem var veikt aritmētiskas operācijas +, -, *, /, div, mod. Šo operāciju rezultātā iegūstam arī veselus skaitļus, izņemot dalīšanu ( / ), kuras rezultātā iegūstam racionālu skaitli. Operācija div (no vārda division - dalīšana) ir dalīšana bez atlikuma (atlikums tiek atmests), bet operācija m od (modulus - mērs) saglabā tikai divu veselus skaitļu dalījuma atlikumu. Operācija a mod b izpildīsies tikai tai gadījumā, ja b>0. Piemēri: ja 7/3=2,3(3), tad 7 div 3=2, bet 7 mod 3=1; 2 div 7=0; (-7) div 2=-3; 7 div (-2) = -3; (-7) div (-2)=3; 23 m od 12=11. Veselā skaitļa tipam izmantojamas divas iebūvētās procedūras: dec(x,n) - samazina x vērtību par n, ja n nav noteikts, tad par 1. inc(x,n) - palielina x vērtību par n, ja n nav noteikts, tad par 1. Izmantojot m od dalīšanu, varam spriest par dota skaitļa dalāmību. Tā kā 9 mod 3 rezultāts ir nulle, tad dotais skaitlis dalās ar skaitli 3 bez atlikuma. Dalot (mod) jebkuru skaitli ar 2, nosakām, vai šis skaitlis ir pāra, vai nepāra skaitlis. Šāds paņēmiens plaši tiek lietots programmu izveidē. Jāņem vērā, ka gadījumos kad veicamo darbību rezultātā iegūstam skaitli, kurš neatbilst norādītajam diapazonam, kļūda netiek uzrādīta un šī skaitļa vietā tiek izvadīts kāds cits (kļūdains) skaitlis. Reālo skaitļu tipi. Turbo Pascal-ā ir pieci reālo skaitļu tipi. Šo tipu skaitļiem atbilst reālā skaitļa jēdziens matemātikā. 8

10 Reālā tipa skaitļu pierakstam iespējamas divas pieraksta formas: a r fiksētu kom atu (punktu), piem., , , ; a r peldošu kom atu (eksponentforma), piem., 3.5E-11, -1E+3 (šo skaitļu vērtības attiecīgi ir "12 un -1000). Ar reāliem skaitļiem var izpildīt visas tās pašas aritmētiskās darbības, kā ar veseliem skaitļiem (izņemot darbības m od un div), tikai rezultāts būs reāls skaitlis. Gadījumos, ja izpildot darbības rezultāts pārsniedz pieļaujamo augšējo robežu, tad tiek uzrādīta kļūda, bet, ja rezultāts ir mazāks par diapazona apakšējo robežu, attiecīgajam identifikatoram tiek piešķirta nulles vērtība. Tips real single double extended D iapazons ± (2.9 E E38 ) (jeb 2,9T0"39...1,7T038) ± (1.5 E E38) (jeb 1,5T0"45...1,7-1038) ± (5.0 E E308) (jeb 5,0-10" , ) ± (3.4 E E4932) (jeb 3,4 10" , ) C iparu skaits m antisā Aizņemtās atm iņas apjoms baiti baiti baiti baiti comp ± 9.2 E+18 ( jeb ) baiti Com p faktiski ir veselo skaitļu tips ar palielinātu diapazonu. Simbolu virkne. To pārstāv datu tips string, kas paredzēts simbolu tabulas elementu virknes uzglabāšanai un apstrādei. Maksimālais simbolu virknes elementu skaits ir 255. Simbolu virkne jāiekļauj apostrofos: 'Anna', 'X1', Y=7'. Simbolu tips. Šī tipa vērtības ir galīga skaita sakārtotas simbolu tabulas elementi. Simbolu tipa (char) lielumi var būt jebkurš simbols, kurš atrodas datora simbolu kodu tabulā. Visi simboli sakārtoti augošā secībā pēc to kodiem, kas mainās no 0 līdz 255. Piem., chr(65) ir burts A, bet chr( 6 6 ) - burts B. Simboli, kas ieslēgti apostrofos ir simboliskā tipa konstantes, piem., x, 6, darbs. Simbolu tipam eksistē divas savstarpēji apgrieztas standartfunkcijas: ord(c) - piešķir simbola c kārtas numuru simbolu tabulā; chr(i) - piešķir simbolu, kuram atbilst kārtas numurs i. Tā, piemēram., ord(a) = 65, bet chr(65) = A. Loģiskā tipa (boolean) lielumiem ir iespējamas tikai divas vērtības: true (patiess) un false (aplams). Ar tām var izpildīt loģiskās operācijas. Biežāk lietojamās ir: and, or, not. Loģiskā tipa funkcija ir odd(x). Šīs funkcijas vērtība ir true, ja x ir nepāru skaitlis un false - pretējā gadījumā. 9

11 Atvasinātie un uzskaitām ie tipi. Aprakstot uzskaitāmo tipu, programmētājs uzdod (uzskaita) visas tās vērtības, kuras mainīgajam varēs piešķirt, ja tas būs aprakstīts kā šī tipa mainīgais. Uzskaitāmā tipa mainīgie programmā var pieņemt tikai tādas vērtības, kuras uzskaitītas vērtību sarakstā. Piemēram: type Vasara= ('Junijs', 'Julijs', 'Augusts'); Uzskaitāmajam tipam pieļaujamas tikai salīdzināšanas operācijas un tam pielietojamas standartfunkcij as: succ(x) -> uzdod aiz simbola x sekojošu simbolu no vērtību saraksta; pred(x) -> uzdod pirms simbola x iepriekšējo simbolu no vērtību saraksta; ord(x) -> uzdod simbola x kārtas numuru konkrētā simbolu kopā. Intervāla tips. Jebkuram skalāram lielumam, izņemot daļskaitli, var izveidot jaunu skalāru lielumu ar vērtību izmaiņas intervālu. Intervāla noteikšana paaugstina programmas drošību, ekonomē atmiņu, kā arī programmas izpildes laikā kontrolē piešķiršanas operācijas. Intervālu var noteikt: 1) tipu apraksta daļā: type <tipa nosaukums>=<konstante1>.. <konstante2 >; 2 ) mainīgo apraksta daļā: var <mainīgais>:<konstante1>..<konstante2 >; kur <konstante1> - apakšēj ā robeža; <konstante2 > - augšējā robeža. Piemēram: type Burts='A'..'Z'; var Int=1..100; i,j,k: Int; s,m: Burts; Lietojot programmā standarta datu tipus, tie nav speci āli jādefinē, bet programmista izveidotie tipi j āuzrāda pēc vārda type. Piemēram: type Diena =('Sestdiena', 'Svetdiena'); Menesis=('Julijs', 'Augusts'); Tipi Diena un Menesis ir jauni tipi, bet vārdi ('Sestdiena', 'Svetdiena', 'Julijs', 'Augusts') pieder pie standarta tipa string Standartfunkcijas Pascal valodas kompilatorā iebūvēto funkciju skaits nav liels. Biežāk lietojamās sakopotas tabulā. Funkcijas nosaukum s F unkcijas nozīme argumentam Tips funkcijai abs(x) x integer integer sqr(x) 2 x real real 10

12 sin(x) cos(x) arctan(x) exp(x) ln(x) sqrt(x) sinx cosx arctgx ex lnx 4 x integer vai real real trunc(x) [x] -skaitļa veselā daļa real integer round(x) noapaļošana līdz veselam odd(x) nepānbas pārbaude integer boolean Trigonometrisko funkciju arguments jauzdod radianos. Gadījumos, kad arguments dots loka grādos, jāizmanto pārejas sakarība x=(xo)*pi/180. Logaritmu ar patvaļīgu bāzi a (nevis e) noteikšanai var izmantot sakarību loga(x) = ln(x)/ln(a). Jāņem vērā, ka Turbo Pascal-ā kāpināšana tiek realizēta izmantojot logaritmu īpašību: ja c = ab, tad ln(c) = bln(a) un c = exp(bln(a)). Līdz ar to nav iespējams kāpināt negatīvu skaitli. Šim nolūkam lietderīgi izmantot cikla operatorus. G adījum a skaitļu ģenerēšana ar funkciju RANDOM. Daudzām parādībām dabā, tehnikā, ekonomikā un citās jomās ir gadījuma raksturs. Piemēram, metot metamo kauliņu, iepriekš nav iespējams paredzēt kāds skaitlis uzkritīs. Šādu parādību realizēšanai datorā var izmantot gadījuma skaitļu funkciju random, t.i., funkciju, kura izvada programmas "iedomātu" skaitli. Šo funkciju var izmantot arī gadījumos, kad programmas darbības pārbaudei nepieciešamas daudzas gadījuma rakstura skaitliskas vērtības. Pieraksts random (n) ģenerē gadījuma skaitli no intervāla 0 <= random (n) < (n -1 ). Gadījumos, kad n nav norādīts (izmantojam pierakstu random bez argumenta), tiek ģenerēts skaitlis no intervāla (0,1 ), tātad decimāldaļskaitlis. Izpildot gadījuma skaitļu ģenerēšanu vairākkārt, lai nodrošinātu citu gadījuma skaitļu izvēli, tiek lietots operators random ize. Šis operators programmā izpildāms pirms funkcijas random Programmas struktūra Risinot uzdevumus ar datoru palīdzību ir nepieciešams sastādīt programmas, kuras dotu iespēju datoram saprotamā veidā realizēt atbilstošo aprēķinu algoritmu. Jebkura programma satur mērķtiecīgā secībā izvietotu operatoru kopumu. Katrai programmai jāsatur vismaz viens izpildāmais operators, pretējā gadījumā tai nav jēgas. 11

13 Pascal valodas programmas struktūra parasti veidota trīs daļās: p rogram <nosaukums>; <apraksta daļa>; vai datu apraksts <operatoru daļa> vai darbību apraksts end. {Turbo Pascal-ā nosaukums v a r a ri nebūt} {tiek uzskaitītas visas turpmāk izmantojamās konstantes, iezīmes, mainīgie, apakšprogrammas un citi objekti } {darbību operatori tiek izvietoti to izpildīšanas secībā} Programmas nosaukums nav obligāts. Vienkāršāku programmu gadījumos var nebūt arī <apraksta daļa> un tad programma sastāv tikai no <operatoru daļas>. Svarīga programmu noformēšanas sastāvdaļa ir komentārs teksta veidā, kurš ievietojams figūriekavās { } vai iekavās ar zvaigznītēm (* *). Komentārs palīdz izprast programmas tekstu un atvieglo tās lasīšanu citam speciālistam. K om entārs nepiedalās program m as izpildē Apraksta daļa Šai daļā jābūt uzskaitītiem visiem <operatoru daļā> izmantojamajiem identifikatoriem, iezīmēm, funkcijām un procedūrām. Identifikatoriem tiek norādīts to tips. Apraksta daļa sastāv no sešām iespējamām pozīcijām. Tiek uzrādītas tikai tās pozīcijas, kuras ir nepieciešamas konkrētajā programmā. Ne vienmēr visas no sešām iespējamajām pozīcijām tiek izmantotas. Var būt arī gadījumi, kad apraksta daļa ir tukša, t.i. tā nesatur nevienu no pozīcijām. Šīs pozīcijas ir: programmā pielietojamo bibliot ēkas m oduļu saraksts (programmā apzīmē ar atslēgvārdu uses); iezīm ju saraksts (label); konstanšu apraksts (const); no standartmoduļiem atšķirīgu papildtipu definēšana (type); m ainīgo apraksts (var); p ro ced ū ru un funkciju apraksts (procedure, function). A praksta pozīciju secība ir viennozīmīga (tā jāievēro): 1. Gadījumos, kad sastādāmajā programmā tiks izmantots kāds no Pascal valodas bibliotēkas standartmoduļiem, tas apraksta daļā jāuzrāda. Piem.: uses crt, graph, u.c. Var tikt veidoti arī nestandarta moduļi un turpmākaj ā programmēšanas daļā lietoti kā bibliotēkas sastāvdaļas. 2. Gadījumos, kad programmas operatoru daļā tiks veikta operatoru izpildes secības maiņa ar operatora goto palīdzību izmantojot iezīmes, tās jāuzrāda iezīmju daļā pēc atslēgvārda label. Iezīmes parasti ir naturālo skaitļu veidā, bet var būt arī teksta veidā. Piem.: label 1, 5, 172, m1, stop; 12

14 Operatoru izpildes secības maiņas vietā pēc operatora goto tiek norādīta attiecīgā iezīme. Šo pašu iezīmi norāda pirms nākamā izpildāmā operatora to atdalot ar kolu. Piem.: goto 5; 5 : w rite( iezime ir 5 ); 3. Gadījumos, kad programmā ir izmantojami konstanti lielumi, tie tiek uzrādīti pēc atslēgvārda const. Skaitliskās konstantes var būt veseli vai racionāli skaitļi. Racionālus skaitļus var pierakstīt divos veidos - ar fiksētu vai peldošu punktu (komatu). Simbolveida konstante tiek ieslēgta apostrofos. Loģiskām konstantēm iespējamas divas vērtības - true un false. Piem.: const a =12; b=-20; c=5.34; d=false; e=true; f= Latvija ; vidvecums=35; fonds=1.5e+04; max=60; 4. Gadījumos, kad programmā nepieciešams izmantot tipus, kuri nav Pascal valodas standarttipi, tos definē pozīcijā aiz atslēgvārda type. Piem.: type diena=(pirmd, otrd,... svetd); Vards=(aija, maija, gatis, sandris); 5. Aiz atslēgvārda v a r jāuzskaita visi mainīgie, kuri tiks izmantoti konkrētajā programmā un j āuzrāda to tips. Piem.: var x, y, suma: real; i, n: integer; atbilde: boolean; otrd: diena; gatis, maija: vards; 6. Pēc atslēgvārda procedure, function tiek nosauktas un aprakstītas visas procedūras un definētas funkcionālās sakarības, norādot to skaitlisko vērtību noteikšanas algoritmus. Procedūras ir neatkarīgas programmas daļas, kuras veic konkrētas darbības. To struktūra ir analoga programmas struktūrai un tās var uzskatīt par mini programmām, kuras nepieciešamajā vietā tiek izsauktas ar to nosaukumiem (vārdiem). Piemērus skaties turpmāk Operatoru daļa Tā ir programmas pamatdaļa un tajā tiek norādītas izpildāmās darbības to izpildīšanas secībā. O perators ir sintaktiska konstrukcija - pabeigta programmēšanas valodas frāze, kas rak stu ro konkrētu datu apstrādes etapu. Katrai komandai algoritma pierakstā atbilst konkrēts operators programmā. Operatoru skaits programmā nav ierobežots. Operatorus vienu no otra atdala ar semikolu, tātad k atra operatora beigās jāliek semikols (;). Izņēmums ir programmas beigas. Programmai vienmēr jābeidzas ar punktu. Operatoru izpildes secības organizēšanai izmanto operatoru iekavas, t.i., vārdus un end. Tie lietojami tikai pārī. Tas nozīmē, ka pārbaudot programmu, jāseko tam, lai līdzīgi kā algebrisko iekavu gadījumā, atverošo iekavu skaits būtu vienāds ar aizverošo iekavu skaitu. Kā jau tika minēts, programmas lasīšanas atvieglojumam tiek izmantoti komentāri brīva teksta veidā to ieslēdzot figūriekavās { } vai (* *). Iekavās var tikt 13

15 iekļauti ari veseli programmu fragmenti, tā izveidojot pamatprogrammas vienkāršotu variantu. Šādi ieslēgumi neietekmē programmas izpildes gaitu Operatori Programmas operatoru daļa sastāv no operatoriem, kuri var būt tukši, vienkārši un salikti. Operatorus vienu no otra atdala ar semikolu. Gadījumos ja operators atrodas pirms vārda else, tad aiz tā semikolu neliek. Tukšajā operatorā nav neviena simbola un tas nenosaka nevienu darbību. V ienkārši ir operatori, kuru sastāvā nav iekļauti citi operatori. Tādi operatori ir piešķires operators, datu ievades un izvades procedūru operatori un pārejas operatori. Saliktie operatori ir konstrukcijas, kuras sastāv no citiem (vienkāršiem) operatoriem. Šādas konstrukcijas tiek iekļautas operatoru iekavās..end;. Piešķires operators ir fundam entāls un uzskatām s p ar pam atoperatoru. Šī operatora simbolisks apzīmējums ir specifisks simbolu sakopojums := un tiek lietots starp mainīgā identifikatoru un šim mainīgajam piešķiramo vērtību, kura var tikt uzdota skaitliskā vai izteiksmju veidā. Piem.: a1:= 2.5; y:= x/(1-x); f:= 3*c + 2*sin(x+pi/2); k:=n>m; Svarīgi izsekot tam, lai izteiksmes vērtība labajā pusē atbilstu kreisā pusē norādītā mainīgā tipam. Tomēr ir pieļaujams real tipa mainīgajam piešķirt integer tipa izteiksmi. Izteiksmju veids viennozīmīgi nosaka darbību izpildes secību: tās izpildās no kreisās uz labo pusi ņemot vērā to prioritāšu secību ( vispirms izpildās <, >, =, >=, =, tad *, /, div, m od un kā pēdējās +, - ) Procedūru operatori Ievades un izvades operatori. Izejas datu ievadei izmanto ievades operatoru read, aiz kura iekavās tiek uzrādīti ievadāmo lielumu identifikatori. Rezultātu izvadei izmanto izvades operatoru write, aiz kura iekavās tiek uzrādīti izvadāmo lielumu identifikatori vai izteiksmes, kuru vērtības jāizvada. Piem ēram, operators read(x) pieprasa ievadīt parametra x vērtību; operators read(x,y,z) pieprasa ievadīt trīs parametru x,y un z vērtības. Ievadi veic ar tastatūras taustiņu palīdzību, pie kam programmu nevarēs palaist, ja nebūs ievadītas visu uzrādīto identifikatoru vērtības. Izvades operators write(s) izvada (uz ekrāna) lieluma s vērtību. Lai izvadītu arī tekstu, jāizmanto pieraksts w rite( s=,s). Lietojot pierakstu write(s,p,(s+p)/2) tiks izvadītas trīs vērtības, no kurām pirmā būs lieluma s vērtība, otrā būs lieluma p vērtība, bet trešā būs šo lielumu vidējā vērtība. Operatoru read un w rite vietā var lietot operatorus readln un w riteln, bet tādā gadījum ā pēc katra operatora izpildes kursors pārvietojas uz jaunu rindu - rezultāti tiek izvadīti kolonas veidā. Operators readln; bez operanda, t.i. ievadāmā parametra, veido pauzi, kura turpinās tik ilgi, kamēr tiek nospiests taustiņš E nter. Šādu paņēmienu izmanto programmu beigās, lai saglabātu redzamus iegūtos rezultātus (pretējā gadījumā tūlīt pēc programmas beigām ekrānu aizsedz logs ar programmas tekstu). Operators 14

16 writeln; bez izvadāmo parametru saraksta pārceļ kursoru uz nākamās rindas sākumu. Tādā veidā iespējams, piemēram, atdalīt vienu no otra programmas rezultātus ar vienu vai vairākām tukšām rindām. Izvades operatora piem ēri: Gadījumā, ja s=2, bet p=5, operators write(s,p) izvada 25 w rite('s= ',s,'p=',p) izvada s=2p=5 write(s, ' ',p) izvada 2 5 write('s=',s, ' ', 'p=',p) izvada s=2 p=5 Gadījumā, ja izvadāmais rezultāts ir reāls skaitlis, lai ierobežotu ciparu skaitu aiz komata, tiek uzdots skaitļa form āts. To veic sekojošā veidā write(s:m:n), kur m ir izvadāmā skaitļa kopējais ciparu skaits, bet n - ciparu skaits aiz komata. Veselu skaitļu gadījumā norādāms tikai ciparu skaits (m). Jāņem vērā, ka tajos gadījumos, kad programmas lietotājs ir izvēlējies pārāk mazu m vērtību, izvadāmā parametra formāts automātiski tiek palielināts. Gadījumos, kad n ir par mazu, notiek noapaļošana. Izvadāmais teksts tiek piespiests labajai izvades lauka malai. Tā, piemēram, a:=4.321; write( a= :10, a:7:3); izvadīs uz ekrāna: xxxxxxxxa=xx4.321 ( x - tukša pozīcija). Beznosacījuma pārejas operators GOTO. Operatoru izpildes secību programmā var mainīt, lietojot beznosacījuma pārejas operatoru goto, aiz kura jāraksta iezīme. Jāatceras, ka iezīme jādefinē programmas apraksta daļā label. Gadījumā, ja programmā, kura aprēķina dota skaitļa x kvadrātu, nepieciešams lietotājam dot iespēju izvēlēties, darbu beigt vai turpināt, lietderīgi izmantot operatoru goto. Šādu iespēju realizē programma: Program kvadrats; label 1 ; var x, y: real; a: char; 1: write('ievadi x vertibu: '); readln(x); y:=sqr(x); writeln(' x kvadrātā ir', y); writeln('d arbu turpināsim? (J/N) '); readln(a); if a='j' then goto 1; end. {tiek definēta iezīme ar nosaukumu 1 } {tiek definēti mainīgie} {izvada paziņojumu monitorā} {tiek ievadīts mainīgais x} {mainīgais y iegūst vērtību x2} {izvada paziņojumu un y vērtību } {izvada paziņojumu monitorā} {mainīgā a ievadīšana no klaviatūras} {pāreja uz iezīmi 1, ja lietotājs ir piespiedis j } Piezīme: Nav ieteicams lietot daudzus goto operatorus vienā programmā. Tas apgrūtina programmas lasīšanu. Operatora goto pielietojums neatbilst labam programmēšanas stilam. Procedūra gotoxy. Operatori read un write izvada informāciju displeja ekrāna vietā, uz kuru norāda kursors. Programmas izpildei sākoties, kursors vienmēr atrodas displeja ekrāna kreisajā augšējā stūrī. Pēc operatora w rite izpildes kursors paliek nākamajā po- 15

17 zīcijā aiz tikko izvadītā simbola, bet pēc operatora w riteln izpildes kursors tiek pārnests uz nākamās rindas sākumu. Tātad, izvadot informāciju displeja ekrānā, kursors pakāpeniski pārvietojas pa kreisi un uz leju. Gadījumos, kad nepieciešams novietot kursoru brīvi izvēlētā ekrāna punktā, jālieto procedūra gotoxy. Procedūra gotoxy novieto kursoru punktā (x,y). Vispārēj ā pieraksta forma ir: gotoxy (<mainīgais_x>,<mainīgais_y>), kur: <mainīgais_x> - kursora koordināte pa horizontāli (kolonnas numurs); <mainīgais_y> - kursora koordināte pa vertikāli (rindas numurs). Var uzskatīt, ka ekrāns sadalīts neredzamās rūtiņās, kur katrā rūtiņā vienlaikus var ierakstīt vienu simbolu. Rūtiņas ekrānā izvietotas 24 rindās, pie kam katrā rindā ir pa 80 rūtiņām. Rūtiņu numerācija tiek veikta no kreisās uz labo pusi un no augšas uz leju. Tādējādi, ekrāna augšējās kreisās rūtiņas koordināte ir (1,1), bet labās apakšējās rūtiņas koordināte ir (80,24). Ekrāna kreisā stūra palielinājums ir: p rogram students; uses crt; ClrScr; GotoXY (20,10); writeln ('Es esmu RTU students!'); end. Izmantojot šo programmu uz displeja ekrāna tiek izvadīts teksts Es esmu RTU students! sākot ar displeja ekrānā 1 0. rindas 2 0. pozīciju. Procedūra ClrScr. Procedūra ClrScr attīra monitora ekrānu un novieto kursoru ekrāna kreisajā augšējā stūrī. To parasti lieto programmas operatoru daļā, tūlīt aiz sākuma iekavas. Tā rezultātā pēc atkārtotas programmas aktivizēšanas nav redzami iepriekšējā aktivizācijas reizē ievadītie un izvadītie dati. C lrscr izmantošana iespējama tikai gadījumos, kad programmas apraksta daļā uses ir uzrādīts Pascal bibliotēkas m o dulis crt. Tukšais operators. Šādi operatori nesatur simbolus un neizpilda darbības. Tie nereti tiek veidoti ar iezīmi, lai izietu no salikta operatora vai programmas. Piemēram: goto <iezime>; {pāreja uz programmas beigām} <iezīme>: ; {tukšais operators} end. Programmas operatoru daļā lieks semikols nerada kļūdu. Tā, piemēram, x:=1;; y:=2; 16

18 interpretējams sekojošā veidā: tiek izpildīts piešķires operators x:= 1 ; pēc tam seko tukšais operators un piešķires operators y:=2 ; Apraksta daļā dubults semikols nav pieļaujams, tas izraisa kompilācijas kļūdu. Vienkāršāko programmu piemēri 1. Aprēķināt divu brīvi izvēlētu skaitļu a un b summu un noteikt to vidējo vērtību! Šādas operācijas veikšanai sastādīsim programmu vairākos variantos: Gadījumā, ja a un b ir veseli skaitļi, piem., a=271 un b=329, iespējami šādi gadījumi: Program m as program summa1 ; write( ,' ',( )/2) end. program summa2 ; const a=271; b=329; write(a+b,' vid.vert=', a/2 +b/2 ) end. P rogram summa3; var a,b,c:integer; read(a); read(b); c:=a+b; write(c,' v.v=',c/2 ) end. Kom entāri {tiek izvadīta doto skaitļu summa un aiz atstarpes to vidēj ā vērtība} {cits pieraksta veids} {tiek izvadīta doto skaitļu summa, teksts un vidēj ā vērtība} {programmas vispārinātāks variants} {skaitļi var tikt definēt arī kā real} {no tastatūras ievada divus patvaļīgus skaitļus a un b} {mainīgajam c tiek piešķirta vērtība} {izvada prasītos rezultātus} 2. Ievadīt divus gadījuma skaitļus a un b. Noskaidrot, vai skaitlis a ir mazāks par skaitli b. Izvadīt iegūtos skaitļus. p rogram gadijumskaitli; v a r a,b:integer; {gadījuma skaitļus iespējams definēt tikai kā veselus} random ize; a:= random ( ); {operators random izvēlās divus gadījuma b:= random ( ); skaitļus no intervāla [0, ) write(a<b); {tiek veikta skaitļu salīdzināšana un izvadīts attiecīgs rezultāts} w rite(a,' ',b) {tiek izvadītas skaitļu a un b vērtības} end. 17

19 3. Atbilstoši simbolu kodiem izvadīt uz ekrana pašus simbolus. program charmak1 ; var x:byte; y:char; readln(x); y:= chr(x); write('atbilst '); writeln(y) end. program charmak2 ; label 1 ; var x:byte; y:char; 1 : readln(x); y:= chr(x); writeln('skaitlim ',x, ' atbilst simbols ',y); goto 1 end. {define x no intervala (0,255) un simbolus no simbolu tabulas)} {ievada skaitli x} {operators chr piekārto mainīgajam y skaitlim x atbilstošo simbolu } {tiek izvadīts teksts un iegūtais simbols} {tiek definēta iezīme 1 } 4. Izveidot taisnstūra figuru, izmantojot kadu no simboliem. p rogram taisnsturis; {ievada skaitli x un tam atbilstošais simbols tiek piešķirts parametram y} {izvada skaitlim x atbilstošo simbolu} {programmas izpilde tiek pārnesta uz iezīmi 1 jauna skaitļa ievadīšanai, šo procesu var pārtraukt ar C trl+b reak un Enter} r a > -Q <u y:char; read(x); y:= chr(x); writeln(y,y,y,y,y,y,y,y); {astoņas reizes tiek izvadīts simbols y} writeln(y,' ',y); {simbols tiek izvadīts divas reizes ar atstarpi} writeln(y,' ',y); writeln(y,' ',y); writeln(y,y,y,y,y,y,y,y) end. 5. Noskaidrot, vai kvadratvienadojumam ax2+bx+c=0 ir realas saknes. {vienādojumam ir realas saknes, ja diskrimi- nants D=b2-4ac ir nenegatīvs} p rogram saknes; v a r a,b,c:real; w rite('a= '); read(a); write('b= '); read(b); write('c= '); read(c); write((b*b-4*a*c)>=0) end. {tiek ievadīti vienādojuma koeficienti} {tiek pārbaudīts, vai D nav negatīvs un izvadīts atbilstošs paziņojums} 18

20 Paškontroles uzdevumi 1 Pk1-1. Veikt brīvi uzdotu skaitļu d un e dalīšanu (noformējot programmas veidā): a) d/e b) d div e c) d mod e Decimāldaļskaitļus noformēt ar divām zīmēm aiz komata. Pk1-2. a) Izskaitļot izteiksmes 1,75/1,2-0,432sin(37o)(1-tg(2+0,3 -^4,5 )) vērtību, piešķirot to mainīgajam v un izvadīt v vērtību uz monitora ekrāna. b) Noteikt par cik izmainās izteiksmes y=a(c+d)/(be) vērtība, ja a=9, b=0,001, c= 2+x, d=2/x, e= 6 -x, bet x vērtības ir 2 vai 3. Pk1-3. Noskaidrot, kuri no skaitļiem 31, 84, 1021, 2471, dalās bez atlikuma ar 7 vai 3 un kuri ar 3 un ar 7 vienlaicīgi. Noformēt atbildi teksta veidā. pie sekojošām leņķu vērtībām grādos: xi=0, 30, 60, 120, 240 (decimāldaļskaitļus noformēt ar divām zīmēm aiz komata). Pk1-5. Aprēķināt riņķa līnijas garumu un riņķa laukumu dotai rādiusa vērtībai. Noteikt laukumu gredzenam, kura ārējais diametrs ir D, bet iekšējais d. Parametri D un d lietotāja izvēlētas vērtības. Rezultātus izvadīt ar divām decimālzīmēm aiz komata. Pk1-6. Noteikt diennakts garumu sekundēs saglabājot atbildi mainīgajā d un izvadot šī mainīgā vērtību uz monitora teksta veidā. Pk1-7. Noskaidrot, kādi simboli atbilst kārtas numuriem 5, 42, 30, 254, 200. Pk1-8. Noskaidrot, vai uzdotiem simboliem atbilst pāru vai nepāru kārtas numuri (izmantot funkciju odd(x)). Pk1-9. Noteikt un pārbaudīt vienādojuma 0,47x2-3,75x +1,25=0 saknes. k S M S M M M S M M Pkl-10. Sastādīt programmu, kura m onitora centrā & Jānis Bērziņš & izvada. & IIR B C B 0 1 & a) attēlā redzamo piramīdu, &... & &&&&&&&&&&&&&&&& b) tavu vizītkarti. Pk1-11. Noteikt trīszīmju vesela skaitļa ciparu summu Sazarojumu operatori Līdz šim rakstītās programmas visus operatorus izpildīja tai secībā, kurā tie bija uzrakstīti. Tomēr bieži rodas nepieciešamība izmainīt programmas izpildes gaitu atkarībā no tā, vai uzdotais nosacījums izpildās vai nē. Gadījumos, kad programmas izpildes gaitā jāizvēlas viena no divām iespējamām operatoru grupām, programmā izmanto sazarojumu. Sazarojuma konstrukcijas pieraksts teksta veidā ir: Ja izpildās <nosacījums>, tad tiek veikta < 1.operaturu grupa>, pretējā gadījum ā tiek veikta < 2. operatoru grupa>. Ar sazarojumu saprot situāciju, kad, izpildoties kādam nosacījumam, realizējas viens vai vairāki iepriekš noteikti uzdevumu risināšanas ceļi. 19

21 Pilnas sazarojuma konstrukcijas visparīgais pieraksts Pascal vidē ir I f <loģiska izteiksme> then <operators_l> else <operators_2 >; Ar < loģisko izteiksmi> šeit domāta salīdzināšana: = (ir vienāds); <> (nav vienāds); < (ir mazāks); > (ir lielāks); <= (ir mazāks vai vienāds); >= (ir lielāks vai vienāds). Konstrukcijas if.. then..else blokshēma: Uzdevuma - apreķinat funkcijas y vērtību, ja f 2x - 6, j a x < 3 y = 1, 5 3 [ x + 5, j a x > 3 algoritma blokshēma ir: bet algoritma izpildes programma: program funkc2 ; uses crt; var x,y: integer; ClrScr; writeln('ievadi x vertibu'); readln(x); if x<=3 then y:=2*x - 6 else y:= x +5; writeln('ja x=',x,' tad y=',y); readln end. {attīra ekrānu} {izvada paziņojumu monitorā} {mainīgajam y tiek piešķirta vērtība, kura ir atkarīga no izvēlētās x vērtības} {iegūtā rezultāta izvadīšana } {pauze programmas izpildē} Piemēram, ja tiek ievadīta mainīgā x vērtību 4, tad programma aprēķina y vērtību y=x+5=4+5=9 (jo 4 nav mazāks vai vienāds ar 3), bet, ja tiek ievadīta vērtību x = -4, tad programmas aprēķina rezultātā iegūstam vērtību y=

22 Nepieciešams atcereties, ka, ja aiz operatora then vai aiz operatora else seko vairaki operatori, tad tie jaraksta starp operatoru iekavām un end, t.i., if <nosacījums> then <operators a 1>; <operators a2 > ;... <operators an>; end else <operators b 1>; <operators b2 >;... <operators bn>; end; pie kam aiz pirmā operatoru bloka end semikols (;) nav jāliek. Nav jāliek semikols (;) arī pirms else. Piem ers: if X=0 then writeln('a=', X) else A:=X - 1; w riteln('a -, A); end; Daļēja sazarojuma konstrukcijas forma if Y=0 then A:=Y+1; writeln('a =', A); end else w riteln('a -, A); if <nosacijumi> then < operatori> ir izmantojama gadījumos, ja kāda programmas daļa jāizpilda tikai pie noteiktiem nosacījumiem. Gadījumos, kad šie nosacījumi neizpildās, operatori aiz atslēgvārda then tiek ignorēti un izpildās nākamie programmas operatori. Šādas konstrukcijas if..then blokshēma ir: Piemērs. Sastādīt programmu, kura dod iespēju aprēķināt divu no klaviatūras ievadītu skaitļu a un b summu un izvadīt to uz ekrāna gadījumos, ja kāds no skaitļiem a vai b ir pāra skaitlis. Pretēj ā gadījumā, programma beidz darbu neaprēķinot summu. program summa; uses crt; V ar a, b, sum: integer; ClrScr; write('ievadi a :'); readln (a); write('ievadi b :'); readln (b); if (a mod 2 = 0 ) or (b mod 2 = 0 ) then sum:=a+b; writeln('summa ir: ',sum); end; {sazarojums ar dubultnosacījumu or (vai)} {izvada summu} {sazarojuma beigas} 21

23 writeln('d arbs pabeigts'); readln end Izvēles operators CASE... OF... END {izvada paziņojumu} {pauze} Izmantojot nosacījuma operatoru if..., iespējams izvēlēties vienu no diviem iespējamiem variantiem. Nav ieteicams nosacījuma operatorus atkārtoti ieslēgt vienu otrā. Tas sarežģī programmas struktūru un dara to nepārskatāmu. Tiek rekomendēts veidot ne vairāk kā 2-3 ieslēgtos operatorus. Gadījumos, kad jāpārbauda vairāki nosacījumi, tiek lietots izvēles, jeb variantu operators case. Operatora vispārīgā forma ir: case <selektors> of N1: <operatoru grupa 1> end; N2: <operatoru grupa 2> end; N 3: <operatoru grupa 3> end; Nk: <operatoru grupa k> end else <operatoru grupa (k+ 1)> end; end; Ar šo operatoru var izvēlēties vienu no vairākiem operatoriem vai operatoru grup ām. Operators case sastāv no selektora (mainīgā) un operatoru saraksta, kur katram operatoram vai operatoru grupai tiek piešķirta sava konstante. Ja mainīgā vērtība sakrīt ar kādu no konstantēm, tiek izpildīts attiecīgais operators vai operatoru grupa. Ja attiecīgās konstantes nav, tad tiek uzrādīta kļūda un programmas darbība tiek pārtraukta vai arī tiek izpildīts tas operators, kurš seko tieši aiz izvēles operatora. No visām operatoru grupām tiks izpildīta tikai viena - tā, kuras priekšā konstantes Ni vērtība sakrīt ar selektora vērtību. Operatorā case izmantojamās konstantes Ni netiek uzdotas apraksta daļā. Izpildāmo operato ru grupas var sastāvēt no viena vai vairākiem operatoriem. Selektora vērtībām var izmantot veselu, loģisku vai simbolu tipu. Tas nevar būt real. Operatoru grupa pēc else tiek izpildīta gadījumā, ja neviena konstantes vērtība nesakrīt ar selektora vērtību. Gadījumos, ja vārds else nav iekļauts operatorā case, tiek izpildīts nākamais operators, kurš seko pēc case. Jāņem vērā, ka operatora case beigās stāv vārds end, kuram nav attiecīgā pāra vārda. Piem ērs. G adījum ā, ja nepieciešams dotu veselu skaitli N pārveidot atbilstoši pazīmei, kuru nosaka šī skaitļa dalījuma ar 17 atlikums sekojošā veidā: ja N m od 17=0, tad N=0; N mod 17=1 vai 6, tad N= - N; N m od 17=2, 3 vai 5, tad N= 2N; N m od 17=4, tad N= 3N, case (N mod 17) of 0: N:=0; 1,6: N:=-N; 2,3,5: N:=2*N; 22

24 bet visos citos gadījumos N=5N. Pascal vidē šo uzdevumu veic operators 4: N:=3*N; else N:=5*N; end; Piem ērs. Sastādīt programmu, kura pieprasa lietotājam piespiest kādu klaviatūras taustiņu un izdrukā piespiestā taustiņa grupas nosaukumu: Burts, Skaitlis, Operators, Speciāls simbols. p rogram simbols; uses crt; var x: char; Begin C lrscr; w riteln(n ospiediet kādu klaviatūras taustiņu '); readln(x); case x of 'A'..'Z','a'..'z': writeln('burts'); '0'..'9': writeln('skaitlis'); '+','-','*','/': writeln('operators'); else writeln('specials simbols'); end; readln end. {izvada paziņojumu monitorā} {mainīgo ievadīšana no klaviatūras} {izvēles operatora case sākums} {izvēles: nospiežot kādu taustiņu - simbolu, tiek izvadīts atbilstošais paziņojums, nospiežot taustiņu, kas neatbilst nevienam no uzrādītajiem simboliem, tiek izvadīts paziņojums, kas seko aiz else} Paškontroles uzdevumi 2 Pk2-1. Kada bus mainīga A vērtība pec šadu operatoru izpildes: A:=0; if B > 0 then if C > 0 then A:=1 else A:=2; pie dotajām mainīgo B un C vērtībām: a) B:=1; C:=1; b) B:=1; C:=-1; c) B:= -1; C:=1; Pk2-2. Noradīt kļudu dotaja programmas teksta un paskaidrot to: if 3<A<7 then A:=A+1; B:=-1; else A:=0; B:=B+1; Pk2-3. Doto algoritmu: a) b) if 3<A and A<7 then A:=A+1; B:=-1; end; else A:=0; B:=B+1 end; ja mainīgā A vērtība nav 0 un A kvadrātā ir mazāks par 25, tad mainīt A zīmi; ja A ir 0, tad mainīgajam A piešķirt vērtību 1. pārrakstīt programmēšanas valodā Pascal. 23

25 Pk2-4. Sastādīt programmu, kas pieprasa ievadīt skaitli no 1 līdz 10, un kura ievadīto skaitli izvada monitorā vārdiskā formā. Pk2-5. Sastādīt programmu, kura nosaka, cik un kādi atrisinājumi būs kvadrātvienādojumam ax2+bx+c= 0 (mainīgos a, b un c ievada lietotājs). Pk2-6. Sastādīt programmu, kas aprēķina funkcijas 2x + 5, j a x > 3 y = 2x , j a x < 3 x - 1 vērtību, ja x nosaka sakarība x=3sin(an/180), bet a vērtību ievada lietotājs. Programmā paredzēt iespēju izvadīt paziņojumu "funkciju nav definēta. Pk2-7. Sastādīt programmu, kas pieprasa ievadīt 3 nogriežņu garumus un nosaka, vai no tiem var uzkonstruēt trīsstūri (viena trīsstūra mala ir mazāka par divu pārējo trīsstūra malu summu) Cikla operatori Cikls ir viens no programmēšanas pamatelementiem. Cikla rezultātā tiek daudzkārt atkārtota vienas operatoru grupas izpilde. Tas sev ī ietver programmēšanas būtību - daudzkārtēju vienveidīgu operāciju izpildi. Pascal-ā tiek izmantoti cikli kā ar fiksētu to izpildes skaitu, tā arī ar iepriekš nezināmu ciklu skaitu. Pirmos sauc par kontrolējamiem cikliem, bet otros par cikliem ar nosacījumiem. Nemākulīga ciklu lietošana var radīt situāciju, kad programma nevar iziet no cikla (programma ieciklojusies). Tādā gadījumā Turbo Paskālā tiek izmantoti klaviatūras taustiņi Ctrl+Break. Ja tas nelīdz, Pascal programmu var aizvērt izmantojot taustiņu kombināciju Ctrl+Alt+Delete vai veikt datora pārstartēšanu ar taustiņu Reset. Tas uzskatāms par galēju līdzekli, jo tā rezultātā izpildāmās programmas dati tiks pazaudēti, tāpēc pēc jebkuras programmas teksta rediģēšanas ieteicams to saglabāt Operators FOR... TO... DO... Fiksēta ciklu skaita operatoram for ir sekojoša konstrukcija: for i:= a to b do <operatoru grupa> end; (no i vērtības vienādas ar a līdz i vērtībai vienādai ar b tiek izpildīta operatoru grupa). Tātad operatoru grupa tiek izpildīta (b-a+1) reizes. Svarīgi ņemt vērā, ka ciklu izpildes solis ir +1, bet parametriem a un b jāapmierina nosacījums a<b. Operatora parametri a, b, i tiek definēti kā naturāli skaitļi, vai simbolu tips, piem., a,b,i:integer; vai a,b,i:char; Cikla operatoram soli var izvēlēties arī vienādu ar - 1. Tādā gadījumā operatora konstrukcija ir: for i:=b downto a do <operatoru grupa> end; Cikla operatora izpilde sākas ar nosacījuma i<= b pārbaudi. Ja nosacījums neizpildās, tad cikla operatoru grupa netiek izpildīta un tiek turpināta programma. Ja nosacījums izpildās, tad tiek izpildīta cikla operatoru grupa un cikla parametram i tiek pie šķirta nākamā vērtība i:=i -1. Process atkārtojas. 24

26 Piem ēri: Izpildot programmas fragmentu - operatoru for i:=15 to 19 do write(i:3); uz ekrāna tiks izvadīta ciparu virkne: ; for i:=19 downto 15 do write(i:3); uz ekrāna tiks izvadīta virkne: ; for ch:= a to e do write(ch:2 ); uz ekrāna tiek izvadīta burtu virkne: a b c d e; for i:= e downto a do w rite(ch:2 ); uz ekrāna tiek izvadīta burtu virkne: e d c b a. Programmas datu izvadei ērti lietot cikla operatoru for. Tā, piemēram, operators for i:=1 to 50 do w riteln(i); if i mod 24 = 23 then readln; end; apstādinās datu izvadi pie i = 23 un 47. Izvade atjaunosies nospiežot Enter. Priekšlaicīgu izeju no cikla var panākt izmantojot operatorus goto vai break Piemēram: for i:=1 to 45 do f:=f+i; Konstrukcijas for...to...do blokshēma ir: if (f>100) or (i=39) then break; end; Ja ciklā jāizpilda vairākas komandas, tad tās jāraksta starp atslēgvārdiem un end. Uzdevums. Sastādīt programmu, kura no lietotāja ievadītā skaitļa vispirms atņem 1, tad 2, tad 3,..., tad 10 un galīgo rezultātu izvada uz displeja ekrāna. p rogram atnem_1 ; uses C rt; var n,i:integer; ClrScr; write('ievadi skaitli: '); readln(n); {ievada n vērtību, vēlams >55} for i := 1 to 1 0 do {cikls} n:=n-i; {n tiek samazināts par i} writeln('skaitlis ir: ',n); end. {izvada iegūto n vērtību} Modificējam programmu tā, lai no lietotāja ievadīta skaitļa n vispirms tiktu atņemts 10, tad 9, tad 8,...,1. Visi rezultāti jāizvada uz monitora ekrāna. 25

27 p rogram atnem 1 0 ; uses crt; var n,i:integer; C lrscr; writeln('ievadi skaitli: '); readln(n); for i : = 1 0 downto 1 do n:=n-i; writeln('skaitlis ir: ',n); end; readln; end. {cikls} {mainīgā n vērtība tiek samazināta par i un iegūtais rezultāts izvadīts uz monitora ekrāna} Programmas izpildes rezultāta, gadījumā, ja n=100, iegūstam naturalu skaitļu virkni Piem ēri. 1. Izveidot programmu, kura ļauj noteikt visu naturālo skaitļu summu intervālā (a,b). Izveidot programmas atnem_10 variantu izmantojot iegūtās programmas operatoru bloku. 2. Izveidot programmu, kura ļauj noteikt uzdota naturāla skaitļa n faktoriāla vērtību (n!= (n-1)-n). 3. Izveidot programmu, kura ļauj noteikt no 100 ģenerētiem skaitļiem maksimālo skaitli. 4. Izveidot programmu, kura fiksētām naturāla skaitļa n vērtībām nosaka skaitļu summas S=1+1/2+1/3+1/ /n vērtību. 5. Izveidot programmu, kura ļauj noteikt 100 ģenerēto skaitļu pāra un nepāra skaitļu skaitu, summu un vidējo vērtību. 6. Izveidot programmu reizrēķina zināšanu testēšanai. p rogram Nr1; p rogram Nr2; v a r i,a,b,s:integer; v a r i,n,fakt:integer; writeln('ievadi skaitli a= '); w riteln('ievada skaitli n= '); read(a); readln(n); writeln('ievadi skaitli b= '); fakt:=1 ; read(b); for i : = 1 to n do s:=0 ; fakt:=fakt*i; for i:=a to b do write(fakt) s:=s+i; end. write(s) end. 26

28 p rogram Nr3; p rogram Nr4; var var i,m,a: integer; i,n:integer; s:real; m:=0 ; for i := 1 to do writeln('ievadi skaitli n= '); readln(n); a:=random(50); s:=0 ; if a>m then m:=a; for i : = 1 to n do end; s:=s+ 1/i; write(m) write('summa ir s=',s:6:3) end. end. p rogram Nr5; p rogram N r6 ; v ar v a r i,a,b,atbilde,atziime:integer; i,a,psk,psum:integer; nsk,nsum,pvv,nvv: integer ; random ize; for i:=1 to 5 do psk:=0 ; nsk:=0 ; psum:=0 ; nsum:=0 ; a:=random(18)+2; for i := 1 to do b:=random(18)+2; a:=random(50); write('cik ir ',a,'*',b, '? Atbilde ir '); if a m od 2 = 0 then readln(atbilde); psk:=psk+1 ; psum:=psum+a; if atbilde=a*b then end writeln(' Pareizi!'); else atziime:=atziime+1 ; end nsk:=nsk+1 ; nsum:=nsum+a; else writecnepareizi.'); end; end; end; writeln('juusu atziime ir ',atziime) pvv:=psum/psk; nvv:=nsum/nsk; end. write(psk:4, ' ',psum:6, ' ',nsk:4, ' ', nsum:6, ' ',pvv:4,' ',nvv:4) end Operators WHILE... DO... Cikla operators while... do... organizē ciklus ar neierobežotu ciklu skaitu. Tas nozīmē, ka tiek atkārtota fiksēta operatoru grupa tik reizes, cik reizes ir sp ēkā uzdotais nosacījums. Cikla izpildes nosacījuma pārbaude notiek operatora sākumā (cikla priekšnosacījums). Operatora while... do...blokshēma redzama attēlā. Jāņem vērā, ka cikla parametram (mainīgajam, kuru satur kā cikla nosacījums, tā <operatoru grupa>) pirms cikla izpildes uzsākšanas jāpiešķir noteikta vērtība, un vienam no cikla operatoriem šī vērtība ir jāmaina, jo pretējā gadījumā cikls turpināsies bezgalīgi. Operatora pieraksta forma: 27

29 while <nosacijums> do <operatoru grupa>; end; Nosacījums ir loģiskā izteiksme. Tas var tikt izteikts dažādos veidos. Piemēram: x>0; (a>1) and (b<>0); s= A. Gadījumos, kad nosacījum a vērtība ir true, izpildās cikla operatoru grupa, pie nosacījum a vērtības false šī izpilde pārtraucas. Ja pirmā vērtība ir false, tad cikls neizpildās un otrādi, ja nosacījum a vērtība ir true un pēc operatoru grupas izpildes tā nemainās, cikls atkārtojas bezgalīgi. Šo cikla operatoru lietderīgi lietot gadījumos, kad iespējamas situācijas, kurās nosacījums neizpildās un līdz ar to cikla operatoru izpilde izpaliek. Piemērs. Izmantojot cikla operatoru while... do sastādīt programmu, kura dod iespēju nodrukāt visus skaitļus, kuri nepārsniedz 100 un dalās ar 7. p rogram dalamie_2 ; uses crt; var y: integer; C lrscr; y :=0; {piešķir y sākumvērtību} while y< = do {cikla sākums, cikls tiek pildīts tik ilgi, kamēr y ir mazāks vai vienāds ar } y:=y+7; {y vērtība tiek palielināta par 7} w riteln(y); { izvada parametra y vērtību } end; {cikla beigas} writeln('program ma {paziņojums teksta veidā} darbu pabeidza.'); readln; end. Piem ēri. 1. Nodrukāt n skaitļus (no 1 līdz n), izmantojot operatoru while. 2. Sastādīt programmu, kura nosaka to naturālo skaitli k, pie kura izteiksmes xk/k vērtība kļūst lielāka par uzdotu skaitli A (x>1, A>1). p rogram Nr1; const n= 1 0 ; var m:integer; m:=0 ; while m<n do m:=m +1 ; write(m:4); end end. p rogram Nr2; var x,a,p:real; k:integer; read(x,a); k:=1; p:=x; while p/x<=a do k:=k+1 ; p:=p*x; end; write(k) end. 28

30 Piemers. Noteikt funkcijas y (x ) = lg(3)+ xyļ5 sin(px / 3) vērtības intervālā (a, b) ar soli dx. p rogram funkcija; var x,y,z,dx,a,b,lg3:real; write('ievadi a ='); readln(a); write('ievadi b ='); readln(b); write('ievadi dx ='); readln(dx); lg3:=ln(3)/ln(10); x:=a; while x<=b do z:=sin(pi*x/3); if (z<0) then writeln('pie vērtības x=',x, ' funkcija nav definēta') else y:= lg3 + x* sqrt(5*z); writeln('pie vērtības x=',x,' funkcijas vērtība y=',y); end; x:= x+dx; end end Operators REPEAT... UNTIL... Cikla operators repeat arī organizē ciklus ar neierobežotu ciklu skaitu. Atšķirībā no iepriekšējā operatora (while), ciklu atkārtotas izpildes nosacījums pārbaudās pēc cikla operatoru grupas izpildes. Tātad cikla operatoru grupa izpildās vismaz vienu reizi, pat gadījumā, ja nosacījums pie pārbaudes neizpildīsies. Operatoru grupa ir ieslēgta starp vārdiem repeat un until un līdz ar to operatoru iekavas un end nav nepieciešamas. Operatora vispārējā pieraksta forma ir R epeat <operatoru grupa> until <nosacījums>; Cikls atkārto <operatoru grupas> izpildi līdz brīdim, kad izpildās nosacījums cikla beigās. Nosacījums aiz atslēgvārda until norāda, kad programmai pārtraukt cikla izpildi. Tātad cikls atkārtojas tik ilgi, kamēr nosacījuma vērtība ir false. Šī operatora blokshēma ir 29

31 Jāņem vērā, ka cikla mainīgajam pirms cikla jā piešķir kāda konkrēta vērtība, un vienam no cikla operatoriem šī vērtība ir jāizmaina, pretējā gadījum ā cikls turpināsies bezgalīgi. Piemērs. Sastādīsim programmu, kura izvada uz ekrāna visus veselos skaitļus, kuri nepārsniedz un dalās ar 9. program dal_ar_9; uses crt; var x:integer; C lrscr; x:= 0 ; repeat {cikla sākums}; x:=x+9; { x vērtība tiek palielināta par 9} write(x:5); {tiek izvadīta mainīgā x vērtība} until x> = ; {cikla beigas un nosacījuma pārbaude} writeln('program m a darbu pabeidza.'); {paziņojuma izvadīšana} readln; end. Monitora ekrānā tiek izvadīti skaitļi: Piemēri. Izmantojot operatoru repeat: 1) nodrukāt n naturālus skaitļus, 2). noteikt to naturālo skaitli k, pie kura izteiksmes xk/k vērtība kļūst lielāka par uzdotu skaitli A (x>1, A>1). program Nr 1r; program Nr 2r; const n= 1 0 ; var x, A, p:real; var m:integer; k:integer; m:=0 ; read(x,a); k:=0; p:=1; repeat repeat m:=m +1 ; k:=k+1 ; w rite(m:4) p:=p*x until m>n until p/k>=a; end. w rite( k=, k) end. Paškontroles uzdevumi 3 Pk3-1. Kas tiks izdrukāts monitora ekrānā pēc doto programmas fragmentu izpildes? a) for i:=3 to 8 do w rite(2*i, ); b) for i:=1 to 5 do write(i:4, ' ;', (100-i):5); c) Skaitlis:= 2; for i:= (5*2-4) to 5*Skaitlis do w rite ('**', i:5); 30

32 d) for i := 12 downto 4 do writeln(25-i: 5); Pk3-2. Izlabo dotos operātorus tā, lai tie atbilstu uzdevumu nosacījumiem. a) Sastādīt programmu, kas monitora ekrānā izdrukā skaitļus no 1 līdz 5 vienu zem otra. for i := 1 to 5 do; writeln(i); b) Sastādīt programmu, kas ļauj ievadīt 10 skaitļus, saskaita tos un rezultātu izdrukā monitora ekrānā. Summa := 0; for i:= 1 to 1 0 do read(skaitlis); Summa:= Summa + Skaitlis; writeln(summa: 15); Pk3-3.. Pārraksti doto programmas fragmentu, izmantojot operatoru for..to..do tā, lai monitora ekrānā tiktu izdrukāts tāds pats rezultāts: for i:= 10 downto 3 do writeln(i: i); Pk3-4. Pārraksti doto programmas fragmentu, izmantojot operatoru for..downto..do tā, lai monitora ekrānā tiktu izdrukāts tāds pats rezultāts. Summa := 0; for i := 1 to 4 do w riteln( * : i); Summa:= Summa + i; writeln(sum ma); end; Pk3-5. Izveidot programmu, kura ļauj noteikt visu intervāla [a,b] naturālo skaitļu kvadrātu summu. Pk3-6. Izveidot programmu, kura ļauj noteikt uzdota intervāla [a,b] naturālo skaitļu reizinājumu. Pk3-7. Izveidot programmu, kura ļauj noteikt no 100 ģenerētiem skaitļiem to maksimālo (vai minimālo) vērtību. Pk3-8. Izveidot programmu, kura ļauj noteikt 100 ģenerēto skaitļu skaita sadalījumu pa intervāliem [0, k/3), [k/3, 2k/3) un [2k/3, k). Parametrs k atbilst ģenerēto skaitļu potenciāli iespējamai maksimālai vērtībai. Pk3-9.. Izveidot programmu, kura ļauj noteikt skaitļu summas S = 1-1/2 +1/3-1/ (-1)n /n vērtību fiksētām naturāla skaitļa n vērtībām. Pk3-10. Izveidot programmu, kura ļauj izveidot atbilstību starp temperatūru vērtībām Celsija un Fārenheita skalās, kur temperatūra Celcija skalā ir intervālā [-10; 10]. Izmantot sakarību tf=9tc/5+32. Pk3-11. Sastādiet programmu, kas izvada uz ekrāna funkcijas Y=X2+3X-2 vērtību tabulu, kur X vērtības ir no 1 līdz 10. Pk3-12. Sastādīt programmu, kas aprēķina n pēc kārtas ņemtu skaitļu summu (intervāla sākumu un n ievada lietotājs). Piemēram, ja intervāla sākums ir 3 un n=4, tad programma saskaita =18. Pk3-13. Sastādīt programmu, kas izvada 7 gadījuma skaitļus, kuru vērtība atrodas in 31

33 tervālā [2,6 ] un aprēķina šo skaitļu kvadrātu summu. Pk3-14. Sastādīt programmu, kura aprēķina Tavu naudas daudzumu pēc G gadiem, ja Tu esi noguldījis bankā N latus uz P procentiem gadā. Pk3-15. Sastādīt programmu, kura nosaka skaitļu rindas locekļu skaitu līdz summas n- tais loceklis neatšķiras vairāk kā par uzdotu skaitli p. a) S=1+1/2+1/3+1/ /n (p=0,0 0 1 ); b) S=1-1/2+1/3-1/ /n (p=0,001); c) S=1-1/2-1/3-1/ /n (p=0,001). Pk3-16. Sastādīt programmu, kura ļauj noteikt, cik dienām pietiks 200 tonnu cementa, ja pirmajā dienā patērē 5 tonnas, bet katrā nākamajā dienā par 20% vairāk nekā iepriekšējā. Pk3-17. Sastādīt programmu, kura nosaka visus Pitagora skaitļus gadījumam, kad 1<=a<20, 1<=b<20. Tātad jāatrod vesels skaitlis, kura kvadrāts ir divu skaitļu no dotā intervāla kvadrātu summa Masīvi Darbojoties ar garām skaitļu vai simbolu virknēm, līdz šim bija nepieciešams definēt katram skaitlim vai simbolam savu atsevi šķu mainīgo. Tas rada pārblīvētības iespaidu un apgrūtina programmas pārskatāmību. Lai atvieglotu liela apjoma datu apstrādi, P a scal un daudzās citās programmēšanas valodās ir iespēja veidot strukturētus mainīgos, kuru struktūra sastāv no vairākām viena tipa vērtībām. Katram strukturētajam mainīgajam ir viens nosaukums, bet pats mainīgais ir sadalīts mazākās vienībās un katra vienība satur vienu vērtību. Pie strukturētajiem mainīgajiem pieder masīvi, ieraksti un faili. Vairākas viena tipa vērtības var apvienot masīvā. Masīvs ir galīga skaita elementu kopum s, k u rā apvienoti viena tipa elementi. Katram masīva elementam ir savs kārtas numurs. Masīvus iedala viendimensiju un daudzdimensiju masīvos. Tā, piemēram, skaitļu virkni var uzskatīt par viendimensiju masīvu. Bet datu tabulu (piemēram matricu) par divdimensiju masīvu. Pieeja masīva elementiem notiek pēc elementa kārtas numura masīvā jeb indeksa. A r indeksa palīdzību tiek norādīts konkrētais masīva elements. Katram masīva elementam ir viens vai vairāki indeksi, kuri norāda elementa vietu masīvā. Elementi masīvā ir sakārtoti to indeksu augšanas secībā. Masīvu raksturojoši lielumi ir tips - visu masīva elementu tips; izmērs (rangs) - masīva indeksu skaits; indeksu izmaiņas diapazons - nosaka visu masīva elementu skaitu. Vektors ir masīva piemērs, kura visi elementi tiek numurēti ar vienu indeksu. Līdz ar to vektora koordinātes ir viendimensiju masīva elementi. Matrica (vērtību tabula) ir divdimensiju masīva piemērs. Tā elementi tiek numurēti ar diviem indeksiem - rindas numuru un stabi ņa numuru. Augstāku kārtu masīvi praksē sastopami visai reti. 32

34 Datora atmiņā visi masīva elementi aizņem obligāti vienu nepārtrauktu apgabalu. Divdimensiju masīvi atmiņā tiek izvietoti pa rindām: vispirms visi pirmās rindas elementi, tad otrās u.t.t. Masīva elementa numurs vispārīgā gadījumā ir kārtas tipa izteiksme. Visbiežāk indekss ir konstante vai integer tipa mainīgais, retāk - char tipa vai boolean tipa lielums. Konkrēts masīva elements tiek aprakstīts aiz masīva nosaukuma kvadrātiekavās norādot tā indeksu. Piemēram, A[3], B[3,5]. Viena no masīvu priekšrocībām ir tā, ka to indeksi var būt gan mainīgie, gan izteiksmes. Tas dod iespēju vērsties pie noteiktas masīva elementu virknes. Tā, piemēram A[i] dod iespēju pārskatīt visus masīva elementus, bet pieraksts A[i*2] - elementus, kuri atrodas pāra vietās vai A[2*i-1] - nepāra vietās. Vienkāršākais masīva apraksta veids - mainīgo apraksta daļā var tiek definēts attiecīgs apzīmējums izmantojot vārdu array. Viendimensiju masīva gadījumā Piemeram: v a r <masiva vards>array[apakšēja robeža..augšēja robeža] a: array [ ] of integer; { vesela tipa skaitļu masīvs} b:array[0..25] o f char; {26 elementi - simboli} c: array [-3..4] of boolean; { 8 elementi - loģiskās vērtības} Divdimensiju gadījumā kur, v a r <masiva vards> array[rl..m, sl..sm] of <elementu tips> r 1 - pirmās rindas kārtas numurs; rn - pēdējās rindas kārtas numurs; s 1 - pirmā stabiņa kārtas numurs; sm - pēdējā stabiņa kārtas numurs. Tātad definējot tabulu masīva veidā aprakstam jālieto var tabula:array[1..3,1..4] of integer; Svarīgi ievērot, ka ne vienmēr visi masīva elementi ir aizpildīti, tas nozīmē, ka reālais masīva elementu skaits var būt mazāks par definēto, bet nekādā gadījum ā nedrīkst rasties situācija, kad reālais masīva elementu skaits ir lielāks par masīva definīcijā paredzēto. Svarīgi ņemt vērā, ka Turbo Pascal-ā ir visai stingrs ierobežojums attiecībā uz operatīvo atmiņu, kas pieejama mainīgo aprakstam. Tās apjoms ir 64 kbaiti. Tātad izmantojot definīcijā array[1..105,1..105] of real tiek pārsniegta programmēšanas vidē pieejamā atmiņa (viens real tipa elements atmiņā aizņem 6 baitus). Šādā situācijā tiek uzrādīta kļūda E rro r 22 (structure too large). Operatīvās atmiņas ekonomijai lietderīgi iespēju robežās izmantot vienbaitīgus tipus byte un shortint. 33

35 Definējot masīvus to indeksu robežas nedrīkst uzdot ar mainīgajiem. Šim nolūkam ieteicams izmantot konstantes, kuras nosaka elementu skaitu. Tātad divdimensiju m a sīvu ērti definēt sekojošā veidā: const r=10; k=15; var m atrica:array[1..r,1..k] of real; Masīvu definēšanu var realizēt arī citos veidos - const daļā kā tipizētu konstanti vai type daļā definējot masīvu kā atsevišķu tipu. Iespējamās tipiskās kļūdas aprakstot masīvus: 1) nav noteikts masīvu izmērs un diapazona robežas - a:array[ ] of real; 2 ) masīva apakšējā robeža lielāka par augšējo - a:a rra y[1 0..1] of integer; 3) masīva robežas jāuzrāda ar konstantēm, bet ne ar izteiksmēm - a:array [1..x+y] of real; 4) indeksu robežas nedrīkst uzdot ar decimālskaitļiem - a:array[ ] of integer. Izejot ārpus masīva indeksu robežām var tikt bojātas ar masīva elementiem aizņemtās atmiņas daļas blakus šūnas. Ja vairākiem masīviem ir vienāds elementu skaits un viens un tas pats tips, tad tos var definēt, piemēram, šādi: var A, B, C:array[1..10] of real; Te katram no masīviem A, B, C var būt līdz 10 elementiem, kuri ir reāli skaitļi. Vienāda tipa un izmēra masīviem vērtību piešķiršanu var veikt šādi: A:=B; {masīvam A piešķir masīva B vērtības}. Piem ērs. īs masīvi: A[1..10], B[1..10], C[1..20]. Masīvs A aizpildīts ar gadījuma skaitļiem. Masīvam B tiek piešķirtas masīva A vērtības. Jāsastāda programma, kura dod iespēju aizpildīt masīvu C atbilstoši sekojošai shēmai: p rogram masivi_3; uses crt; var A,B: array [1..10] of integer; C:array[1..20] o f integer; i:integer; clrscr; random ize; for i : = 1 to 1 0 do A[i]:=random(10); writeln('m asivs A:'); for i : = 1 to 1 0 do write(a[i]:3); w riteln; {definē divus 1 0 integer tipa elementu masīvus} {definē 2 0 integer tipa elementu masīvu} {masīva A aizpildīšana ar gadījuma skaitļiem {masīva A vērtību izvade ekrānā, izmantojot ciklu} {izvada tukšu rindu} 34

36 B:=A; writeln('m asivs B:'); for i := 1 to 1 0 do write(b[i]:3); w riteln; for i : = 1 to 1 0 do C[2*i-1]:=A[i]; C[2*i]:=B[i]; end; writeln('m asivs C:'); for i : = 1 to 2 0 do write(c[i]:3); end Darbības ar masīviem {masīvam B piešķir masīva A vērtības} {masīva B vērtību izvade ekrānā, izmantojot ciklu} {masīva C elementiem, kuru indeksi ir nepāra skaitļi piešķir masīva A vērtības} {masīva C elementiem, kuru indeksi ir pāra skaitļi piešķir masīva B vērtības} {Masīva C vērtību izvade ekrānā, izmantojot ciklu} Viendimensiju masīvu var stādīties priekšā kā galīgu lentu, kura sadalīta rūtiņās. Katrai rūtiņai ir kārtas numurs un attiecīgajā rūtiņā var kaut ko ierakstīt. Ar masīvu nevar rīkoties kā vienu veselu. Lai veiktu kādu operāciju ar masīvu kopumā, šī operācija ir jāveic ar katru masīva elementu atsevišķi, vēršoties pie konkrētā masīva elementa, izm antojot tā indeksu. Ja programmā nepieciešams izvadīt ekrānā visu masīva elementu vērtības, tad visērtāk ir lietot galīga skaita ciklu operatoru for, kurā cikla mainīgo izmanto kā masīva indeksa vērtību Masīvu aizpildīšana. Masīva elementu vērtības var uzdot sekojošos veidos: datu ievads no klaviatūras (programmas piemērs 1); ar gadījuma skaitļu ģeneratoru (programmas piemērs 2 ); ar piešķires operatoru; nolasot elementu vērtības no faila. Katrā no šiem gadījumiem masīva aizpildīšanai tiek izmantots cikls. Tā, piemēram, ievads no klaviatūras realizējas ar for i:=1 to 5 do readln(a[i]); {vektors no 5 elementiem} vai for i:=1 to 3 do for j:=1 to 2 do readln([b[i,j]); {matrica ar izmēru 3x2, t.i. 6 elementiem aizpildās pa kolonām}. Aizpildot masīvu c ar n gadījuma skaitļiem no diapazona 0-99 izmantojam random ize; {gadījuma skaitļu devēja inicializācija} for i:=1 to n do C[i]:=random(100); Masīvu aizpildīšana ar gadījuma skaitļiem bieži tiek lietota veicot matemātisko modelēšanu un spēles gadījuma situāciju realizācijai. 35

37 Gadījumos, kad masīvs,jāattīra no iepriekšējām elementu vērtībām, to aizpilda ar nullēm: for i:=1 to n do A[i]:=0; Masīva elementa vērtību izvade realizējas arī ar cikla operatoru for izmantojot operatorus w rite un writeln. Vektora izvadi stabiņu veidā realizē for i:=1 to n do writeln(a[i]); bet rindas veidā for i:=1 to n do write(a[i], ); vai for i:=1 to n do write(a[i]:4); Matricu izvads standarta formā (pa rindām un kolonnām) realizējas izmantojot operatoru writeln bez parametra: for i : = 1 to n do for j := 1 to m do write(a[i,j]:4); w riteln; end; (skaitļu formāts palīdz nolīdzināt kolonnas) Masīvu aizpildīšanas piemēri 1. K atram m asīva elementam ar piešķires operatoru tiek piešķirta konkrēta vērtības. Sastādīsim programmu, kura aizpilda masīvu A[1..7] ar nedēļas dienu nosaukumiem un izvada tos uz ekrāna. p rogram diena; uses crt; var A: array [1..7] of string; {definē masīvu ar 7 string tipa elemeni : integer; tiem} clrscr; {Masīva elementus aizpilda ar nedēļas A[1] -Pirm diena'; dienu nosaukumiem} A[2] -O trdiena'; A[3] -'Trešdiena'; A[4] -'Ceturtdiena'; A[5] -'Piektdiena'; A[6 ] -'Sestdiena'; A[7] -'Svetdiena'; for i:=1 to 7 do writeln(a[i]); readln; end. {Masīva elementu vērtību izvadīšana uz ekrāna} 2. M asīva aizpildīšana a r cikla palīdzību Sastādīsim programmu, kura izveido skaitļu virkni no veseliem skaitļiem no 1 līdz n dilstošā secībā un izvada to uz ekrāna. Gadījumā, ja n=14, tad masīvu grafiski var attēlot šādi: 36

38 I 14 I 13 I 12 C v \\ 10 I 9 I 8 I 7 I 6 I 5 I 4 I 3 I 2 I 11 Protams, šo uzdevumu var atrisināt, neizmantojot masīvu, bet katru skaitļu virknes elementu piešķirot konkrētam mainīgajam. Šajā gadījumā ir jāizveido 14 mainīgie. Veidojot šāda tipa programmu, tās apjoms pieaug proporcionāli virknes elementu skaitam. Tādēļ tiek pielietots masīvu uzpildīšanas paņēmiens izmantojot ciklus. Varam atzīmēt, ka programmas masivs_1 apjoms nemainīsies, ja elementu skaits pieaugs. Turpretī izmantojot iepriekšējo masīva uzpildes paņēmienu, programma būtiski pagarinās. Sastādot programmu, kura paredzēta lielu masīvu apstrādei, ieteicams, vismaz programmas veidošanas sākumposmā, masīva elementiem piešķirt gadījuma skaitļu ģeneratora piedāvātās vērtības. Pēc tam, kad masīva elementu apstrāde ir noprogrammēta, atrastas pieļautās kļūdas un konstatēts, ka programma strādā atbilstoši uzdevuma izvirzītaj ām prasībām, masīva elementu vērtību piešķiršanu gadījuma skaitļu veidā var aizstāt ar read, readln vai citiem operatoriem. program masivs_1 ; uses crt; v a r M:array[1..14] o f integer; {definē masīvu ar 14 integer tipa ele- mentiem} n,i: Integer; C lrscr; write('cik ir masiva elementu? '); readln(n); for i:=n downto 1 do write('ievadi skaitļu virknes ',i, ' elemen {Masīva vērtību ievade izmantojot ciktu: '); lu} readln(m [i]); end; for i:=1 to n do write(m[i]:4); readln; end. {Masīva vērtību izvade ekrānā, izmantojot ciklu} 3. Sastādīt programmu, kura aizpilda masīvu A[1..10] ar gadījuma skaitļiem no intervāla (3,10). 37

39 p rogram masivs_2 ; uses crt; var A:array[1..10] of integer; i: integer; clrscr; random ize; for i := 1 to 1 0 do A[i]:=random(8)+3; for i := 1 to 1 0 do write(a[i]:4); end. {definē masīvu ar 1 0 integer tipa elementiem} {masīva aizpildīšana ar gadījuma skaitļiem*} {masīva elementu vērtību izvade uz ekrāna} Piezīme.* {dators iedomājas skaitli no intervāla [3;10], jo random (8 ) iniciē skaitli no intervāla [0,7], bet pieskaitot 3, A[i] vērtību intervāls ir [3,10].} Masīvu apstrāde Bieži nākas aprēķināt masīva elementu summu, to vidējo vērtību, noteikt maksimālās vai minimālās elementu vērtības un to kārtas numurus, nomainīt atsevišķu elementu vērtības ar citām u.t.t. Viendimensiju masīva elementu summu nosaka: s: = 0 for i:= 1 to n do S:=S+a[i]; bet to reizinājumu: r:= 1; for i : = 1 to n do r:=r*a[i]; Piem ērs. Meteoroloģiskā stacija ik pēc divām stundām reģistrē gaisa temperatūru. Sastādīt programmu, kura ļauj ievadīt iegūtos mērījumus un aprēķina diennakts vidējo gaisa temperatūru. Tātad diennaktī tiek veikti 12 neatkarīgi mērījumi. p rogram Meteo_stacija; uses crt; const n=1 2 ; v a r sum,vid:real; i: integer; M :array[1..n] o f real; clrscr; for i : = 1 to n do {definē n real tipa elementu masīvu} {aizpilda masīva elementus ar mērījumu vērtībām} 38

40 write('ievadi ',i,'. merijumu: '); readln(m [i]); end; sum:=0; for i:=1 to n do sum:=sum+m[i]; vid:=sum/n; writeln('diennakts videja temperatura ir ',vid:3:1, ' graadi. '); end. {nosaka mērījumu summu} {aprēķina diennakts vidējo temperatūru un izvada uz ekrāna} Lai noteiktu veselu skaitļa masīva elementu skaitu, kuri ir pāru skaitļi, izmantojam programmas fragmentu: k:=0; for i:=1 to n do if a[i] mod 2=0 then k:=k+1; {tiek pārbaudīts katrs masīva elements, vai tas dalās ar 2 bez atlikuma un fiksēts šādu elementu skaits}. Bieži ir nepieciešama elementu meklēšana ar īpašu vērtību. Atrast elementu nozīmē noteikt tā kārtas numuru masīvā. Tā, piemēram, lai noteiktu pirmo masīva elementu, kura vērtība ir 0, varam izmantot: i:=0; repeat i:=i+1; until(a[i]=0) or (i=n) if a[i]=0 then w riteln(' pirmais elements ar vērtību 0 ir ', i) else w riteln ('tāda elementa nav'); {masīva elementa numurs} {vai nu tāds elements tiek atrasts vai arī nē (n atbilst pēdējam masīva elementam)} Gadījumā, ja jāatrod visi elementi, kuru vērtības ir 0, būs jālieto cikla operators for. Šai nolūkā varam izmantot sekojošus operatorus: W riteln( elementu, kuru vērtības ir 0, kārtas numuri ir ); for i:=1 to n do if a[i]=0 then w rite(i, ); Elementu maksimālās vērtības un tā kārtas numuru nosaka operatori: max:=a[1]; k:=1 for i:=2 to n do if a[i]>max then max:=a[i]; k:=i; end; {meklēšanu sāk ar pirmo elementu} {pārskata visus pārējos elementus sākot ar otro} {fiksē katru atrasto vērtību, kura lielāka par visām iepriekšējām} Šis programmas fragments nodrošina pirmā maksimālā elementa noteikšanu. Operatorā if izmantojot nosacījuma formu a[i]>=max, nosakām pēdējo elem entu ar m aksim ālu vērtību (pie nosacījuma, ka ir vairāki elementi ar maksimālu vērtību). 39

41 Studentam ieteicams izveidot programmas fragmentu, kurš dod iespēju fiksēt visus elementus ar maksimālo vērtību. Atsevišķu masīva elementu vērtības nom aiņa ar uzdoto vērtību realizējas ar operatoriem: min:=80; for i : = 1 to n do if a[i]<min then a[i]:=min; Šāds algoritms atbilst situācijai, kad pārskatot n darbinieku algas tiek konstatēts, kuriem no darbiniekiem alga ir zem pie ļaujamā minimuma (80) un tās tiek nomainītas ar šo fiksēto vērtību min. Studentam ieteicams papildināt šo programmas fragmentu ar operatoriem, kas ļautu fiksēt cik šādu darbinieku ir kopskaitā un par cik būs jāpalielina kopējais algu fonds. M asīva elem entu pārvietošanas mērķis ir elementu vērtību apmaiņa vietām. Tātad elementu vērtības nemainās, bet mainās to atrašanās vieta. Lai realizētu šādu elementu vērtību pārvietošanu, tiek izmantots papildus mainīgais (apmaiņas buferis), kurā uz laiku tiek saglabāta viena no elementu vērtībām. Lai realizētu masīva pirmā elementa vērtības apmaiņu ar piektā elementa vērtību, izmanto operatorus: buf:=a[1]; a[1]:=a[5]; a[5]:=buf; Masīvu sakārtošana K ārtošana un m eklēšana ir svarīgākie informātikas jēdzieni. Kārtošanas būtība ir viena tipa datu kopuma sakārtošanas process augošā vai dilstošā kārtībā atbilstoši kādai no pazīmēm. Kārtošanas procesā masīva elementi tiek mainīti vietām tā, lai gala rezultātā to vērtības būtu sakārtotas augošā vai dilstošā kārtībā. Gadījumos, kad starp masīva elementiem ir elementi ar vienādām vērtībām, lieto jēdzienus nedilstoši un neaugoši masīvi. Sakārtotos masīvos informācija atrodama daudz ērtāk un ātrāk. Masīvu kārtošanai ir izstrādāti daudzi algoritmi, kuri atšķiras, galvenokārt, ar to realizācijas ātrumu. Liela apjoma ( un vairāk elementu) masīviem racionāli izmantot ātrās kārtošanas metodes. Mazāka apjoma masīviem var tikt pielietoti paši vienkāršākie kārtošanas algoritmi. Par vienu no vienkāršākajām kārtošanas metodēm uzskatāma lineārā sakārtošanas metode. Šīs metodes būtība atbilstoši veicot masīva sakārtojumu nosacījumam par tā elementu vērtību neaugšanu, ir pārskatot visu masīvu atrast lielāko vērtību un apmainīt to ar pirmā elementa vērtību. Algoritms tiek atkārtots sākot ar otro masīva elementu, tā noteiktā maksimālā vērtība tiek apmainīta ar otrā masīva elementa vērtību. Šādu procesu realizē programma: 40

42 p rogram sakarto_1 ; const n=1 0 ; M :array[1..n] of byte {masīvs tiek definēts tipizētas konstantes =(9,11,12,3,19,1,5,17,19,3); veidā} var i, j, buf, k:byte; a: integer; writeln('dotais masīvs '); for i:=1 to n do write(m[i]:3); writeln; a:=0 ; { - iterāciju skaitītājs} for i := 1 to n -1 do for j:=i+ 1 to n do {nepārbaudītās masīva daļas izmēra iz maiņa} a:=a+ 1 ; if M[i]<M[j] then {salīdzina i-to elementu ar nepārbaudītās masīva daļas elementiem} buf:=m[i]; {ja atrasts elements, kurš ir lielāks par i-to M[i]:=M[j]; elentu, tos maina vietām} M[j]:= buf; end; end; for k : = 1 to n do write(' ',M[k]); w riteln(' ir veiktas ',a, ' iterācijas'); end. Konkrētā masīvā sakārtošanai neaugošā kārtībā bija nepieciešamas 190 iterācijas. Studentam ieteicams patstāvīgi pārbaudīt cik iterācijas nepieciešamas, lai masīvu sakārtotu nedilstošā kārtībā. B urbuļu metode. Tā ir viena no populārākajām masīvu sakārtošana metodēm un tās būtību raksturo algoritms, kura izpildes rezultātā vieglākie masīva elementi pakāpeniski uzpeld. Metodes īpatnība ir tā, ka tiek salīdzināti blakus esošie elementi un, ja nepieciešams, samainīti vietām. Šo algoritmu realizē programma: 41

43 for j := 1 to i-1 do a:=a+ 1 ; if M[j+1]>M[j] then buf:=m[j]; M[j]:=M[j+1]; M[j+1]:=buf; end; end; end; for k := 1 to n do write(' ',M[k]); writeln(' ir veiktas',a, ' iteracijas'); end. ņa} {salīdzina i-to elementu ar nepārbaudītās masīva daļas elementiem} {ja atrasts elements, kurš ir lielāks par i-to elementu, tos maina vietām} Programmas algoritms paredz ciklisku visu elementu no pēdējā līdz otram caurskati un pārvietošanu pa kreisi, ja kaimiņam ir mazāka vērtība. Pēc katra cikla soļa caurskatāmās masīva daļas garums samazinās par vienu. Dotā masīva sakārtošanai ar burbuļu metodi ir nepieciešams veikt 45 iterācijas. Abas iepriekš analizētās masīvu sakārtošanas metodes uzskatāmas par vienkāršām, bet arī maz efektīvām. Daudz efektīgāka ir metode, kuras pamatā ir masīva sadalīšanas princips atsevišķās daļās un elementu apmaiņa starp šīm daļām. Metodes algoritms ir visai sarežģīts un tādēļ attiecīgo programmu šī kursa apjomā nerekomendējam. Meklēšana nesakārtotā masīvā ir visai darbietilpīga, jo pamatojas uz visu elementu caurskati un salīdzināšanu ar uzdoto vērtību ( atslēgu ) līdz situācijai, kad salīdzināšanas rezultāts dod vērtību true. Apstrādājot liela apjoma informāciju parasti vispirms attiecīgo informācijas masīvu sakārto un pēc tam veic nepieciešamā elementa meklēšanu. Viena no meklēšanas efektīvām metodēm ir dalīšanas uz pusēm metode. Metodes ideja - sakārtotu masīvu dala uz pusēm un pēc masīva vidējā elementa vērtības nosaka, kurā masīva daļā atrodas meklējamais elements. Nevajadzīgo masīva daļu atmet un attiecīgo algoritmu atkārto ar atlikušo masīva daļu. Dalīšanu atkārto tik ilgi, līdz masīva daļa sastāvēs tikai no viena elementa. Šādu algoritmu realizē programma: program dala; const n=2 0 ; M: array [1..n] of byte =(20,20,19,19,19,18,17,17,12,12,11,10,9,9,5,5, 3, 3, 2, 1); v a r atsl,i,pirm,ped:byte; a: integer; rez: boolean; 42

44 writeln('dotais masīvs'); for i := 1 to n do write(' ',M[i]); writeln; write('ievadaam mekleessanas atsleegu '); readln(atsl); a:=0 ; pirm:=1 ; ped:=n; rez:=false; repeat i:=(pirm+ped) div 2 ; if M[i]=atsl then rez:=true else if M[i]>atsl then pirm:=i+1 else ped:=i-1 ; a:=a+ 1 ; until (rez) or (pirm>ped); if rez then W riteln(' mekleejamais elements atrodas ',i, '-jaa vietaa ') else writeln('masivaa nav mekleetaa elementa'); writeln('mekleessana veikta ar ', a, ' iteraacijaam') end Elementu izslēgšana un ievietošana masīvā. Tā kā masīva elementi izvietoti atmi ņas blakusesošās šūnās, tad nepieciešamības gadījum ā bez papildus grūtībām likvidēt vai arī pievienot elementus var tikai m asīva beigās. Visos citos gadījumos nāksies masīva elementus pārbīdīt. Sekojošā programma veic masīva elementu ar konkrētu vērtību meklēšanu, to izslēgšanu no masīva un masīva sabīdīšanu. p rogram izslegt; const n= 1 0 ; Mas: array [1..n] of byte=(15, 35, 27, 6, 3, 74, 42, 15, 43, 91); v a r x, j, i, m: byte; w riteln( sakotnejais masivs ); for i := 1 to n do write(' ',Mas[i]); writeln; w rite(' izsleedzamais elements '); readln(x); {izslēdzamais elements, cikla parametrs pārbīdot elementus, skaitītājs, masīva elementu skaits pēc to sabīdīšanas} 0; := 0; := n; := m repeat {caurskatīt visus masīva 43

45 i:=i+ 1; while Mas[i]=x do j:=i; repeat Mas[j]:=Mas[j+1]; j:= j+ 1; until j>=m; m :=m-1 ; end; until i>=m; for i:=m+1 to n do Mas[i]:=0; writeln('iegūtais masīvs ir'); for i:=1 to n do w rite(' ',Mas[i]); w riteln; end end. Paškontroles uzdevumi 4 Pk4-1. Dots programmas fragments: Noteikt katram masīvam: var elementus} [kamēr kārtējais masīva elements ir vienāds ar x, nobīdām atlikušos elementus par 1 pozīciju pa kreisi} {samazinām masīva elementu skaitu} {masīva astē ievieto nulli} {ja astes izvadīšana nav vajadzīga, tad ciklā n jānomaina ar m} A : array[1..30] of real; B : array[-5.. 5] of integer; C : array[11..25] of char; a) elementu skaitu; b) kā pirmajam un pēdējam elementam ar operatora readln palīdzību piešķirt vērtības? Pk4-2. Definēt masīvus, kuros var ierakstīt: a) 35 kontroldarba atzīmes; b) 2 0 automobiļu cenas; c) 50 atbildes (ar jā vai nē ) uz vienu jautājumu. Pk4-3. Pieņemot, ka masīvs Nauda ir definēts šādā veidā: var Nauda: array[1..3] of real; un tā elementu vērtības ir: Nauda[1] = 25,31 Nauda[2 ]= 43,27 Nauda[3] = 17,52, noteikt, kādas ir masīva Nauda elementu vērtības pēc doto programmas fragmentu izpildes? a) A:= 59.32; B:= A + Nauda[3]; Nauda[1]:= B; b) if Nauda[3] < Nauda[1] then Pag:= Nauda[3]; Nauda[3]:= Nauda[1]; Nauda[1]:= Pag; end; Pk4-4. Dots viendimensiju masīvs, kurā ir 7 elementi. Sastādīt programmu, kura aprēķina pirmo četru elementu summu un pēdējo 3 elementu reizinājumu. Pk4-5. Sastādīt programmu, kura ar gadījuma skaitļu ģeneratora palīdzību aizpilda masīvu A[1..10], tad piešķir masīva A vērtības masīvam B[1..10] un aizpilda masīvu C[1..10] ar masīva A un masīva B attiecīgo elementu summām. Pk4-6. Sastādīt programmu, kura lietotāja ievadīto vārdu izdrukā apgrieztā secībā. Piemēram: Students - stneduts. 44

46 Pk4-7. Sastadīt programmu, kura aizpilda masīvu A[1..20] tikai ar 0, 1 vai 2. Sakartot elementus masīva ta, lai sākuma būtu visas nulles, tad visi vieninieki, un beigas divnieki Funkcijas un procedūras Mūsdienu programmēšanas būtiska iezīme ir moduļveida principa izmantošana. Atbilstoši šim principam programmas atsevišķas daļas tiek veidotas ka neatkarīgi moduļi - apakšprogrammas. Tas ļauj izmantot divas būtiskas priekšrocības - konkrētu fragmentu var izmantot vairakkart ka viena, ta arī vairakas programmas un programmu var izveidot ka nelielu neatkarīgu fragmentu kopumu. Tadas programmas viegli lasīt, testēt un kompilēt. Apakšprogrammu pielietošana dod arī iespēju taupīt atmiņu. Apakšprogrammas izmantojamo mainīgo saglabašanai atmiņa tiek rezervēta atmiņas daļa tikai uz šīs apakšprogrammas izpildes laiku. Parēja laika ta ir atbrīvota. Pascal-a moduļveida princips tiek realizēts izmantojot procedūras un funkcijas. Kaut arī tam ir analoga nozīme un struktūra, tas atšķiras ar pielietošanas mērķi un veidu. Visas procedūras un funkcijas dalas divas grupas - iebūvētās un programmētaja sastādītās. Iebūvētas, jeb standarta procedūras un funkcij as ir daļa no programmēšanas valodas un var tikt izsauktas bez papildus apraksta. Biežak lietojamas standartfunkcijas, to argumentu un rezultatu tipi tika dotas tabula (8. lpp). Šo funkciju izmantošana būtiski atvieglo programista darbu. Diemžēl šadu funkciju skaits ir visai ierobežots un daudzas plaši lietojamas funkcijas nav atrodamas Pascal bibliotēka (kaut vai trigonometriska funkcija tgx). Šados gadījumos programmētajam nakas izstradat individualas nestandarta procedūras un funkcijas. Procedūru un funkciju struktūra tiek veidota ar saviem individualiem mainīgiem, kurus sauc par lokālajiem mainīgajiem. Lokalos mainīgos definē procedūru vai funkciju iekšienē, un tie ir izmantojami tikai tajas procedūras un funkcijas, kuras tie ir definēti. Parējie mainīgie (globālie mainīgie) tiek definēti programmas galvenaja daļa un tie ir izmantojami ka programmas galvenaja daļa, ta arī visas procedūras un funkcijas. Ikreiz, vēršoties pie procedūras vai funkcijas, lokalie mainīgie tiek izveidoti no jauna. Tas nozīmē, ka iepriekšējos aprēķinos iegūtas vērtības netiek saglabatas. Gadījumos, ja procedūra vai funkcija kadam no mainīgajam piešķirts tads pats nosaukums ka kadam no globalajiem mainīgajiem, procedūras vai funkcijas iekšienē tiek izmantots šis lokalais mainīgais. Procedūra ir neatkarīga īpaša veida noformēta programmas daļa, kurai tiek piešķirts atsevišķs vards. Šim vardam jabūt unikalam, tas nozīmē, ka to nedrīkst lietot citu programmas procedūru vai mainīgo apzīmēšanai. Procedūra var tikt daudzkart pēc tas varda izsaukta dažadas programmas vietas konkrētu darbību izpildei. Procedūru nevar lietot kā operandu izteiksm ē. Uzrakstot šo vardu programmas teksta, tiek izsaukta jeb aktivizēta attiecīga procedūra. Līdz ar procedūras izsaukšanu sakas tas izpilde - tiek izpildīti procedūra ietilpstošie operatori. Pēc pēdēja operatora izpildes, tiek turpinata programmas izpilde no tas vietu, kura tika izsaukta procedūra. Ja ir nepieciešams nodot informaciju no kadas programmas daļas uz procedūru, izmanto vienu vai vairakus parametrus. Tos norada iekavas aiz procedūras nosaukuma. Šo parametru vērtības janorada izsaucot procedūru. Procedūras visparīgais pieraksts analogs programmas pierakstam. To veido nosaukums, apraksta un izpildama daļa. P rocedūrām un funkcijām (atšķirība no program 45

47 mas) nosaukum s ir obligāta sastāvdaļa. Tas sastāv no rezervētā vārda procedure vai function un to identifikatora (vārda), aiz kura apaļajās iekavās ieslēgts formālo parametru saraksts ar katra parametra tipa norādi. Piemēram: procedure pakape(a: real, n:integer). Izpildāmā daļa tiek ieslēgta operatoru iekavās un end, pie kam pēc end ir jālieto semikols nevis punkts kā tas ir programmas beigās. Lai vērstos pie procedūras, tiek izmantots procedūras izsaukšanas operators. Tas sastāv no procedūras vārda un faktisko parametru saraksta apaļajās iekavās. Parametrus vienu no otra atdala ar komatu. P aram etru saraksts nav obligāts. Informācijas nodošana procedūrai realizējas trīs veidos: 1) ja uz procedūru nav nepieciešams nodot informāciju, tad definējot procedūru, aiz tās nosaukuma mainīgos nenorāda: procedure <vārds>; 2 ) ja uz procedūru ir nepieciešams nodot tikai mainīgā vērtību (šī mainīgā vērtību procedūra neizmaina), tad aiz procedūras nosaukuma iekavās j ānorāda jauns lokāls m ainīgais un tā tips, kuram tiks piešķirta mainīgā vērtība: procedure <vārds> (<mainīgais>:<tips>); 3) ja procedūrai jānodod pats mainīgais, ļaujot procedūras operatoriem m ainīt šī m ainīgā vērtību, tad aiz procedūras nosaukuma iekavās jāraksta var un jānorāda jauns lokāls mainīgais, kuram tiks piešķirta galvenajā programmas daļā izmantotā mainīgā vērtība: procedure <vārds> ( v a r <mainīgais>:<tips>). Pēc procedūras izpildes nodotajam mainīgajam tiks piešķirta procedūras mainīgā vērtība. Paskaidrosim to ar piemēru: Jānis (mainīgais ar vērtību, kuru nodod procedūrai) aizbrauc uz ārzemēm (procedūra) mācīties. Tur Jāni jaunie draugi sauc par Džoniju (mainīgais iegūst jaunu pagaidu nosaukumu, pēc kura procedūrā tiek veikta mainīgā vērtību maiņa), bet atgriežoties mājās viņu atkal sauc par Jāni, un viss, ko viņš ir iemācījies ārzemēs, ir Jāņa rīcībā (programmas galvenās daļas mainīgajam saglabājas vērtība, kas iegūta procedūras darbības gaitā). Funkcija līdzīgi kā procedūra veido atsevišķu noslēgtu programmas daļu, bet atšķiras no pēdējās ar to, ka funkcijas darbības rezultāts galvenajai programmas daļai tiek nodots kā mainīgais. Tādēļ, definējot funkciju, ir jānosaka, kāds būs tās darbības gala rezultāta tips. function <vārds> (<mainīgie>): <funkcijas tips>; Piem ērs. Sastādīsim programmu, kura dod iespēju izveidot tabulu collu pārveidošanai centimetros. Tabulas izveidošanai izmantosim vienkāršotu procedūra (bez parametriem) horizontalas līnijas izveidei. p rogram col_cm; var col: integer; cm: real; 46

48 {horizontalas līnijas veidošanas procedū- ra} {pamatprogrammas sakums} {novelk augšējo līniju} {tabulas galva} {izveido divas kolonnas ar desmit vērtī- bam katra} {tabulu noslēdzoša līnija} procedure linija ; var i: integer; for i:= 1 to 2 0 do w rite (' -'); w riteln; end; linija; w riteln(' collas cm '); for col:= 1 to 1 0 do cm:= 2.54*col; writeln(' ', col: 8, ' ', cm:9:3, ' '); end; linija end. Vēlams programmu papildinat ta, lai katru colla - centimetri pari atdalītu horizontala līnija. Minēta piemēra uzskatami redzama viena no procedūras priekšrocībam - ērta līnijas izmēru un to veidojošo simbolu nomaiņa. Attiecīgie labojumi jaizdara tikai vienu reizi konkrētaj a procedūra, bet ne vairakkart programma. Sastadīsim procedūru, ar kuru nomainot iepriekšēja piemēra izmantoto, iegūstam iespēju izveidot dažada garuma horizontalas līnijas, pie kam šīs līnijas veidojot no atšķirīgiem simboliem. procedure linija (gar:integer; {gar - līnijas garums simbolos, simb - simb :char) ; simboli no kuriem veidojas līnija} var i: integer; for i:= 1 to gar do write( simb); {Izmantojot galvenaj a programma šos trīs w riteln; end; neatkarīgos procedūras izsaukumus, iegūslinija (2 0, ' _ '); tam trīs atšķirīgas līnijas} linija ( 1 0, ' # '); linija (15, ' o '); Daudzu uzdevumu algoritmos nakas veikt skaitļu kapinašanu vesela pozitīva skaitļa pakapē (Pascal- a nav šadas standartoperacijas). Kapinašanu pozitīva pakapē iespējams veikt izmantojot procedūru: procedure pakape (x: real; n:byte; v a r rez: real); var i: integer; rez:= 1 : for i:= 1 to n do rez:= rez*i; end; v a r p1,p2,p3: real; {x - skaitlis, kurš tiek kapinats n - taja pakapē, rezultats būs parametrs - mainīgais rez} {pamatprogramma} 47

49 pakape(2, 1 0,p 1); {mainīgajiem p1, p2 un p3 tiek piešķirtas pakape(2,2 0,p2 ); vērtības atbilstoši pakāpēm 1 0 pakape(2,30,p3);, 20 un 30} writeln('210 = ', p1: 4 ); {globālie mainīgie } writeln('220 = ', p2: 7 ); writeln('230 = ', 31: 10) end. Ņemot vērā to, ka šī procedūra pamatprogrammai nodod tikai vienu rezultātu, šo procedūru var noformēt arī kā funkciju. Tas izdarāms sekojošā veidā: function pak (x:real; n:byte): real; {x - skaitlis, kurš tiek kāpināts n - tajā i, p: integer; pakāpē, rezultāts būs identifikatorā pak} p:= 1 : for i:= 1 to n do p:=p*i; pak:=p; end; v a r x,n,y: real; {pamatprogramma} w riteln(' ievadiet kāpināmo skaitli un kāpinātāju'); readln(x,n); {mainīgajam y tiek piešķirta attiecīgā y:= pak(x,n); funkcijas vērtība} w riteln (x:4:2, ' pakape ', n:2,' ir ',y) end. Piem ers. Definēt skaitļa n faktoriāla (n!) funkciju. {no programmas galvenās daļas uz procedūru tiek nodoti divi mainīgie - mafunction fakt(n): real; fak,i: integer; fak:= 1 ; for i:= 1 to n do fak:= fak*i; fakt:=fak; end; Piem ērs. Sastādīsim programmu, kura aizpilda masīvus A[1..n] un B[1..m] ar gadījum a skaitļiem, saskaita katra masīva elementu vērtības un nosaka, kura masīva elementu summa ir lielāka. Sastādot šo programmu, izmantosim procedūras un funkcijas, kurām no programmas galvenās daļas ir jānodod viens mainīgais (masīvs A vai B) un viena mainīgā vērtība (elementu skaits n vai m). program salidzini_summu; uses Crt; var A,B:array[1..20] of integer; i,n,m:integer; procedure mas_uzpilde (var x: array of integer; y:integer); for i : = 1 to y do {procedūra, kura aizpilda viendimensiju masīvu ar gadījuma skaitļiem} 48

50 end; x[i]:= random (1 0 )+ 1 ; procedure mas_izvade(var x: array of integer; y: integer); for i:= 1 to y do write(x[i]:4); writeln; end; function summa(var x : array of integer; y: integer): integer; var sum: integer; sum:=0 ; for i := 1 to y do sum:= sum+x[i]; summa:=sum; end; ClrScr; random ize; write('ievadi masiva A elementu skaitu n= '); readln (n); mas_aizpilde (A,n); mas_izvade(a,n); w riteln ('Masiva A elementu summa ir:', Summa(A,n)); w rite ('Ievadi masiva B elementu skaitu: '); readln(m); Mas_aizpilde (B,m); Mas_izvade (B,m); writeln ('Masiva B elementu summa ir: ', Summa(B,m)); if summa (A,n) > summa (B,m) then sīvs un ta elementu skaits.} {procedūra, kura izvada viendimensiju masīva elementu vērtības: no programmas galvenas daļas uz procedūru tiek nodoti divi mainīgie - masīvs un ta elem entu skaits} {viendimensiju masīva elementu vērtību aprēķina funkcija } {no programmas galvenas daļas uz funkciju tiek nodoti divi mainīgie - masīvs un ta elementu skaits, bet pēc funkcijas izpildes programmas galvenajai daļai tiek nodots vesels skaitlis (sum m a) - funkcijas lokalais mainīgais, kura vērtība nav pieejama programmas galvenajai daļai} {sākas pam atprogram m a} { izvēlas parametra n vērtību} {izsauc procedūru, nododot tai divus mainīgos -masīvu A nodod ka mainīgo ar vērtību, bet masīva elementu skaitu n nodod tikai ka mainīga vērtību. Masīva A vērtības piešķirs procedūras mainīgajam x, bet masīva elementu skaita n vērtību piešķirs mainīgajam y. Pēc procedūras izpildes masīva x vērtības tiks piešķirtas masīvam A, bet mainīga n vērtība netiks izmainīta. {izsauc procedūru, kas izvada uz ekrana masīva A vērtības} {izsauc funkciju summa, kas atgriež masīva A elementu summu, kuru writeln operators izvada uz monitora ekrana.} {analogas manipulacijas tiek veiktas arī ar masīvu B} {salīdzina masīvu elementu summas (funkcijas summa(a,n) un summa(b,m)} 49

51 writeln('m asiva A elementu summa ir lielaka par masiva B elementu summu') else if summa (A,n)<Summa (B,m) then writeln('m asiva A elementu summa ir mazaka par masiva B elementu summu') else writeln('m asiva A elementu summa ir vienada ar masiva B elementu summu') end. Paškontroles uzdevumi 5 Pk5-1. Kuri dotajā programmā ir lokālie un kuri globālie mainīgie? program druka; uses crt; var j: integer; A,B: char; Burti: array[1..100] o f char; procedure Rekins(Skaits: integer); v a r i,burts: char; Burts:= '*'; for i:=a to B do if Burti[Ord(i)] > Burts then Skaits:= Skaits + 1; writeln('skaits = ', Skaits); end; C lrscr; random ize; A:='A'; B:='z'; for j := 1 to do Burti[j]:= chr(random(35)+30); Rekins(0); end. Pk5-2. Kas tiks izvadīts monitora ekrānā pēc dotās programmas izpildes? p rogram Druka; uses crt; var A,B: char; procedure Raksta(A: integer); const B= 5; writeln(a:3, B:3); end; procedure Skaita; var A: char; A:= B; B:= '*'; writeln(a: 3, B:3); end; 50

52 C lrscr; A:= 'a'; B:= 'b'; Raksta(7); writeln(a:3, B:3); Skaita; writeln(a:3, B:3); readln; end. Pk5-3. Atrast kļūdas programmas fragmentos un paskaidrot tas. a) function Liels(A,B: integer): integer; if A> B then Liels:= A; end; b) function Summa(Skaits: integer): integer; var L: integer; Summa:= 0; for L:=1 to Skaits do Summa:= Summa + L; end; Pk5-4. Noteikt summas 1!+2!+3!+4!+5! vērtību. Pk5-5. Noteikt summas 1/a +1/a2 +1/a3 +1/a /an vērtību patvaļīgai naturala skaitļa n vērtībai. Pk5-6. Izvadīt tabulas veidā summu 1 +1/2+1/3 +1/ /n 1 + 1/22 + 1/32 +1/ /n2 1/32 + 1/52 +1/ /(2n+1) 2 1! +2!/(1+ 1/2 ) n! /( / /n) vērtības naturala skaitļa n vērtībam intervala (5, 10). Pk5-7. Izveidot funkcijas y = 3x5 + 2 x3-7 x2 + x - 8 vērtību tabulu intervala (1,15) ar soli 2. Pk5-8. Izveidot dotas programmas, kura nosaka ar virsotņu koordinatēm uzdota četrstū ra ABCD laukum u, komentarus. Papildinat programmu ta, lai tiktu izvadīti atsevišķu trīsstūru laukumi. Parbaudīt risinajumu izvēloties citu četrstūra dalījumu. Parveidot programmu ta, lai tiktu izmantotas funkcija un procedūra. program laukums4stur; uses crt; v a r xa,ya,xb,yb,xc,yc,xd,yd:integer; a,b,c,d,e,ab,bc,cd,ad,db,l,p1,p2,t1,t2:real; clrscr; w riteln (Ievadi koordinates xa, ya, xb, yb, xc, yc, xd, yd '); writeln; write( write( write( write( write( write( xa= '); readln(xa); ya= '); readln(ya); xb= '); readln(xb); yb= '); readln(yb); xc= '); readln(xc); xc= '); readln(yc); 51

53 write(' xd= '); readln(xd); write(' yd= '); readln(yd); AB:=sqrt(sqr(xB-xA)+sqr(yB-yA)); BC:=sqrt(sqr(xC-xB)+sqr(yC-yB)); CD:=sqrt(sqr(xD-xC)+sqr(yD-yC)); AD:=sqrt(sqr(xD-xA)+sqr(yD-yA)); DB:=sqrt(sqr(xB-xD)+sqr(yB-yD)); p1:=(ab+db+ad)/2; T1:=sqrt(p 1*(p1 -AB)*(p1 -DB)*(p1 -AD)); p2:=(db+cd+bc)/2; T2:=sqrt(p2*(p2-DB)*(p2-CD)*(p2-BC)); L:=(T1+T2); writeln; write('jusu ievadita 4-stura laukums ir ',L:4:2); end. Pk5-9. Noteikt vienādojuma f(x)= 0 reālās saknes lietotāja izvēlētā intervālā (a, b). Izveidot programmas komentāru. Veikt rezultātu pārbaudi. p rogram saknes; var a,b,c,eps,fa,fc: real; function f(x:real): real; f:=sqr(x) - 2 ; end; read(a,b,eps); fa:= f(a); while abs(b-a) > eps do c:= (a+b)/2 ; fc:= f(c); if fa*f c< 0 then b:= c else a:= c; fa:= f(c); end; end; write(c) ;end. Pk5-10. Noteikt laukumu figūrai, kuru ierobežo līkne y(x), abscisu ass un taisnes x=a un x=b ar uzdotu precizitāti p. Izveidot programmas komentāru. program laukums_y; label 1 ; v a r a,b,s1,s2,x,d,p: real; n: integer; function y(x: real): real; y:= Sqrt (100-Sqr(8-x))-6; 52

54 end; write('apaksseejaa robezza a= '); readln(a); write(' augsseejaa robezza b= '); readln(b); w rite(' precizitaate p= '); readln(p); n:= 1 ; s2 := 0 ; 1 : n:= n+ 1 ; x:= a; d:= (b-a)/n; s 1 := 0 ; while x < (b+d/2 ) do s 1 := s 1+y(x); x:= x+d; end; s 1 := s 1 *d; if abs(((s1-s2 )* )/s 1) > p then s2 := s 1 ; goto 1 end; write(' laukums s='); w riteln(s 1); w rite(' dalijumu skaits n= '); w riteln (n); end. Pk5-11. Noteikt vienadojuma F(x) = 0 saknes un aprēķinat liknes F(x) un abscisu ass ierobežoto laukum a daļu gadījuma, ja F(x)=x Pielikumi Paškontroles uzdevumu atbildes. Pk1-1. Gadījuma, ja d=11 un e=3, iegūstam a) 3.67 b) 3 c) 2. Pk1-2. a) v= E+00 b) y izmainas p a r E+03 Pk1-3. Uzdevuma atrisinašanai ieteicams izmantot skaitļu dalīšanu mod ar 7 un ar 3. Pk1-4. Veicot uzdevumu svarīgi atcerēties, ka lenķu vērtības no gradiem japarvērš radianos un ka trigonometriskas funkcijas tgx Pascal standartfunkciju bibliotēka nav un tas aprēķins jaorganizē programmētajam. Pk1-5. Aprēķinu veikšanai jaizmanto sakarības: rinķa līnijas garums - 2nr, rinķa laukums - n r2, kur r ir rinķa radiuss. Pk1-6. D iennaktī ir sekundes. Svarīgi ņemt vēra, ka iegūtais skaitlis parsniedz integer tipa skaitļu diapozonu. Pk1-7. Iegūstam simbolus 9,,, k 53

55 Pk1-9. Izmantojam kvadrātvienādojuma sakņu noteikšanas formulas. Pārbaudi veicam ievietojot iegūtās sakņu vērtības vienādojumā un nosakot cik precīzi tās apmierina vienādojumu. Pk1-11. Trīsciparu skaitļa pirmo ciparu varam noteikt veicot dalīšanu div ar 100, otro ciparu veicot ši dalījuma atlikuma dalīšanu div ar 1 0. Pk2-1. a) 1; b) 2; c) 0. Pk2-2. Pk2-3. a) trūkst operatoru un end; un nepareizi pierakstīta vērtību salīdzināšana. b) lieks ir semikols pirms else un trūkst iekavu salīdzināšanā. if (A<>0) and (sqr(a)<25) then A:=-A else A:=1; Pk2-4. var sk:byte; sk:=random(1 0 )+ 1; case sk of 1 : write('viens'); 2 : write('divi'); 1 0 :write('desmit'); end. Pk2-5. Jāizmanto operātori: Pk2-6. D:= sqr(b)-4*a*c; if D>0 then x1:= (b+sqrt(d))/2*a; x2:= (b-sqrt(d))/2*a; write('ir divas realas saknes : x 1=', x 1, ' x2 =',x2 ); end else if D=0 then x 1 := b/2 *a; write('ir viena reala sakne : x=', x 1); end else write('realu saknu nav '); X:= 3*sin(a*pi/180); if x>3 then write('y= ',2*x+5) else if x = 1 then write('funkcija nav defineta') else write('y= ',2*x-3/(x-1)); 54

56 Pk2-7. Jāizmanto operātors: if ((a+b)>c) and ((a+c)>b) and ((c+b)>a) then write('var uzkonstruet trijsturi') else write('nevar uzkonstruet trijsturi'). Pk3-1. a) b) 1; 99 2; 98 3; 97 4; 96 5; 95 c) ** 6 ** 7 ** 8 ** 9 ** 1 0 d) Pk3-2. a) for i:=1 to 5 do writeln(i); b) Summa:=0; for i : = 1 to 1 0 do w riteln (Summa:15); read(skaitlis); Summa:=Summa+Skaitlis; Pk3-3. for i:=3 to 10 do writeln(13-i:13-i); end; Pk3-4. Summa:=0; for i:=4 downto 1 do writeln('*':15-i); Summa:=Summa+(5 -i); writeln(summa); end; Pk3-5. Var izmantot operātorus: sum:=0; for i:= a to b do sum:=sum+sqr(i); write(sum); Pk3-6. Var izmantot operātorus: r:=1; for i:= a to b do r:=r*i; write(r); Svarīgi izsekot tam, lai reizinājums r nepārsniegtu tā definīcijas apgabalu. Pk3-7. Var izmantot operātorus: b:=0; for i:= 1 to do a:= random(n); Pk3-8. Pk3-9. if a>b then b:=a; end; write(b); Var izmantot operātorus: for i:= 1 to do a:= random(n); if (a<=n/3) then n1:=n1+1; if (a>n/3) and (a<=2*n/3) then n2:=n2+1 else n3:=n3+1 end; write('n1=',n1, ' n2=',n2, ' n3=',n3) Var izmantot operātorus: s:=0; for i:= 1 to n do if (i mod 2 = 0 ) then s:=-+ 1/i; 55

57 Pk3-14. Pk3-15. Pk3-16. else s:=s+ 1/i end; write('n1=',n1, ' n2=',n2, ' n3=',n3); Var izmantot operātorus: read(n); for i:= 1 to G do N:=N+N*P/100; write('pec G gadiem summa summa bus ',N); Var izmantot operātorus: i:= 1 ; a:= 1 ; s:=a; while (a>p) do i:=i+ 1 ; a:= 1/i; s:=s+a; end; Var izmantot operātorus: p:=5; C:=200; n:=0; while p<c do C:=C-p; n:=n+1; p:=p*1.2; end; write(n); Pk4-1. a) masīva A elementu skaits ir 30, masīva B elementu skaits ir 11, Masīva C elementu skaits ir 15. b) readln(a[1]); readln(a[30]); readln(b[-5]); readln(b[5]); readln(c[11]); readln(c[25]). Pk4-2. KONTR: a rr a y [1..35]of byte; AUTO: array[1..20]of real; A TBILD E:array[1..50]of char. Pk4-3. a) Nauda[1] = 76,84 Nauda[2] = 43,27 Nauda[3] = 17,52 56

58 Nauda[1] = 17,52 Nauda[2] = 43,27 Nauda[3] = 25,31 Pk4-4. Varam izmantot operātorus: for i:=1 to 4 do s:= s+m[i]; for j:=5 to 7 do r:=r*a[j]; Pk4-5. Varam izmantot operātorus: for i:= 1 to n do A[i]:=random(n); B[i]:=A[i]; C[i]:=A[i] + B[i]:end; Pk4-6. var A:array[1..n] of char; B: array[1..n] of char; for i:= 1 to n do read (A[i]); j:=n+1-i; B[j]:=A[i];end; for i:= 1 to n do write(a[i]); for i:= 1 to n do write(b[i]);end. Pk a b b * a * Pk5-4. Summa iegūstama ar for operātoru ar parametru vērtībām a=1 un b=5 un izmantojot funkciju skaitļa faktoriāla aprēķināšanai. Pk5-5. Līdzīgi kā iepriekšējā uzdevumā ar operātora forpalīdzību tiek aprēķināta summa, kuras saskaitāmie ir funkcijas 1/an vērtības skaitļiem n no 1 līdz izvēlētajai vērtībai. Pk5-6. Katra no summām noformējama funkcijas veidā. Tabulas izveidošanai ērti izmantot operātoru for. Pk5-7. Ieteicams izmantot pakāpes funkciju xn Funkcija y tiek noteikta pie nosacījumiem x=1, x=3 u.t.t. Pk5-11 Vienādojuma saknes ir xj= -4 un x2=4, bet laukums - 84, Darbs ar programmu Palaižot Turbo Pascal 7.0 (fails turbo, exe), atveras ekrāns, kura augšējā daļā izvietota komandu rinda. Šalā rindā ietilpst File (darbs ar failiem), kurā iekļautas komandas: New, Open, Save, Save as, Save all, Change dir, Printer setup, Print, Dos shell, Exit. Exit (teksta redaktors) - iekļautas komanda: Undo, Redo, Cut, Paste, Clear, Show clipboard Search (teksta meklēšana un aizstāvēšana) - komandas: Find Replace, Search again, Go to line number Run (programmas izpilde) - Run, Step Over (izpildot programmu pa soļiem), T race into (izpildīt pa operatoriem), Go to cursor (izpildīt līdz rindai, kurā atrodas kursors), Program reset (pārtraukt skaņošanu, atbrīvot atmiņu, aizvērt visus failus, kuri tika izmantoti programmā), P a ram e trs (uzdot komandu rindas argumentus). Compile (programmas kompilācija) un tās komandas Compile, M ake, Build, Inform ation. D ebug (programmas skaņošana) - B reakpoints, Call stack, W atch, O utput (rezultātu logs), U ser screen, Evaluate/modify Tools (komandu izpilde neizejot no Pascal vides) O ptions (kompilatora parametru uzstādījums) 57

59 Windows (operācijas ar logiem) Help (informācijas iegūšana). Program m as ievade un korekcija. Ekrāna darba zonā (pamatlaukumā) tiek rakstīta programma. Svarīgi ņemt vērā, ka vienā ekrāna logā var rakstīt tikai vienu programmu. Kopumā ir 20 logi. Tie aizveras ar peles klikšķi uz izslēgšanas pogas ekrāna augšējā kreisā stūrī (maza - zaļa). Pulsējošais kursors darba zonā norāda ekrāna vietu, kurā tiks ievadīts programmas teksts. Lai dzēstu kļūdaini ievadītu simbolu, kursors jānovieto zem šī simbola un jānospiež taustiņš Delete vai arī kursors jānovieto pa labi no attiecīgā simbola un jānospiež taustiņš Back Space. Uz nākamo rindu kursors tiek pārcelts nospiežot Enter. S aglabāšana uz diska.uzrakstīto programmu pirms tās izpildīšanas ieteicams saglabāt uz diska. Šai nolūkā tiek atvērta pozicija File, aktivizēta komanda Save vai Save as, ievadīts programmas nosaukums un nospiests E nter. Tā rezultātā fails tiks saglabāts kārtējā kataloga vinčesterā. Gadījumos, ja fails jāsaglabā kādā citā katalogā, pirms ieraksta, izmantojot komandu Change dir (no File) jāsameklē nepieciešamais katalogs. P rogram m as izpilde. Šai nolūkā tiek aktivizēta komanda R un. Gadījumos, kas programmā pielaistas sintaktiskas kļūdas, Turbo Pascal translators norādīs uz to atrašanās vietu, un dos atbilstošu paziņojumu (Error...). pēc tam, kad kļūda ir novērsta un programma saglabāta uz diska, to var palaist atkārtoti. Apskatīt programmas darba rezultātus varam ieslēdzot komandu User screen (no Debug). Nospiežot jebkuru klaviatūras taustiņu, atgriežamies pie programmas teksta. Varam izmantot arī komandu O utput (no Debug), kura atvērs risinājuma rezultātu izvades logu. Lai atstātu šo logu atvērtu visā programmas izpildes laikā jārealizē komandu C ascade (no Window). Beidzot darbu Pascal vidē jānospiež komandpoga Exit (no File). Program m as skaņošana Programmas skaņošanas procesā tiek atklātas un novērstas kļūdas, kuras ieviesušās visos programmas sagatavošanas etapos. Pēc sava rakstura kļūdas iedalāmas trīs grupās: sintaktiskās kļūdas - tās kuras rodas Pascal valodas sintakses likuma neievērošanas dēļ. Šai grupā tipiskas kļūdas ir: punkturācijas zīmju trūkums; apraksta daļā nedefinētu konstanšu, mainīgo vai masīvu izmantošana programmas operatora daļā; nepareizu datu piekārtošana u.c. šāda tipa kļūdas tiek atrastas kompilācijas procesā. semantiskās kļūdas - saistītas ar Pascal valodas semantisko likumu neievērošanu (dalīšana ar nulli, mēģinājums izvilkt sakni no negatīva skaitļa u.c.). Šī tipa kļūdas tiek atklātas programmas izpildes gaitā (etapā). Tā rezultātā programmas izpilde tiek pārtraukta, kursors nostājas kļūdas vietā un uz ekrāna tiek izvadīts paziņojums: Run tim e erro r <N r> at < x: y>, kur Nr. - kļūdas numurs, x:y - kļūdas adrese. algoritmiskās kļūdas - rodas nepareizu algoritmisku konstrukciju veido šanas rezultātā. Šī veida kļūdas ne vienmēr ir vienkārši atrodamas. 58

60 Pascalā nav automātiska loģisko kļūdu meklētāja. Šādu kļūdu atklāšanai tiek rekomendēts veikt atsevišķu apakšprogrammas skaņošanu sākot ar zemāko hierarhijas līmeni. Programmas darba rezultātus obligāti jāpārbauda ar testa uzdevumiem, kuru rezultāti ir zināmi. Turbo Pascal integrētajā rīku aprīkojumā atrodams iebūvēts skaņotājs (Debugger), ar kura palīdzību var izsekot programmu izpildei. Skaņotājs dod iespēju: veikt programmas skaņošanu un trasēšanu pa soļiem; izpildīt programmu līdz noteiktai vietai; realizēt programmas pārstartēšanu; caurskatīt un modificēt mainīgos. Skaņošana un trasēšana pa soļiem. Tiek aktivizēta komanda Step Over (no Run). Lai veiktu programmas trasēšanu, jāizmanto komanda Trace into (no Run). Atšķirība starp abiem šiem procesiem (skaņošanu un trasēšanu) ir tā, ka veicot programmas skaņošanu pa soļiem nav iespējams izsekot to operatoru izpildei, kuri iekļauti procedūrās un funkcijās. Toties veicot trasēšanu, tāda iespēja ir. Program m as izpilde līdz noteiktai vietai. Gadījumos, kad nepieciešams noskaņot tikai daļu no programmas, var izmantot iespēju apturēt programmas izpildi noteiktā vietā. Lai to veiktu ir nepieciešams: novietot kursoru uz rindas, līdz kurai jāizpilda programma; aktivizēt komandu Go to cursor (no Run). Fiksēt programmas izpildes pieturpunktu (B reakpoint) iespējams vēl vairākos veidos: ar komandu Toggle B reakpoint (no Local menu), Breakpoint (no Debug), aktivizējot komandu Add breakpoint (no Debug) un nospiežot Enter. Lai likvidētu apstāšanās punktu, pietiek nospiest klaviatūras taustiņu kombināciju C trl+f8. Program m as pārstartēšana. Lai pārstartētu programmu pirms tās darbības beigām, pietiek aktivizēt komandu Program reset (no Run) vai nospiest kombināciju Ctrl+F2. Tā rezultātā programma tiks izpildīta no sākuma. M ainīgo caurskate un m odifikācija. Nepieciešams izpildīt programmu līdz konkrētai vietai, aktivizējot komandu W atch (no Debug). Tā rezultātā atvērsies logs Watches. Nospiežot Ctrl+F7 vai taustiņu Insert, atvērsies logs A dd W atch. Pēc tam nepieciešams ievadīt mainīgā nosaukumu un nospiest Enter. Logā Watches parādīsies mainīgā nosaukums un tekošā vērtība. Mainīgā dzēšana logā Watches notiek nospiežot taustiņu Del vai Ctrl+Y. Gadījumā, ja vēlamies nomainīt mainīgā vērtību, nepieciešams izpildīt programmu līdz pieturpunktam, aktivizēt komandu Eveluate /modify (no Debug). Atvērsies dialoga logs Evaluate and Modify. Laukā Expression jāievada mainīgā nosaukums, laukā New Value mainīgā jaunā vērtība un ar peles kreiso taustiņu nospiest taustiņu Modify. Tā rezultātā laukā Result parādīsies mainīgā jaunā vērtība. Pēc tam nospiežam taustiņu E valuate un taustiņu Cancel. Izdarīto manipulāciju rezultātā programmas izpildi varam turpināt jau ar jauno mainīgā vērtību. Paziņojumu kodi par kļūdām Turbo Pascal valodas programmās Iepazīsimies ar tipiskākajiem paziņosumiem par kļūdām, ar kurām nākas sastapties 59

61 programmu kompilācijas un izpildes gaitā. Paziņojum i p ar kom pilācijas kļūdām. 1. O ut of mem ory (iziets ārpus atmiņas robežām). Kļūda parādās gadījumā, ja kompilātors ir izmantojis visu tam atvēlēto atmiņu. To var novērst izmainot apgabala Destination no M emory vērtību. 2. Identifier expected (Tiek gaidīts identifikātors). Šai vietā jāatrodas identifikātoram. 3. U nknow n identifier (Nepazīstams identifikators). 4. D uplicate identifier (identifikatora atkārtojums). 5. Syntax e rro r (Sintaktiska kļūda). Tekstā atrasts nepieļaujams simbols. Iespējams, ka trūkst simbols - iekava, vai nepareizi uzrakstīts identifikators vai operators. 8. String constant exceeds line (Teksta virkne konstante pārsniedz atļauto rindiņas garumu). 21. E rro r in type (kļūda tipa noteikšanā). Tipa noteikšana nevar sākties ar šo simbolu. 26. Type m ism atch (Tipu neatbilstība). Paziņojuma cēloņi var būt: mainīgā un izteiksmes tipu neatbilstība piešķires operātorā; faktisko un formālo parametru tipu neatbilstība vēršoties pie procedūrām vai funkcijām; izteikmju operandu tipu neatbilstība. 30. Integer constant expected (Tiek prasīta vesela tipa konstante) 31. B EG IN expected (Nepieciešams operators BEGIN) Liktenīgās kļūdas Division to zero (Dalīšana ar nulli). 205 Floating point overflow (Pārpildīšana veicot operācijas ar peldošu punktu) Invalid floating point operation (Neiespējama darbība ar reālu skaitli). Kļūdas iemesli: reālais skaitlis, kurš tiek nodots funkcijai Trunc vai Round nevar tikt pārveidots par veselu tipa Longint pieļaujamā intervāla robežās; funkcijas sqrt arguments ir negatīvs; funkcijas ln arguments ir negat īvs vai nulle A rithm etic overflow e rro r (Kļūda veicot matemātisku operāciju). Šāda kļūda rodas, piemēram, ja izteiksmes vērtība pārsniedz definēto vērtību diapozonu. Literatūra. G SPALIS. Turbo Pascal for Windows ikvienam. Rīga, Datorzinību Centrs , 126 lpp. L. KUZMINA, J. KUZMINS. Pascal valoda skolēniem un skolotājiem. Lielvārds. 2001, 96 lpp. Ю.А. АЛЯЕВ, О.А. КОЗЛОВ. Алгоритмизация и языки программирования.москва, Финансы и статистика, 2002, 319 стр. Г.РАПАКОВ, С. РЖЕУЦКАЯ. Turbo Pascal для студентов и школьников. БХВ - Петербург, 2002, 349 стр. С. А. НЕМНЮГИН. Turbo Pascal. Питер, 2003, 491 стр. 60

62 2. UNIVERSĀLĀ M ATEM ĀTISK O APRĒĶ INU SISTĒM A M ATH CAD 2.1. Ievads Kopš pagājušā gadsimta 80-tajiem gadiem plašu popularitāti ieguvusi integrētā sistēma matemātisko aprēķinu automatizēšanai Mathcad. Tā izstrādāta firmā Mathcad Soft (ASV). Šīs sistēmas ietvaros matemātiskie risinājumi tiek veikti izmantojot pierastās m temātiskās formulas un simbolus. Ar Mathcad iespējams gan kvalitatīvi sagatavot publikāciju, grāmatu tekstus izmantojot pašas sarežģītākās matemātiskās formulas un noformēt rezultātus nevainojamā grafiskā veidā, gan veikt vissarežģītākos matemātiskos aprēķinus kā skaitliskā, tā arī simbolu veidā. Sistēma Mathcad līdzīgi citām programatūrām nepārtraukti attīstās un pilnveidojas, iegūstot plašu versiju klāstu. Plaši pazīstama un būtiski atšķirīga versija ir Mathcad 7.0 PRO. Tūlīt pēc palaišanas sistēma ir gatava radīt dokumentu ar nepieciešamajiem aprēķiniem. Lietotāja interfeiss (Mathcad grafiskās čaulas līdzekļu kopa, kura nodrošina ērtu sistēmas vadību kā ar tastatūras tā peles palīdzību) izveidots tā, ka lietotājs, kuram ir iemaņas darbam ar Windows, uzreiz var uzsākt darbu ar Mathcad. Nospiežot divas reizes uz peles kreisā taustiņa, atveras paketes nosaukums, kurš saglabājas uz ekrāna visu programmas automātiskās ielādēšanās laiku. Pēc brīža nosaukums nozūd un atveras Mathcad logs - balta lapa, kurā tiek veiktas visas darbam nepieciešamās operācijas, t.i., ievadītas aprēķiniem nepieciešamās izteiksmes un komandas, funkcijas, grafiki un tekstiski paskaidrojumi un kurā būs redzami iegūtie rezultāti Mathcad galvenais izveles logs P M athcad [U n title d : 1 ] S U S ļj^j FHe Edīt View Insert Format Tools ymbolics ^īndovv Help _ n1 X 100% v Q Normai v Arial v v B I U = J i = X* 4 ^ [:::] * \% ap MySite Dažas M athcada komandu rindu pogas. Ijj kalkulators novērtējuma rīku rinda < grafiku rīku rinda & programmēšanas riku rinda loģisko operatoru rīku rinda grieķu alfabēts [:::] vektoru un matricu rīku rinda Simbolisko darbību rīku rinda 61

63 Instrumentu panelis Uzklikšķinot uz attiecīgās instrumenta pogas, atveras tā saturs. Piemēram: kalkulators Grieķu alfabēts Loģisko operatoru riku rinda Lapas virspusē izvietota rīku rinda, kura lielā mērā satur Windows raksturīgos rīkus. Atšķirīgie rīki ir: Insert (ievietošana), M ath (matemātika), Symbolics (simboliskās operācijas). Nākamās trīs rindas satur instrumentu paneļus, daļa no kuriem tipiska Windows, bet daļa veido specifiskas Mathcad funkcijas. Tā, piem., f(x) atver iebūvēto funkciju sarakstu. Atsevišķā rindā izvietots instrumentu panelis, kuri dod iespēju veikt virkni matemātisku operāciju. Programma Mathcad dod iespēju strādāt ar vienādojumiem, skaitļiem, tekstu un grafikiem mums ierastā veidā. Lai ievadītu izteiksmi, nav nepieciešams lietot programmēšanas valodu. Mathcad-a vienādojumi un grafiki ir dzīvi. Izmainot kādu no sākotnējiem datiem - mainīgo vai arī vienādojumu, automātiski tiek pārrēķinātas visas skaitliskās vērtības un pārzīmēti grafiki Mathcada iespējas Mathcad-ā, Jūs varat veikt aritmētiskās darbības izmantojot iebūvētās funkcijas un matem ātiskos operatorus; definēt mainīgos un funkcijas; novērtēt funkciju un izteiksmju vērtību maiņu argum enta izmaiņas apgabalā; ātri konstruēt viena un divu argum entu funkciju grafikus; veikt darbības ar m atricām; veikt funkciju diferencēšanu; aprēķināt summas un integrāļus; atrisināt vienādojumus un vienādojumu sistēmas skaitliskā veidā; 62

64 izpildīt simbolu pārveidojumus; veikt matemātisko un teksta apgabalu veidošanu; veikt izteiksmju rediģēšanu; veikt mērvienību rediģēšanu. Uzskaitītās iespējas sastāda tikai daļu no tām iespējām, kuras realizējamas ar Mathcad Darbs ar Mathcad apgabaliem Katrs Mathcad vienādojums, teksta rindkopa vai grafiks ir atsevišķs objekts saukts par apgabalu. Apgabalu var iezīmēt paklikšķinot uz tā ar peles kreiso taustiņu. Pārvietojot kursoru pie iezīmētā apgabala robežas, tas pieņem rokas veidu. Šādā stāvoklī apgabals var tikt pārvietots. Iezīmētam teksta apgabalam pārādās aktīvie punkti, kas var tikt izmantoti apgabala izmēru maiņai. Formulu apgabals Teksta apgabals X := 10 0 Piemērs, kas atrodas pa kreisi, ir izveidots drukājot x:100 Vairāki apgabali var tikt iezīmēti un vienlaicīgi pārvietoti vai nodzēsti ar peli ierāmējot tos kopējā rāmī. Lai atceltu kāda apgabala iezīmējumu, nepieciešams uz tā paklikšķināt, turot nospiestu taustiņu Shift. Apgabalus dokumentā var redzēt dodot komandu View ^ Regions. Mathcad vienmēr dokumentu lasa no kreisās uz labo pusi un no augšas uz leju. Tātad aprēķina izejas datiem jāatrodas vai nu pa kreisi vai uz augšu no aprēķinā izmantojamām sakarībām. Pamēģiniet pārvietot izteiksmi y2 = 100 virs definētās y vērtības un Mathcad vairs ne- 2 varēs aprēķināt y vērtību. y := 10 y 2 = 100 Iezīmēto apgabalu dzēšanai var izmantot komandu Edit Cut vai Cut no konteksta komandkartes, ko iegūst paklikšķinot uz apgabala ar labo peles taustiņu. Izdrukāta var tikt tikai josla gar Mathcad darba apgabala kreiso malu. Pārējo darba apgabalu var izmantot tādu starprezultātu izvietošanai, kurus nav nepieciešamas izdrukāt Matemātisko un teksta apgabalu veidošana Matemātisko izteiksmju veidošanu veicam paklikšķinot ar peles kreiso taustiņu ekrāna brīvā vietā un ievadot konkrētus matemātiskās izteiksmes elementus, izmantojot elementārās darbības, operatoru sagataves un iebūvētās funkcijas. D arbība Taustiņš Poga Piemērs z Saskaitīšana = 4 63

65 Atņemšana = 0 Reizināšana * Dalīšana / Pakāpe A 2 2 = = = 4 Teksta apgabalu veido paklikšķinot brīvā vietā un nodrukājot pēdiņas Iespējams arī sākt drukāt nepieciešamo tekstu bez pēdiņu lietošanas. Šajā gadījumā pēc pirmās taustiņa Space lietošanas Mathcad-s matemātisko apgabalu automātiski pārveidos par teksta apgabalu Mainīgo definešana Mainīgo define, paklikšķinot arpeles kieiso taustiņu ekiana vajadzigaja vietaun lakstot: E krānā redzams Druka age:23 age := 23 Jaatzime, ka nodrukājot kolu : vai paklikšķinot aritmetiskaja palete (Arithmetic Palette) uz piešķiršanas operatora taustiņa Ē [ Mathcad-s parāda :=. Piešķiršanas operators Mathcad-ā tiek lietots mainīgā definēšanai. Lai noskaidrotu mainīgā age vertību, jānodrukā mainīgā nosaukums, kam seko vienādības zīme: Druka age= iegūst age = 23 Mainīgo var izmantot matemātiskās izteiksmēs: age := 23 age -10 = 230 vai arī, lai definētu citus mainīgos: old := age -10 old = 230 Nomainot mainīgā sākotnējo vērtību definīcijā, vērtība mainās arī visās izteiksmēs, kurās šis mainīgais ir izmantots Funkciju definešana Funkcija tiek definēta tāpat kā mainīgie, lietojot piešķiršanas operatoru: f(x):xa2 D ruka E krana redzams 64

66 Definētai funkcijai f(x) var izmantot skaitli k ā funkcijas argumentu f( 10) = 100.? definēt mainīgo, kuru var izmantot kā funkcijas f(x) argumentu x := 3 f(x) = 9.? vai definēt mainīgā izmaiņas diapazonu un, izmantojot šo mainīgo kā funkcijas f(x) argumentu, iegūt funkcijas vērtību tabulu a = 0 3 f(a) Izmantojot jau definēto funkciju f(y), iespējams definēt citu funkciju: g (y ) := f (y ) + 6 g ( x) = 15. Izveidojot funkcionālu sakaribu, varam izmantot kādu n o Mathcad-ā. iebūvētajām funkcijām. Šai nolūkā dodam komandu Insert ^ Function vai paklikšķinam uz gas. In s e rt F u n c tio n Function acosh(z) anglefx, y) APPEND (file) APPENDPRN(file) arg(z) 1 zi OK Insert Cancel ED po- Description The angle (in radians) whose cosine is z. Principal value for complex z. Iebūvētās funkcijas nosaukums var tikt ievadīts ari tieši no klaviatūras Matematisko izteiksmju veidošana Paklikšķinot ekrāna vietā, kur gribam izveidot matemātisku izteiksmi, drukājam konkrēto izteksmi īpašu vērību pievēršot tam, kas notiek nospiežot taustiņu Spacebar: 65

67 Druka Ekrana redzi f(x):x+6[spacebar]*(xa3[spacebar]-1) Pirmo reizi nospiežot Spacebar X + 6 tiek izveidotas zilas rediģēšanas līnijas. Ievadot reizināšanas zīmi tā attiecas uz visu ar rediģēšanas līnijām iezīmēto izteiksmi. Gadījumā, ja Spacebar netiktu nospiests, tiktu iegūta pilnīgi cita, x+ 6-x - 1 izteiksme: Otro reizi nospiežot Spacebar, tiek iezīmēts x3 un drukājot -1, atņemšana tiek veikta no izteiksmes x3. Nepielietojot Spacebar, būtu iegūts rezultāts : Druka E krānā redzams f(x):x+6*(xa3-1) Taustiņš Spacebar rūpīgi jālieto strādājot ar eksponentēm, kvadrātsaknēm, indeksiem un dalīšanu. Piemēram: (HH! D rukā E krana redzams xa2[spacebar] +3[Spacebar] /5[Enter] Druka E krana redzams xa1/ta2[spacebar][spacebar][spacebar]/3 66

68 Izteiksmju rediģešana... 4 x f (x) := x. Veiksim izteiksmes 8 rediģēšanu ar peles palīdzību: Paklikšķinam ar peles kreiso taustiņu uz kvadrātsaknes simbola. Sakne un visa zemsaknes izteiksme ir iezīmēta zilās rediģēšanas līnijās; Paklikšķinam pa labi no 5 un izmantojot taustiņu Spacebar paplašinam iezīmēto apgabalu; Paklikšķinam pa kreisi no 3 un izmantojot taustiņu Spacebar paplašinam iezīmēto apgabalu. Zilās rediģēšanas līnijas definē izteiksmes daļu, uz kuru attieksies nākošais ievadāmais operators vai darbība. Jaunā izteiksme vai operators parādīsies pa kreisi vai pa labi no vertikālās zilās līnijas atkarībā no tā, kā ir veikta iezīmēšana (sākot pa kreisi vai pa labi no kāda objekta). Vēl dažas darbības ar peli: ( ) Vx2"+5 3 f (x) := x 8 Izpildām dubultklikšķi uz argumentu x funkcijas f(x) izteiksmē; Nospiežam peles taustiņu pa kreisi no x2 un, turot to nospiestu, pārvietojam peles kursoru pa labi. Veicot šīs darbības, daļa no matemātiskās izteiksmes tiek iekrāsota inversā krāsā. Ievadot nākošo izteiksmi vai operatoru, šī iezīmētā daļa tiks dzēsta. Rediģējiet izteiksmi x := x + x + 2 = tā, lai tā izskatītos sekojoši x = (x - 5) 2 + x - 2 = Skaitlisku un simbolisku izteiksmju ievadīšanas piemeri Mathcad-ā ir iespējams veikt darbības kā ar skaitliskām tā ar simboliskām izteiksmēm. Skaitliskas izteiksmes satur skaitļus un operatorus, bet simboliskās izteiksmes - skaitļus, nezināmos, mainīgos un operatorus. 67

69 Ar peles kreiso taustiņu uzklikšķinot patvaļīgā ekrāna lapas vietā, parādīsies sarkans krustiņš norādot pozīciju, no kuras tiks uzsākts ievads. Mathcad-ā komandas un operatorus var ievadīt kā no tastatūras tā arī no piedāvātām rīki rindām. Rakstot ar tastatūru uz ekrāna parādās izteiksme mazliet atšķirīgā formā Rakstot ar tastatūru uz ekrāna iegūstam 1 2+1/ (9+3)/2* Izteiksmes skaitlisko vērtību nosaka, ievadot no tastatūras vienādības zīmi =. Lai nodzēstu izteiksmi no ekrāna, ieklikšķiniet peles kursoru jebkurā izteiksmes vietā. Nospiediet tastatūras taustiņu Spacebar tik ilgi, kamēr visa izteiksme ir nodalīta ar zilu leņķveida rāmi. Nospiediet taustiņu Backspace. Iezīmētais laukums nokrāsosies melnā krāsā. Nospiediet taustiņu Delete un izteiksme pazudīs no ekrāna. Rakstot ar tastatūru 3*x+2*y uz ekrāna iegūstam 3 x + 2y \i6 -da2 V 16 - d2 og(xa2)-l g(1000) log(x2) - log(1000) Jaņem vērā, ka simbols slīpa svītra ( \ ) Mathcadā identificē kvadrātsakni.] M ainīgos saturošu izteiksm ju izskaitļošana 2 b a - b Uzdevums. Noteikt izteiksmes ļ vērtību pie nosacījuma, ka a=9,8 un b=5 Darba gaita: Ar peli ieklikšķinām brīvā ekrāna vietā un ar tastatūru rakstām a:9.8. Uz ekrāna būs redzams a:=9.8 (parametram a tiek piešķirta vērtība 9.8). Piešķiršanas zīmi no tastatūras ievada ar : ( kols). Līdzīgā veidā parametram b piešķiram vērtību 5. Ar tastatūru ievadām aa2*b/2= un automātiski iegūstam izteiksmes skaitlisko vērtību. Uz ekrāna redzams: b := 5 a2 - b =

70 Mathcad lasa un izpilda darbības virzienā no kreisās uz labo pusi un sākot no augšas uz leju. Saskaņā ar šo jāievēro, lai mainīgo skaitliskās vērtības tiktu uzdotas pirms mainīgos saturošās izteiksmes! Uz ekrāna izvietotu izteiksmi ar peles palīdzību var pārvietot uz jebkuru citu ekrāna vietu. Veicot vienu peles klikšķi uz izteiksmes, tai apkārt parādās melns rāmis. Pieliekot peles kursoru pie rāmja malas, tas pārvēršas par mazu melnu roku. Turot nospiestu peles pogu, pārvietojam izteiksmi uz vajadzīgo vietu Mathcad visi rezultāti ir savā starpā saistīti (dzīvi). Mainot kāda izteiksmes parametra skaitlisko vērtību vai tās daļu, tiek pārrēķinātas visas skaitliskās vērtības un pārzīmēti attiecīgie grafiki. Ieklikšķinot kursoru izskaitļojuma rezultātā un atverot izvēli Form at ^ Result, iespējama rezultāta formāta maiņa. Izvēlamies vajadzīgo formātu un apstiprinām to. Number Format General Number Format Fractional = Funkcijas vertību noteikšana un vertību tabulas izveidošanas piemeri Lai definētu mainīgo x, kas mainās no 0 līdz 10 ar soli 1, ar tastatūru raksām x:0;10. Tādā gadījumā uz ekrāna būs redzams x:= Solis 1, speciāli nav jāievada. Ja vēlamies, lai mainīgais x mainās no 0 līdz 10 ar soli 2, tad jāievada divas pirmās mainīgā vērtības, kas viena no otras ir atdalītas ar komatu un pēdējā mainīgā vērtība: x:0,2;10. Tā rezultātā uz ekrāna būs redzams x:=0, Uzdevums. Mainīgais x mainās intervalā no 0 līdz 15 ar soli 3. Aprēķināt izteiksmes 2(x-5)2+x-2 vērtības šajā apgabalā. Darba gaita: Definējam mainīgā x vērtības rakstot x:0,3;15 un definējam funkciju f(x) rakstot f(x):2*(x-5)2+x-2 Uz ekrāna redzams: x:= 0,3..15 f(x ) := 2 -(x - 5) 2 + x - 2 Lai izdrukātu mainīgā x vērtības un tām atbilstošās funkcijas f(x) vērtības, rakstām: x= un f(x)= Uz ekrāna 69

71 x = f(x ) Gadījumā, ja nepieciešams noteikt funkcijas vērtību pie kādas citas mainīgā x vērtības, piem., x=11, rakstām f(11)= un tā rezultātā uz ekrāna iegūstam f(11)= Mainīgo un funkciju definešanas piemeri Definēšanas simbols := atrodas aritmētiskajā paletē (Arithmetic Palette), bet to var izveidot arī no klaviatūras, nodrukājot kolu un vienādības zīmi: a := 4 a + 4 ā = 6 Mainot kādam dotu izteiksmju lielumam sākotnēji piešķirto vērtību, Mathcad-s automātiski pārrēķina visas no šī lieluma atkarīgās izteiksmes. Tādā veidā varam noteikt jebkuras dotas funkcijas vērtību pie fiksētas argumenta vērtības. Piemēram: f (x):= ^ a f (10) = Gadījumā, ja ir uzdota parametra a vērtība a=4, paklikšķinot a vērtības definīcijā pa labi no skaitļa 4, iegūstam zilu rediģēšanas līniju: a := 4ļ Nospiežot vienu reizi taustiņu Backspace, iegūstam: a:= i Melnā taisnstūra vietā nodrukājot 3, parametram a esam piešķīruši citu vērtību t.i. a=3. Paklikšķinot ar peli brīvajā ekrāna apgabala, redzam tās izmaiņas, kuras radušās parametra vērtības izmaiņas rezultātā. Argumenta vērtību apgabala operators (.. ) atrodas aritmētikas paletē (Arithmetic Palette) un var tikt ievadīts arī no klaviatūras, izmantojot semikolu ( ; ). Argumenta vērtības tiek uzdotas fiksējot to izmaiņas apgabala pirmo vērtību, vērtību izmaiņas soli un pēdējo vērtību. Lai iegūtu turpmāk redzamās tabulas, nodrukājiet z=, f(z)= un tā tālāk. z := 0,.5..2 z f(z) e x p (f(z ))z I

72 Nomainot argumenta z definīcijā pēdējo vērtību 2 ar vērtību 4, iegūstam lielāku argumenta un funkciju vērtību tabulu. Nomainot argumenta vērtību izmaiņas soli, piem., ar vērtību 0.2, iegūsim blīvāku funkciju vērtību kopu Funkciju grafiku konstruēšana Viena argumenta funkcijas grafiku x-y asis, piemeram, sin(x), iegūstam nodrukājot funkcijas izteiksmi un paklikšķinot uz X-Y Plot pogas I = J grafiskajā paletē (Graph Palette), vai izvēloties komandu Insert Graph ^ X-Y Plot vai arī paklikšķinot taustiņa. Pie horizontālās ass jānodrukā funkcijas arguments (mūsu gadījumā tas ir x) un jānospiež E nter. x Funkcijai, kuras grafiks tiek konstruēts nav obligāti jābūt mainīgā x funkcijai. 1 Uzdevums. Uzkonstruēt funkciju y2-3y zcos(z) 1 + x grafikus Funkciju grafiku konstruēšana lietojot mainīgo diapazonus Gadījumos, kad nepieciešams iegūt funkcijas grafiku fiksātam argumenta izmaiņas apgabalu, rīkojamies sekojošā veidā. Definējam viena mainīgā funkciju (piemēram f(x) = x2 + 8x - 27 ) r., _ Ekrana redzi Druka 2 f(x):-xa2[spacebar]+8*x-27 f ( x ) :_ x + 8 ' x 27 71

73 Definej am neatkarīgu mainīgo horizontalaj ai asij: I111 1it I Drukā x:0;10 E krana redzi x := Grafiku veidojam vidū pie horizontālās ass pierakstot x, vidū pie vertikālās ass f(x) un nospiežot E nter. -10 J -20 f(x) x Grafika gludumu raksturo punktu skaits, kuros tiek noteiktas funkcijas v ērtības, kas savienotas ar taisnes nogriežņiem. Palielinot šo punktu skaitu, iegūstam gludaku līkni. Punktu skaitu izmainām uzdodot argumenta izmaiņas soli dotaja intervala (piem., x:= 0, ). Lai iegūtu dotas funkcijas grafiku pie citam ta parametra vērtībam, pietiek divas reizes paklikšķinat uz kada no grafika elementiem un dialoga loga nomainīt vajadzīgos parametrus vai dot komandu Form at ^ Graph Vairaku funkciju grafiku vienlaicīga veidošana Lai vienlaicīgi izveidotu vairaku funkciju grafikus, piemēram z un z, nodrukajam šo funkciju izteiksmes, atdalot tas ar komatu, un pierakstam z pie horizontalas ass: ļ 2 Druka 1/z [Spacebar], [Enter] 72

74 , z 10-5.,_ L z. z Lia Atšķirīgu funkciju grafikiem var tikt lietoti atšķirīgi mainīgie ar atšķirīgu to izmaiņas diapazonu. Tā, piemēram: Drukā f(x):sin(x) g(t):ta3 x:-10,-9.9;10 t:-2,-1.9;2 E krana redzi f (x) := sin(x) g (t) := 13 x := -10, t := -2, Grafiku izveidošanai brīvā vietā drukā horizontālās ass vidū drukā x,t;. vertikālās ass vidū drukā f(x),g(t); nospiež Enter. 73

75 Grafiku konstruēšanas piemeri x, t Uzdevums.Uzkonstruet grafiku funkcijai f(t)=exp(-t2). D arba gaita: Definējam funkciju: f1 (t) := e x p ( -1 2) Par cik funkcijas nosaukums f jau ir izmantots, tad definējot funkciju izmantojam apzīmējumu fl. Ar peli ieklikšķinām brīvā ekrāna vietā un no Math paletes nospiežot pogu, ^ atveras grafiku zīmēšanas komandas, no kurām izvēlamies x-y Plot. Uz abscisu ass no tastatūras ievadām argumenta apzīmējumu t, uz ordinātu ass funkcijas nosaukumu f 1(t) un ar peli ieklikšķinām brīvā ekrāna vietā. Grafiks ir neizteiksmīgs. Nomainām argumenta intervālu uz [-2,2]. Paklikšķinām ar peli grafika laukumā un pēc tam paklikšķinot uz mazākās argumenta vērtības nomainām to ar vērtību -2. analogi nomainām otru galējo argumenta vērtību. Paklikšķinot ar peli ārpus grafika laukuma konstatējam, ka grafiks ir daudz izteiksmīgāks f1(t) 2-10,10 f 1(t) t Uzdevums. Izveidot funkciju f(x)=x+sin(x) un g(x)=xsin(x) grafikus. D arba gaita: definējam funkcijas f(x):=x+sin(x) g(x):=x sin(x) 74

76 f(x) g(x) x Grafiki polarajas koordinātes Analogi zīmējam funkciju grafikus polarajas koordinatēs. No grafiku zīmēšanas instrumentiem izvēlamies Polar Plot. Mainīgais q mainās no 0 līdz 10 ar soli Lai uzkonstruētu grafikus divām vai vairākām funkcijām uz abscisu ass ievadām argumenta vārdu, t. i. x, bet uz ordinātu ass funkciju nosaukumus, t. i., f(x) un g(x), atdalot tos vienu no otra ar komatu. Uzklikšķinot divas reizes uz grafika, atveras logs Formatting Currently Selected X Y Plot ar grafiku noformēšanas papildus iespējām.(lūdzu iepazīties patstāvīgi). q := 0, C r(q) := 2-q r(q) q Funkciju grafiki polārajās koordinātēs funkcijām cos(3q) un sin(6q) sin(6- q) q q Apvienoti grafiki Vienkaršakais veids ka vairakus grafikus apvienot viena, ir izmantot nosacījuma operatoru if. Izveidojot nosacījumus jaatceras, ka apvienojumu and (un) realizē izmantojot reizinašanas zīmi, bet nosacījumu or (vai) izmantojot pluss zīmi. 2 Uzdevums. Veikt funkcijas f(x) := x - 16 grafika modifikacijas atbilstoši izvirzītajiem nosacījumiem! 75

77 1.uzdevums. Uzzīmēt funkcijas f(x) := x2-16 grafiku! f(x) 2.uzdevums. Uzzīmēt grafiku funkcijai, kura atšķiras no funkcijas f(x) ar to, ka posma, kur f(x)<0 funkcijai ir konstanta vērtība vienada ar 0! D arba gaita. Definējam funkciju f(x) := if(f(x) > 0, f(x), 0) Funkcijas nosaukums ir pasvītrots ar zaļu viļņotu līniju.tas nozīmē, ka Mathcad brīdina par to, ka vēlams lietot citu kombinētas funkcijas nosaukumu. Tadēļ ievedam apzīmējumu: f 1(x) := if(f(x) > 0, f(x ), 0) un iegūstam f1(x) 3.uzdevums. Uzzīmēt grafiku funkcijai f2(x), kura atšķiras no funkcijas f(x) ar to, ka argumenta x vērtībam x<1 ir spēka nosacījums f2(x)= -f(x)! D arba gaita. Definējam funkciju f2(x) := if(x > 1, f(x),-f(x )) Ta rezultata iegūstam grafiku f2(x) 4. uzdevums. Uzzīmēt grafiku funkcijai f3(x), kura atšķiras no funkcijas f(x) ar to, ka argumenta x vērtībam -1<x<1 ir spēka nosacījums f3(x)= -f(x)! D arba gaita. Definējot funkciju f3(x) := if[(x > -1 ) (x < 1), f(x),-f(x)] nosacījumu par izmainītas funkcijas argumentu vērtībam ievadam ar reizinašanas zīmi. Iegūstam sekojošu funkcijas f3(x) grafiku: f3(x) x 76

78 5. uzdevums.uzzīmēt grafiku funkcijai f4 (x), kura atšķiras no funkcijas f(x) ar to, ka argumenta x vērtībām -1<x<1 ir spēkā nosacījums f2(x)=0, bet argumenta vērtībām x>1 ir spēkā nosacījums f2(x)=-f(x)! D arba gaita. Definējam funkciju f5(x) := if(x < - 1, f(x), if(x > 1 f(x), 0)) Šīs funkcijas grafiks ir: 20 f5(x) f5(x) x 6. uzdevums. Uzzīmēt grafiku apvienotai funkcijai AP(x), kuru veido funkcijas Y1(x) =0, Y2(x) = 4 un Y3(x) = 8 atbilstoši nosacījumiem Y1(x), ja x<4 AP(x) = Y2(x), ja 4<x<8 Y3(x), ja x<8 Definējam funkcijas: AP(x) := if[(x> 0) (x< 4), Y1(x),if[(x> 4)-(x< 8), Y2(x), Y3(x)]] 10 AP(x) x Virsmu grafiki Virsmas grafikuizveidošanai izmantojam no grafiku rīku rindas komandu Surface Plot vai 3D Scatter Plot. Virsmas veido divargumentu funkcijas. Piemēram definējam funkciju f 1(x,y):=x+y-x2-y2 Grafiku noformēt var vairākos veidos. Šajā piemērā pirmajā gadījumā uzzīmējam tikai virsmas grafika kontūras (Auto Contour), otrajā gadījumā virsma ir aizpildīta. Grafika 77

79 noformējuma komandas iestada divas reizes uzklikšķinot uz grafika. Atveras komandu logs 3-D Plot - Format. 1. Grafiks noformēts ar komandu 3-D - Plot - Form at Special Auto Contour Virsmas grafiks funkcijai fl(x,y) 2. Grafiks noformēts ar komandu 3-D - Plot - Format Special Auto Contour un Fill Virsmas grafiks fl(x,y) Darbojoties ar 3D grafiku ir iespējams definēt ari funkciju ar 3 mainīgajiem. Piemērs. 1. F1(u,v):=u sin(v) F2(u,v):= cos(v) F3(u,v):=u sin(u)2 2. X(u,v):=sin(v)cos(v) Y(u,v):=sin(v)sin(u) Z(u,v): =cos(v) (F1,F2,F3) (X,Y,Z) Lai izmainītu grafika formu divas reizes uzklikšķinām uz grafika un izdaram vajadzīgas izmaiņas Vienādojumu sakņu noteikšana skaitliska veida Gadījumā, ja jānosaka vienādojuma f(t)=0 saknes, palaižam Mathcad sakņu meklētāju formā root (f(t), t) =. Šai gadījumā iepriekš orientējoši jānorāda saknes atrašanās vieta. Piem., t := 1 Mathcad-s atradīs norādītajai vērtībai tuvāko sakni. Tā, piem., funkcijas f(t)=t2-cosh(t) gadījumā, iegūstam: 78

80 root(t2 - cosh(t), t) = Nelineārā vienādojumā un vienādojumu sistēmu sakņu noteikšana Uzdevums. Noteikt vienādojuma 2x - 4x - 3x + 1=0 saknes. D arba gaita: 3 2 Definējam funkciju fx) = 2'x - 4 x - 3 'x + 1 un uzkonstruējam šīs funkcijas grafiku. Izveidojam uz abscisu ass vērtību izmaiņas intervālu [-2,2], bet uz ordinātu ass intervālu [-20, 20]. Veicam vienu peles kreis ās pogas klikšķi uz grafika un ieslēdzam komandu Format Graph Trace. Paklikšķinām uz grafika krustpunkta ar abscisu asi. Tā rezultātā dialoga logā parādīsies x un y vērtības. Jācenšas uzklikšķināt pēc iespējas precīzāk uz ass tā, lai y vērtība būtu tuva nullei. Dialoga logā nospiežot komandu Copy, novietojot kursoru brīvā laukuma daļā un nospiežot komandu Paste, uz ekrāna tiks izvadīta nosakāmā x vērtība. f(x) = 2 x3-4 x2-3 x + 1 x -0.5 ir pirmā tuvinātā x vērtība, pie kuras izpildās nosacījums f(x)=0, 2 ir otrā x vērtība, pie kuasr f(x)=0, bet 0.3 ir trešā x vērtība, pie kuras f(x)=0. Šāda metode nav precīza un tādēļ ieteicams vienādojuma sakņu noteikšanu veikt izmantojot funkciju root(f(x),x) vai procedūru Given... Find V ienādojum u sakņu aprēķins dotajā intervālā a r funkciju (vai operato ru ) root (root(f(x),x)). 3 2 Saskaņā ar funkcijas f(x) = 2 'x - 4 'x - 3 'x + 1 grafiku konstatējam, ka tuvināta 79

81 mainīgā x vērtība, pie kuras f(x)=0 ir -0,5. Šo tuvināto vērtību piešķiram mainīgajam x un rakstām root(f(x),x)=. Tā rezultātā iegūstam: x := -0.5 root(f(x), x) = Analogi nosakām vienādojuma otro un trešo sakni x 1 := 2 root(f(x1), x1) = x3 := 0.3 root(f(x3), x3) = V ienādojum a sakņu noteikšana, izm antojot kom andu G iven... Find Ievadot vienādojumus ( vienu vai arī vienādojumu sistēmas), lieto simbolisko vienādības zīmi. To veic nospiežot Ctrl un ievadot =. Ievadām tuvinātu pirmās saknes vērtību. x:=-0.5 Starp komandas Given.. find vārdiem tiek ievadīta vienādojuma kreisā puse un tai sekojošā simboliskā vienādības zīme (no tastatūras taustiņi C trl un =). Aiz vārda find nodrukājot argumenta vārdu, t.i. x, tiek iegūta saknes vērtība: Given x3-4 x2-3 x + 1 = 0 find(x) = Ievadām tuvinātu otrās saknes vērtību un analogā veidā nosakām tās precizētu vērtību. Ieteicams lietot citu mainīgā apzīmējumu. Ar viļņotu stvītru pasvītrotais liecina par to, ka šāds lielums jau ir izmantots. x := 2 Given AAA x - 4 x - 3 x + 1 = 0 find(x) = Analogi nosakām trešo sakni: x := 0.3 AAA Given x - 4 x - 3 x + 1 = 0 Find(x) = Uzdevums. Aprēķināt tās argumenta vērtības dotajā intervālā [-0.5, 2], pie kurām funkcijas vērtība ir -3. Iespējami divi varianti: izmantojot operatoru root, vai komandu Given..find. 80

82 Pirmaj ā gadījumā rīkojamies sekojošā veidā: x := -0.5 root(f(x) + 3, x) = x 1 := 2 root(f(x1) + 3, x1) = x3 := 0.3 root(f(x3) + 3, x3) = Otrajā gadījumā: x := -0.5 Given x3-4 x2-3 x + 1 = -3 find(x) = Given x3-4 x2-3 x + 1 = -3 find(x) = Given x3-4 x2-3 x + 1 = -3 find (x) = Uzdevums. Atrisināt nelineāru vienādojuma sistēmu x(z+1)2-2x(x+z)=0 (1-x)2y-2x2 =0 (z-2)y2+z=0. Piešķiram mainīgiem x, y, z patvaļīgas sakņu sākuma vērtības, pēc tam seko operators Given, tālāk ievada pirmā vienādojuma kreiso pusi un tad simbolisko vienādības zīmi (no tastatūras nospiežot taustiņu Ctrl un =) un vienādojuma labo pusi nulli. Simbolisko vienādības zīmi var ievadīt arī no Mathcad-a rīku rindas. Analogi ievada pārējos vienādojumus. Zemāk ievada komandu Find ar meklējamo nezināmo apzīmējumiem x,y,z. Mainīgiem var piešķirt arī nosaukumus. Darba gaita: Patvaļīgi ievadam tuvinātas sakņu sākuma vērtības x:=3 y:=10 z:=1 81

83 Given x (z + 1) - 2 x (x + z) = (1 - x)2 y - 2 x = 0 (x - 2) y + z = 0 ^1.975A find(x, y, z) = 8.21 V y Uzdevums. Noteikt vienādojuma saknes ar funkciju Solve Uzrakstam vienādojumu un paņemam simbolisko aprēķinu panelī komandu Solve ievadam mainīgo x un ar atstarpes taustiņu aktivizējam izteiksmi (zila līnija), nospiežam komandu Calculate (vai taustiņš F9). 2 x ' - 25 solve, x Jāņem vērā, ka lietojam simbolisko vienādības zīmi. Pieraksts var būt arī šāds: f(x) := x x f(x) solve, x Uzdevums.Atrast kvadrātvienādojuma a z 2 + bz + c = 0 saknes. D arba gaita: Piešķiram mainīgiem a, b, un c vērtības. Rakstot vienādojumu izmantojam simbolisko vienādojuma zīmi un komandu Solve kā iepriekšējā piemērā. a:=2 b:=3 c:=1 / _ 1 \ -1 V 2 0 ( \ X + 1 sin(x) = Uzdevums. Noteikt vienādojuma 10 saknes. Darba gaita: Uzkonstruējam vienādojuma kreisās un labās puses funkciju grafikus un tuvināti nolasām tās argumenta x vērtības, pie kurām abi grafiki krustojas. Diapozonā no -10 līdz +10 šādas vērtības ir 7. 82

84 sin ( x) x+1 10 x sin( x) - 1 = 0 10 Izmantojot funkciju root, iegūstam x:= - 9 ( r \ X + 1 I rootl sin(x) - 10, x I = x:= 9 (. x + 1 ^ rootl sin(x) - 10, x I = Studentam jāatro d pārējās saknes Darbs ar vektoriem un matricām V ektoru un m atricu definēšana Lai izveidotu vektoru vai matricu: Drukā v: Izvēlas komandu Insertā Matrix vai paklikšķina uz pogas vektoru un matricu paletē (Vector and M atrix Palette). Ievada vajadzīgo rindu un kolonnu skaitu (3 un 1). Paklikšķina uz In sert Aizpilda matricas sagatavi lietojot Tab lai pārvietotos no vienas pozicijas uz otru. 3.3 v :=

85 Lai iegutu pirmo vektora elementu, kura indekss pec noklusēšanas ir 0 E krānā redzi Druka v[0= 0 vai lieto pogu no Arithm etic Palette. Nākošajam elementam ir indekss ^ : v[1= Druka Pēdējam elementam ir indekss 2: v[2= Druka Lai izvadītu visus elementus uzreiz: i:0;2 v[i= Druka E krana redzi v 1 = E krana redzi v 2 = 8 E krana redzi i := 0..2 v Vektoru elementi var tikt izmantoti k a funkcijas argumenti. Piemeram: yjv f (v) := r v + a b := 9.7 a := b 2 Definējam vektoru un lietojam ta elementus ka funkcijas argumentus: f(v ' 3.3 ' 1.11 v := i := Lielākā daļa vektoru un matricu operatoru atrodami Vector and Matrix Palette. Daži piemēri: D arbība Taustiņi Poga Uz ekrana Skalārais reizinājums [Shift]+8 : 1 v w 84

86 Vektoriālais reizinājums [Ctrl]+8 «XV ļ v x w Determinants I N M Kolonna [Ctrl]+6 N. M 2 > Mathcad ir liels daudzums iebuveto funkciju darbibam ar vektoriem un matricam. Skatieties dažus piemērus: M := M ērķis Piemers Kolonnu skaits cols(m ) = 3 Rindu skaits rows (M ) = 3 Lielaka skaitliska vērtība max (M ) = 9 Matricas īpašvērtības eigenvals (M ) = Darbs ar matricam. 1. Matricu var ievadīt ar tastatūru nospiežot taustiņu Ctrl un burtu M vai no matricu rīku rindas uzklikšķinot uz matricu vektora pogas. 2. Atveras komandu logs Insert Matrix, kurā jāievada matricas rindu un kolonnu skaits un jānospiež pogu OKvai Insert. 3. Aizpildām tukšās pleisholdera (melni laukumi ņi) vietas ar vērtībām. Pārejot no vienas vērtības uz citu, lietot taustiņu Tab. 85

87 Piemeram, gadījuma r 5i ļ 1+ 2i V 6 0, viena kolonna un trīs rindas. Exel tabulas parkopešana uz Mathcad ( ) ir viena rinda un trīs kolonnas, bet gadījuma Iezīmējam Excel tabulu, iekopējam atmiņā, atveram Mathcad un izpildām komandu Edit > Paste Special as "Unformatted Text As Number," ( ļ V Līdzīgi ka jebkuram mainīgajam arī matricai varam piešķirt vardu r ļ b := V Darbības ar matricam. P :=( 5 7 Divu dotu matricu V6 8 M := summu nosaka sakarība M + P = Sareizinam divas matricas x := (1 2 3 ) y := ^4 8 12^ y *x = x-y = 28 86

88 Atrast matricas lielāko un mazako vērtību, izdrukāt rindu un kolonnu skaitu. Definejam matricu, lai ērtāk būtu ievadīt skaitļus spiežam taustiņu Tab B := ^ ^ è y min(b) = 1 ma?(b) = 9 cols(b) = 3 rows(b) = 3 Izdrukājot matricas n-to rindu vai kolonnu Mathcad-ā masīva mainīgos elementus sāk skaitīt no 0. Var lietot komandu ORIGIN:=1. Tad matricas pirmais elements ir 1. Tātad, izdrukājot matricas pirmās rindas otro elementu un trešās rindas trešo elementu, iegūstam B 0, 1 = 3 B 2, 2 = 1 Lai izdrukātu matricas pirmo rindu un pirmo kolonnu, rakstām.. j:=0..2 Bj, 0 = Bo, j = X := f Dotas matricas è transponēto vai inverso matrica un matricas determinantu iegūst, izmantojot pierakstu. x - 1 = T XT= è 9.524X IX =-210 Iespējama matricu reizināšana vektoriālā formā. Piemēram, dota matrica 87

89 M = [ 1 J (M M) = v 2 4 0, bet tas vektorialais reizinajums pašai ar sevi ir Cits iespējamais pieraksta veids ir 2 3 LV3 0 V4 0J r 2 ļ 6 V Funkcija Augment dod iespēju mainīt matricas strukturu. Ta, piemeram, divu matricu vieta iespējams izveidot vienu matricu ar citu kolonnu skaitu. Dotas matricas M := r P:=V un V6 80, bet varam iegut augment(m, P) = Vienādojumu sistēmas atrisinašana izmantojot matricu algebru Izmantojot matricu rēķinus, iespējams noteikt linearas vienadojumu sistēmas saknes. Linearas vienadojuma sistēmas saknes aprēķina sareizinot vienadojuma sistēmas kreisas puses inverso matricu ar labas puses matricu: Sak := Vk" 1 V Ta, piemēram, vienadojumu sistēmas x+2y+3z=1 4x+5y+4z=2 3x+2y+z=3 gadījuma, iegustam: r ^ r 1 > r 2 ļ Vk := Vl := 2 Sak = -2 V3 2 1 j V3 0 V 1 0 Saskaņa ar iepriekš izklastīto, sistēmas atrisinajumu varam iegut arī izmantojot funkciju Isolve. Tada veida iegustam r 2 ļ lsolve(vk, VĻ = -2 Tatad iegutie rezultati sakrīt. 88

90 2.10. Matematiskas analīzes uzdevumi Mathcad-ā ir iespējams veikt simboliskas darbības. Simboliskā vienādības zīme ir bultiņa no Symbolic rīku rindas. Bultiņas vietā var lietot komandu Symbolic ^ Evaluate ^ Symbolically vai Shift +F9. Lai vienkāršotu izteiksmi, lieto funkciju symplify p 3 + p z 15 + z p = sin(x) + cos(x) simplify 1 (x - 1) + 2-x2 + 4-x - 1 simplify 3-x2 + 2-x Funkciju atvasinašana (diferencešana) No Calculus riku rindas izvēlamies pogu _ kā rezultātā atveras sagatave di Šai sagatavē melno taisnstūrīšu vietās jāievada funkcijas nosaukums (fukcija dota iepriekš) vai tās izteiksme un mainīgais, pēc kura veicama diferencēšana. Ievadot simbolisko vienādības zīmi ( ^ ), automātiski iegūstam funkcijas diferenciāli. Piemēram: d d 2 -x dx d x2 (ln(x))_ dx sin(x) cos(x) dx. Analogi tiek iegūti funkcijas augstakas kartas atvasinajumi Šim nolūkam tiek izmantota augstakas kārtas atvasinājuma poga. Piemēram: d x 12-x dx Summu un integrāļu aprēķins Summu un noteikto integrāļu sagataves atrodamas aprēķinu paletē Calculus Palette. Ievadot konkrētas izteksmes un to parametru izmaiņas apgabala vērtības, automātiski iegūstam konkrētās summas vai integrāļa vērtības. Tā, piem., iegūstam: 10 1 Y = t 0 n! j - 1 -dx = x 89

91 1 1 + cos(x) q(x) := x2 + 4 x q(x) dx 0 3 Funkcijas, kura uzdota rindas veida, vērtības pie fiksētam argumenta vērtībam nosaka analogi tam, ka iepriekš izklastītaja vienargumenta funkciju vērtību aprēķina. Piemēram: 3 f(x) := I k = 0 3! k 23-k x 2 k!-(3 - k)! f(2) = f(-5) = f(1) = Nenoteikta integraļa gadījuma nepieciešams veikt simboliskas operacijas un rezultata iegušanai jaizmanto simboliska vienadības zīme no simbolu paletes. Integraļu aprēķinam izmantojam atbilstošas rīku paletes poga. Piemēram * * 2, x dx x sin(x) dx -cos (x) xdxdxdx 3 J J J J Funkcijas robežu noteikšana. Rīku rinda ir trīs pogas robežu noteikšanai, no kuram pirma ļauj noteikt robežu punkta vai bezgalība, otra un treša nosaka robežu no kreisas un no labas puses. Ta, piemēram, iegustam: 2, Mērvienību lietošana Skaitliskam lielumam mērvienību var pievienot to pareizinot ar mērvienības izteiksmi: Druka E krānā redzi 90

92 r:6370*km r := 6370 km A(r):4*p[Ctrl]g*rA2 A (r) := 4-p-r 2 (Simbols p ir pieejams arī no Arithmetic Palette un Greek Symbols Palette.) (HH! D rukā E krana redzi A(r)= 14 2 A (r) = 5.099*10 -m Jaatzime, ka rezultāts automatiski tiek izvadīts SI sistēma p-r = *m2 Lai izvadītu aprēķina rezultātu, piemēram, hectares, paklikšķinam uz izteiksmes, pēc tam divas reizes uz melnā taisnstūra izteiksmes labaj ā malā un nomainam mērvienību. 4 - p r 2 = h e c t a r e Mērvienības ievadīšanai var izmantot arī Insert Unit dialoga logu. Literatūra 1. Дьяконов В.П. Компьютерная математика. Теория и практика. М.:Нолидж, 2001ю 2. Кирьянов Д. MathCAD СПб.: БХВ-Петербург, Mathcad 11. Userus Guide. Mathsoft Engineering&Education Inc., Дьяконов В.П.Энциклопедия MathCAD 2001i и Mathcad 11. М: СОЛОН- ПРЕСС, 2004Ю 91

93 3. STIEŅU SISTĒM U SKAITLISKO APRĒĶ IN U M ETO DIK A IM ANTOJO T GALĪG O ELEM ENTU PROGRAM M U ANALYSIS FO R W INDO W S 3.1. Programmas īss raksturojums Analysis fo r Windows 1.9 ir uz galīgo elementu metodi balstīta programma, kas paredzēta divu un trīs dimensiju metāla kopņu un rāmju aprēķinam. Tiek pieņemts, ka sistēma sastāv no lineāri elastīgiem gariem slaidiem stieņiem. Programma paredzēta darbam Windows vidē un tai piemīt visas Windows programmu priekšrocības - neizejot no programmas var strādāt ar citām programmām, iekopēt ekrāna saturu atmiņā (Clipboard), atvērt vēl vienu programmas kopiju, u.t.t. Programma tiek atvērta standarta Windows logā. Strādājot ar Windows, uz citām programmām var pārslēgties izmantojot taustiņu kombināciju Alt+Tab, vai no loga pilna ekrāna varianta pārslēgties uz standarta variantu ( - lg I x l-> - ln l x l), lai kļūtu pieejams uzdevumu panelis. Programmai ir sekojošas komandu grupas: File - darbam f Structural Analysis ar failiem, Structure - izejas datu ievadīšanai, Drawing - rezultātu izvadīšanas uz ekrāna parametru noteikšanai, Calculate - aprēķinu veikšanai, Results - iegūto rezultātu izvadīšanai uz ekrāna, Print - iegūto rezultātu drukāšanai, Help - informācijas iegūšanai. Sākot darbu ar programmu komandu grupā Structure jāizvēlas, vai sistēma būs divu vai trīs dimensiju un vai tā būs kopne vai rāmis. Izvēles rezultāts ir redzams arī ekrāna kreisajā apakšējā stūrī, kur ir parādīta globālā koordinātu sistēma: plakana kopne; plakans rāmis; telpiska kopne; telpisks rāmis. Informāciju par aprēķinu veikšanai nepieciešamo sistēmas struktūru, slodzēm un materiālu īpašībām var ievadīt izmantojot komandu grupas Structure komandas. Lielu darba daļu var veikt arī dialoga režīmā, izmantojot peli, vienlaicīgi vizuāli kontrolējot iegūtos rezultātus. Darbam dialoga režīmā ir sekojošas priekšrocības: jebkuras izdarītās izmaiņas (ievadīts jauns mezgls vai stienis, izmainītas koordinātes) nekavējoši parādās uz ekrāna un var tikt vizuāli kontrolētas; izvēlēties mezglu vai stieni izmantojot peli ir daudz ērtāk nekā meklēt tos atbilstošā sarakstā; 92

94 balsti un slodzes mezglos var tikt ievadītas vienlaicīgi ar mezgliem; slodzes, kas darbojas uz stieņiem, var tikt ievadītas vienlaicīgi ar stieņiem. Ievadot izejas datus var izmantot starptautiskās (SI) vai ASV mērvienības. Vispirms ir jāievada informācija par mezgliem, pēc tam par stieņiem. Pēc izejas datu ievadīšanas var tikt veikts sistēmas aprēķins un izvadīti iegūtie rezultāti. Pirms veikt aprēķinu, programma izpilda sistēmas struktūras analīzi un pārliecinās, vai tā ir ģeometriski nemainīga. Pēc aprēķina veikšanas, stieņi, kuriem neizpildās stiprības vai noturības nosacījumi, tiek iekrāsoti sarkanā krāsā Komandu grupa File File ^ New Nodzēš apskatāmo konstrukciju, lai dotu iespēju ievadīt jaunu. Ielādē eksistējošu konstrukciju no diska atmiņā. Atmiņā esošie struktūras dati var tikt pazaudēti. Ieraksta struktūras datus diskā failā ar paplašinājumu.str. File à Combine Ielādē struktūras datus no dota faila atmiņā. Ielādētie dati var tikt kombinēti ar atmiņā esošajiem datiem. File Text out Saglabā struktūras datus teksta failā ar paplašinājumu.txt. Ja konstrukcija ir aprēķināta, teksta failā parādās arī aprēķina rezultāti. File à DXF-Files Ļauj ievadīt un izvadīt rezultātus AutoCad formātā (konstrukcijai jābūt veidotai no taisniem stieņiem). Programmas darba beigas. Ja kopš pēdējās saglabāšanas struktūras dati ir mainījušies, programma piedāvā saglabāt izmaiņas K o m a n d u g r u p a S tr u c tu r e Structure Drawing Calcu 2-DimensiGnal Truss Joints Members Support Joints Joint Loads Structure à 2-imensional Structure à Truss Parāda, ka tiks rēķināta plakana sistēma. Izvēloties šo komandu varam pārslēgties uz telpisku sistēmu aprēķinu. Šajā gadījumā parādās komanda 3-Dimensional. Parāda, ka tiks rēķināta kopne. Izvēloties šo komandu varam pārslēgties uz rāmja aprēķinu. Šajā gadījumā parādās komanda 93

95 Frame. Structure à Neglect own Weight Parāda, ka netiks ievērots konstrukcijas pašsvars. Izvēloties šo komandu varam pārslēgties uz pašsvara ievērošanu. Šajā gadījumā parādās komanda Calculate own Weight. Structure à International Units Structure à Joints Parāda, ka tiks izmantotas starptautiskās mērvienības (SI). Pārslēgties uz ASV mērvienībām (American Units) var izvēloties šo komandu. Mezgls tiek definēts ar mezgla numuru un tā koordinātēm. Lai ievadītu, mainītu vai dzēstu mezglus izvēlamies komandu Jo ints (att. 3.1). att. 3.1 Lai pievienotu jaunu mezglu, ievadām tā koordinātes globālaj ā koordinātu sistēmā (divas plakanas sistēmas gadījumā, trīs - telpiskai sistēmai) un nospiežam Enter pēdējā aizpildītajā lodziņā vai nospiežam pogu Add (att. 3.1). Starptautiskajā mērvienību sistēmā koordinātes var tikt ievadītas m vai mm (jāizvēlas lodziņš Coordinates in mm). Lai izdzēstu mezglu, to izceļam un dodam komandu Remove. Pēc dialoga loga aizvēršanas (OK) palikušie mezgli tiks pārnumurēti. Lai mainītu mezgla parametrus ierakstam mezgla numuru logā Joint Nr. un nospiežam Enter vai izceļam mezgla numuru ar peli un paklikšķinām peles labo taustiņu. Pēc izmaiņu izdarīšanas mezgls jāpievieno sarakstam dodot komandu Add. Rediģēt datus tieši sarakstā nav iespējams. Izdarītās izmaiņas apstiprinām (OK) vai atceļam (Can- 94

96 cel). Poga Copy... ļauj veidot jaunus mezglus (izvēle Copy) vai pārvietot esošos (izvēle Move) noteiktā attālumā no dotā mezgla. Šī iespēja ir ērta, ja attālumi starp mezgliem nav veseli skaitļi un ir neērti aprēķināt mezglu globālās koordinātes, kā arī veidojot daudzstāvu konstrukcijas. Kopējot tiek pārkopēti arī stieņi starp izceltajiem mezgliem. Izcelt vairākus mezglus iespējams izmantojot taustiņu Ctrl. Structure ^ M embers Pēc mezglu ievadīšanas varam ievadīt stieņus. Stieni nosaka tā sākuma un beigu mezgls. Sākuma mezgls ir mezgls ar mazāko globālo X koordināti. Ja X koordinātes ir vienādas, tad att. 3.2 sākuma mezgls ir mezgls ar mazāko globālo Y koordināti. Ja arī Y koordinātes ir vienādas, tad sākuma mezgls ir mezgls ar mazāko Z koordināti. Ar stieni ir saistīta lokālā koordinātu sistēma. Lokālā x ass iet no sākuma mezgla paralēli stienim, lokālā z ass vienmēr ir paralēla xz plaknei, bet lokālā y ass tiek ņemta tā, lai tās pozitīvais virziens projicētos uz pozitīvā globālās Y ass virziena. Par datu atbilstību lokālajai koordinātu sistēmai rūpējas programma. Lokālo koordinātu sistēmu stienim var redzēt stieni izceļot ar peli - paklikšķinot uz stieņa sākuma un beigu mezgla numuriem. Katram konstrukcijā izmantotajam stieņa šķērsgriezumam un materiālam ir jābūt savam individuālam nosaukumam (sarakstos komandās Cross Sectional D ata un M aterial Data). Lai ievadītu jaunu stieni dodam komandu Structure^M em bers (att. 3.3). Aizpildam tabulu ievadot: a) logā M ember No. ievadam stieņa numuru; b) logos Begin un End - stieņa sākuma un beigu mezglu numurus; c) logā Section - stieņa šķērsgriezuma nosaukumu; d) logā M aterial - stieņa materiāla nosaukumu; e) logā Hinges - 0, ja stienim galos nav locīklu, B, ja locīkla ir stieņa sākumā, E, ja locīkla ir stieņa beigās un 2, ja locīklas ir abos stieņa galos; f) logā Angle - pagrieziena leņķi ap lokālo x asi; g) nospiežam E nter pēdējā logā vai dodam komandu Add. Kopnes (Truss) gadījumā pēdējās divas pozīcijas nav jāaizpilda. Lai dzēstu kādus stieņus, tos izceļam un dodam komandu Remove. 95

97 att. 3.3 Lai rediģētu esošu stieni, ievadam tā numuru un nospiežam taustiņu Enter vai izceļam stieņa numuru ar peli un paklikšķinām peles labo taustiņu. Pēc izmaiņu izdarīšanas stieni pievieno sarakstam dodot komandu Add. Rediģēt datus tieši sarakstā nav iespējams. Izdarītās izmaiņas apstiprinām (OK) vai atceļam (Cancel). att. 3.4 att. 3.5 Stieņu grupai ar vienādu šķērsgriezuma nosaukumu, šo nosaukumu (visiem stieņiem) var mainīt dodot komandu Section... (att. 3.4). Logā Old Section name ieraksta veco, bet logā New Section name jauno šķērsgriezuma nosaukumu un apstiprina (OK) vai atceļ (Cancel) izvēli. Ja ir nepieciešams kādus stieņus bez locīklām pārveidot par stieņiem ar locīklām abos galos un otrādi, izceļam vajadzīgos stieņus un dodam komandu Hinges... (att. 3.5). Izvēlamies No Hinges, ja locīklas nav vajadzīgas, Hinges on both sides, ja tās ir vajadzīgas un apstiprinām izvēli. Structure à Support Joints Lai sistēmu papildinātu ar balstiem dodam komandu Structure ^ Support Joints (att. 3.6). 96

98 att. 3.6 Balsti tiek definēti ar mezgla numuru un ierobežojumiem pārvietojumiem attiecībā pret koordinātu asīm. Plakanai sistēmai jāraksturo pārvietojumi pret x un y asīm Rx un Ry un pagrieziens ap z asi Mz, telpiskai sistēmai iespējams raksturot sešus parametrus - trīs lineāros pārvietojumus (Rx, Ry, Rz) un trīs pagriezienus (Mx, My, Mz). Ir iespējami sekojoši varianti: 1) Space - iespējams brīvs pārvietojums; 2) R - atbilstošais pārvietojums nav iespējams; 3) D - uzdots sākotnējais pārvietojums (balstu sēšanās), kura lielums milimetros j āieraksta ailē Dx, Dy vai Dz; 4) S - pārvietojums iespējams, bet proporcionāli pārvietojuma lielumam pieaug balsta reakcija (balsts uz elastīga pamata). Balsta reakcijas pieaugumu raksturo koeficients, kurš kn/m j āieraksta ailē Dx, Dy vai Dz. Piezīme: pēdējie divi punkti attiecas tikai uz lineāriem pārvietojumiem. Kopnēm iespējami ierobežojumi tikai lineārajiem pārvietojumiem. Pēc vajadzīgo aiļu aizpildīšanas pievienojam balstu sarakstam - Add vai Enter pēdējā ailē. Pēc katra balsta pievienošanas balsta numurs automātiski palielinās par vienu un varam ievadīt nākamo balstu. Ja nepieciešams kādu balstu dzēst izvēlamies to sarakstā un dodam komandu Remove. Lai rediģētu esošu balstu, ievadām tā numuru un nospiežam taustiņu Enter vai izceļam balsta numuru ar peli un paklikšķinām peles labo taustiņu. Pēc izmaiņu izdarīšanas balstu pievieno sarakstam dodot komandu Add. Rediģēt datus tieši sarakstā nav iespējams. Izdarītās izmaiņas apstiprinām (OK) vai atceļam (Cancel). Plakanai sistēmai uz ekrāna balsti tiek parādīti sekojošā veidā: 97

99 1 Iespilejums - Rx=R, Ry=R, Mz=R. Kustīgs lociklas balsts - Rx= Ry=R, Mz=. Balstu sešanās - Rx=, Ry=D, Mz= 2 Nekustīgs lociklas balsts - Rx=R, Ry=R, Mz=. Balstu sēšanās - Rx=D, Ry=D, Mz=. Balsts uz elastīga pamata - Rx=, Ry=S, Mz=. Telpiskai sistēmai balstu izskats uz ekrāna ir nosacīts un var mainīties atkarībā no redzes leņķa uz sistēmu. Structure à Joint Loads Lai konstrukcijai pieliktu slodzi mezglos, dodam komandu Structure è Joint Loads (att. 3.7). att. 3.7 Ierakstām mezgla numuru ailē Joint No. un atbilstošos logos pielikto spēku un momentu vērtības. Apstiprinot ievadītos datus, atmetot slodzes un izdarot labojumus rīkojamies tāpat kā visu iepriekšējo logu gadījumā. Spēki tiek ņemti ar + zīmi, ja to virzieni sakrīt ar globālās koordinātu sistēmas asu virzieniem. Tātad uz leju vērsts spēks ir jāņem ar - zīmi. Momenti ir pozitīvi atbilstoši labās rokas likumam pret asīm globālajā koordinātu sistēmā (pulksteņa rādītāja virzienā skatoties ass pozitīvaj ā virzienā). Plakanai sistēmai asu pozitīvie virzieni parādīti zīmējumā: 98

100 F X F y M z Structure ^ M ember Loads Lai noslogotu konstrukcijas stieņus dodam komandu Structure ^ Member Loads (att. P1.8), ievadam stieņa numuru (Member No.), izvēlamies slodzes veidu (C), lokālo vai globālo koordinātu sistēmu (L/G) un ievadam slodžu skaitliskās vērtības atbilstoši slodzes veidam. Stienim var pielikt piecu dažādu veidu slodzes, kuru izvēli nosaka skaitlis C: C=1: Koncentrēts spēks F (kn) x, y vai z ass virzienā, attālumā a no stieņa sākuma mezgla. C=2: Moments M (knm) ap x, y vai z asi, attālumā a no stieņa sākuma mezgla. C=3: Izkliedēta slodze q (kn/m) x, y vai z ass virzienā. C=4: Simetriska trapecveida izkliedēta slodze q (kn/m) x, y vai z ass virzienā ar pārejas zonu a (m). C=5: Nesimetriska trapecveida izkliedēta slodze x, y vai z ass virzienā ar intensitāti q1 (kn/m) attālumā a (m) no stieņa sākuma mezgla. Slodze darbojas posmā ar garumu b (m). Tādejādi intensitāte slodzes beigās q2 (kn/m) ir attālumā a+b no stieņa sākuma mezgla. 99

101 Mem ber Loads 2LI M em ber No. C L/G X1 Y1 Z1 a [m] X2 Y 2 Z2 b [ml ICO Add Rem ove Cancel Ok Load Case C : 1: Point Load [kn] along the...axis on a distance 'a ' from the first joint. 2: Moment [knm] along the...axis on a distance 'a ' from the first joint. 3: Distributed M em ber Load [kn/m along the...axis. A: Sym metrical Trapezoidal Load [kn/m] along the...axis with transition 'a'. 5: Nonsym m etrical Trapezoidal Load [kn/m from distance 'a ' till [kn/m] at 'a'+ 'b ' L/G: Local or Global Coordinate System Structure à Temperature Structure à Cross Sectional Data att. 3.8 Komanda Structure ^ Temperature ļauj iegūt piepūles un spriegumus, kas rodas konstrukcijā to sasildot vai atdzesējot. Piemēram, var ņemt vērā temperatūras starpību (ok) starp izgatavošanas un ekspluatācijas temperatūru. Visiem konstrukcijā lietotajiem stieņu šķērsgriezumiem jābūt piešķirtam nosaukumam, kuram jāatrodas stieņu šķērsgriezumu bibliotekā, kas pieejama ar komandu Structure ^ Cross Sectional Data (att. 3.9). Bibliotēka satur lielu daudzumu Eiropas standarta stieņu šķērsgriezumu. Papildināt bibliotēku var ierakstot jauno šķērsgriezuma nosaukumu (Section Name) un to raksturojošos parametrus atbilstošās ailēs un dodot komandu Add (izdzēst ar Remove). Katru šķērsgriezumu raksturo: 100

102 Ax: šķērsgriezuma laukums [cm2]; Ix: inerces moments pret x asi [cm4]; Iy: inerces moments pret y asi [cm4]; It: šķērsgriezuma vērpes konstante [cm4]; ex: lielākais attālums no šķērsgriezuma neitrālās ass līdz šķērsgriezuma robežai galvenās ass virzienā [mm]; ey: lielākais attālums no šķērsgriezuma neitrālās ass līdz šķērsgriezuma robežai sekundārās ass virzienā [mm]; M: stieņa viena metra masa [kg/m]. Cross-sectional data Section Name Ax Ix ly It [cm I] [cm 4] (cm 41 [cm 4] ex [mm] ey [mmj M [kg/m] HEA26Q - HEA28Ü HEA3GG HEA320 HEA34G HEA360 HEA40Ü HEA450 HEA50G 1 HEA550 HEA60G / , ,00 Add Remove Cancel Ok att. 3.9 Structure à Material D ata Katram konstrukcijā izmantotajam materiālam jābūt savam individuālam nosaukumam. Lai pievienotu sarakstam jaunu (Add) vai izdzēstu nevajadzīgu (Remove) materiālu dodam komandu Structure è Material Data (att. 3.10). 101

103 att kn/cm2=10 MPa =100 kg/cm2-2 K atru m atenalu raksturo: 1 N/mm = 1 MPa nosaukums (Material); elastības modulis E (kn/cm2); bīdes modulis G (kn/cm2), izotropiem materiāliem G=E/(1+v), kur v ir Puasona koeficients; materiāla robežspriegums Re (N/mm2), vienāds ar 0.7 no materiāla tecēšanas robežas vai stiepes stiprības; termiskās izplešanās koeficients (10-6 1/K). Piezīme: starptautisko (SI) un amerikāņu mērvienību salīdzinājums: International Units (SI) American Units Joint Coordinates: meter [m] foot [ft] Forces: knewton [kn] thousands of pounds [Kips] Moments: [knm] [Kip-ft] Distributed Load: [kn/m] [Kip/ft] Joint Displacements: [mm] inch [in] Stresses: [N/mm2], MPa [Kips/in2] 1 foot = meter 102

104 1 pound [lbf] = Newton 1 inch = 25.4 mm 3.4. Darbs dialoga režīmā. Informāciju par aprēķinu veikšanai nepieciešamo sistēmas struktūru, slodzēm un materiālu īpašībām var ievadīt arī dialoga režīmā, izmantojot peli, vienlaicīgi vizuāli kontrolējot iegūtos rezultātus. Mezglu ievadīšana dialoga režīmā. Lai ievadītu jaunu mezglu izpildām ekrānā dubultklikšķi ar peles kreiso taustiņu. Logā ekrāna labajā apakšējā stūrī (att. 3.11) ievadam att mezgla koordinātes. Ja mezglā ir balsts, poga Support... ļauj ievadīt ierobežojumus mezgla pārvietojumiem. Poga Load... ļauj pielikt mezglam slodzes. Ievadītos datus apstiprinām ar OK. Lai rediģētu mezglu, izpildām dubultklikšķi ar peles kreiso taustiņu ekrānā uz mezgla numura, veicam un apstiprinām vajadzīgās izmaiņas. Lai dzēstu mezglu, izpildām dubultklikšķi ar peles kreiso taustiņu ekrānā uz mezgla numura un nospiežam taustiņu Remove. Stieņu ievadīšana dialoga režīmā. att

105 Lai ievadītu jaunu stieni ar peles kreiso taustiņu iezīmējam stieņa sākuma un beigu mezglus. Iezīmētā stieņa numurs kļūst sarkans. Stieņa iezīmējumu var atcelt ar peles labo taustiņu. Iegūtajā logā (att. 3.12) ievadam stieni raksturojošos lielumus un arī slodzes (izmantojot taustiņu Load...), apstiprinām izmantojot taustiņu OK. Lai izmainītu stieni ar peles kreiso taustiņu iezīmējam stieņa sākuma un beigu mezglus, izdarām un apstiprinām izmaiņas. Stieņa dzēšanai izmantojam pogu Remove K o m a n d u g r u p a D r a w in g Drawing ^ Redraw - atjauno ekrana saturu (to pašu dara klikšķis ar peles kreiso taustiņu). Drawing ^ Drawing Options - maina zīmējuma parametrus. OK Cancel Drawing ^ Colors - maina zīmējumā attēlojamo lielumu krāsas. 104

106 üoiuur setting!» Select an elem en t and his colour. Structure D isplacem ents Forces M om ents Axial Force Shear Force Bending M om ent Torsion Bending M em b er Stress Krasu palete w T mana Attēlojamais lielums Structure D isplacem ents Forces Moments B endin g Axial Force Shear Force BenriingJiļom enī M em b er Stess «> Dotaja bridi aktīvas krasas OK Cancel Zīm ējum a param etru maiņai izmantojamas taustiņu kombinācijas: C trl+j Ctrl+M Ctrl+P parāda (noņem) mezglu num urus parāda (noņem) stieņu num urus parāda (noņem) profilu nosaukumus C tr l+ «-,* telpiskām konstrukcijām maina horizontālo redzes leņķi par 30 C tr l+ t,* telpiskām konstrukcijām maina vertikālo redzes leņķi par 30 A lt+«-,-» telpiskām konstrukcijām maina horizontālo redzes leņķi par 10 A lt+ f,* telpiskām konstrukcijām maina vertikālo redzes leņķi par 10 Ctrl+F Ctrl+L Ctrl+R skats uz struktūru no priekšas skats uz struktūru no kreisās puses skats uz struktūru no labās puses 105

107 Ctrl+T Ctrl+I Ctrl+D Ctrl+N Ctrl++/- skats uz struktūru no augšas maina attēla izvadīšanas uz ekrāna veidu (Isometric, Dimetric) parāda (noņem) mezglu pārvietojumus parāda (noņem) aprēķina rezultātus dubulto (2x samazina) piepūļu un pārvietojumu zīmēšanas mērogu (to pašu dara peles labais un kreisais taustiņš) 3.6. K o m a n d u g r u p a C a lc u la te Komandu grupa Calculate satur tikai vienu komandu, kas veic sistēmas aprēķinu. Pirms aprēķina izpildīšanas tiek veikta sistēmas struktūras analīze. Ja sistēma nav ģeometriski nemainīga, aprēķina izpilde tiek pārtraukta un izdots paziņojums - The Construction is not stableļ. Ģeometriski nemainīgai sistēmai katram mezglam tiek sastādīta un atrisināta līdzsvara vienādojumu sistēma. Lielu konstrukciju aprēķina gaitai var sekot ekrāna kreisajā augšējā stūrī, kur tiek parādīts, cik vienādojumi ir izveidoti Equation 695 out of 1692 un Clk mezgliem tie ir atrisināti Join t 43 out of pēc aprēķina veikšanas sistēmas zīmējums automātiski tiek papildināts ar mezglu pārvietojumiem. Ja kādam sistēmas stienim neizpildās noturības vai stiprības nosacījumi, tas tiek iekrāsots sarkanā krāsā K o m a n d u g r u p a R e s u l t s Results_ Print Help Joint Displacem ents Member Forces Member Stresses Buckling R eactions NTM Forces NTM Stresses labās rokas likums. Komandu grupas Results komandas izvada uz ekrāna aprēķina rezultātus. Results ^ Joint Displacements: Izvada uz ekrāna mezglu pārvietojumu vērtības globālajā koordinātu sistēmā tabulas veidā. SI sistēmā lineārie pārvietojumi tiek doti [mm], pagriezieni [o]. Lineāro pārvietojumu pozitīvie virzieni sakrīt ar globālās koordinātu sistēmas asu virzieniem, leņķisko pārvietojumu pozitīvos virzienus nosaka Results ^ M ember Forces: Tabulas veidā parāda piepūļu vērtības sistēmas stieņu 106

108 galos lokālajā koordinātu sistēmā. Lokālās koordinātu sistēmas asu virzienus visvieglāk iegūt iezīmējot vajadzīgo stieni uz ekrāna. SI sistēmā spēku mērvienība ir [kn], momentu [knm]. Kopnēm piepūlēm tiek dota tikai viena vērtība (beigu mezglā), rāmjiem (sijām, u.c.) abos stieņa galos. Results ^ M ember Stresses: Tabulas veidā parāda spriegumu vērtības sistēmas stieņu galos lokālajā koordinātu sistēmā. SI sistēmā spriegumu mērvienība ir [N/mm2, MPa]. Kopnēm spriegumiem tiek dota tikai viena vērtība (beigu mezglā), rāmjiem (sijām, u.c.) abos stieņa galos. SAx : aksiālspriegums. SDy, SDz : bīdes spriegumi lokālās y- un z- ass virzienā. Bīdes spriegumi tiek aprēķināti atbilstoši SDy = Fy / Ax (vidējā sprieguma vērtība). SBy, SBz : aksiālspriegumi, ko izsauc liece lokālās y- un z-ass virzienā. Tie tiek aprēķināti atbilstoši SBy = My ey / Iy. STx : vērpes (bīdes) spriegums. Vērpes spriegums tiek aprēķināts atbilstoši STx = Mx e / It. SRes : rezultējošais spriegums, kas aprēķināts atbilstoši Huber and Hencky in NEN 3851 p24: SRes = sqrt( SAx2 + SBy2 + SBz2 - SAxSBy - SBySBz - SBzSBx + 3SDy2 + 3SDz2 + 3STx2 ) Plakanu sistēmu gadījumā: SRes = sqrt( SAx2 + SBy2 - SAxSBy + 3SDz2 ) SRes nav reāls rezultējošais spriegums stienī, bet idealizēts spriegums, kas var tikt salīdzināts ar Re (materiāla stiprības robeža = 0.7 no tecēšanas robežas vai stiepes stiprības). Results ^ Buckling: Parāda spiesto stieņu noturības aprēķina rezultātus atbilstoši NEN 3851 p35. Šajā aprēķinā tiek pieņemts, ka visas slodzes tiek ievadītas ar slodzes koeficientu (Load Factor) - attiecību starp aprēķinā izmantoto un reālo slodzi. Slodzes koeficients parasti tiek ņemts vienāds ar 1.5, bet var tikt ievadīta arī jebkura cita vērtība. 107

109 Drošības koeficients (Safety Factor) ir atkarīgs no ekspluatācijas apstākļiem. Tērauda konstrukcijām drošības koeficients parasti ir 2.5. Kopējās maksimālās pieļaujamās noturības slodzes lielums (Maximum Buckling Load) ir atkarīgs no slodzes koeficienta un drošības koeficienta. Katram spiestam stienim slaidums un maksimālā pieļaujamā noturības slodze tiek aprēķināta ņemot vērā galu stiprinājumus. Veicot aprēķinu tiek ņemta vērā stieņa slaiduma (Slenderness) un Eilera robežslaiduma (Eulers Limit Slenderness) attiecība: Slaidums = Stieņa garums / sqrt( I / Ax ) Eilera robežslaidums = 3,14 sqrt( E / 0,7 Re ) = 111 ( for FE360 ) Slaidums <= 20: Šajā apgabalā maksimālā pieļaujamā deformācija tiek sasniegta daudz ātrāk par noturības zudumu. Maksimālo pieļaujamo noturības slodzi nosacīti var noteikt atbilstoši: Ax. Re. 20 < Slaidums < Eilera robežslaidums: Šis ir plastiskais apgabals, kurā spriegums nedrīkst pārsniegt materiāla tecēšanas robežu. Maksimālo pieļaujamo noturības slodzi šajā apgabalā rēķina atbilstoši Von Tetmayer. Slaidums > Eilera robežslaidums: Šis ir elastīgais apgabals, kurā ir spēkā Eilera noturības kritērijs: Maksimālā pieļaujamā noturības slodze= 3,142 EI / ( drošības koeficients. stieņa garum s2 ). Results ^ Reactions: Tabulas veidā izvada balstu reakciju aprēķina rezultātus globālajā koordinātu sistēmā. SI sistēmā mērvienība spēkiem ir [kn], momentiem [knm]. Pozitīvie virzieni spēkiem sakrīt ar globālās koordinātu sistēmas asu pozitīvajiem virzieniem, momentiem jāpielieto labās rokas likums globālajā koordinātu sistēmā. Results ^ NTM Forces: Aprēķina sistēmas stieņiem aksiālspēka (N), šķērsspēku (Ty un Tz), vērpes momenta (Mx), lieces momentu (My un Mz) un izlieču (fy un fz) vērtības virknē stieņu šķēlumu. Aksiālspēks ir pozitīvs, ja tas izsauc stiepi apskatāmajā šķēlumā. Šķērsspēks ir pozitīvs, ja tas griež apskatāmo stieņa daļu pretī pulksteņa rādītāja virzienam. (Pretēji tam kā pieņemts celtniekiem! - Q epīru zīmē nepareizā pusē!). 108

110 Lieces moments ir pozitīvs, ja tas izsauc stiepi stieņa augšēja daļa. (Pretēji tam kā pieņemts celtniekiem! - M epīru tom ēr zīmē stieņa stieptajā pusē!). Izliece ir pozitīva, ja tās virziens sakrīt ar lokālās koordinātu ass pozitīvo virzienu. Piepūļu pozitīvie virzieni parādīti zīmējumā: Stieņa dalījumu skaits var tikt mainīts (parasti 20). Aprēķina rezultāti tiek parādīti tabulā: NTM-Forces Stieņa numurs \ Member No. Divisions Dalījumu skaits / Aprēķināt izvēlēto I Stieņi, kurus parādīt stieni(-us) zīmējuma Calculate 20 OK Parādīt visus stieņus Sclect the Members to b drawn Ail Members Forces [knj Moments [knm] Deflection [mm] Distance N Ty Tz Mx My Mz fy fz Æ. 8.S , , , Results ^ NTM Stresses aprēķina sistēmas stieņiem aksiālspriegumus (SNx), bīdes spriegumus (TDy un TDz), vērpes spriegumus (TMx), lieces izsauktos spriegumus (SMy un SMz), izlieci (fy), rezultējošo spriegumu (Resulting Comparative Stress) (SRes) virknē stieņa šķēlumu. Rezultāti tiek apkopoti tabulā: 109

111 Zīmju likumi spriegumiem ir t ādi paši kā spēkiem K o m a n d u g r u p a P r in t Help S tructural D ata M aterial List Results Ņ TM -Forces D raw ing H eading Print ^ Structural Data: Izdrukā tabulu veidā noformētus datus par mezgliem, balstiem, stieņiem, stieņiem pieliktajām slodzēm, stieņu šķērsgriezumu parametriem un izmantotajiem materiāliem. Print ^M aterial List: Izdrukā tabulu ar visiem stieņiem izmantoto profilu un materiālu nosaukumiem. Color print Print ^R esults: Izdrukā mezglu pārvietojumus, piepūles un spriegumus sistēmas stieņu sākumā un beigās, noturības aprēķina rezultātus, balstu reakcijas. Print ^NTM -Forces or Stresses: Izdrukā piepūļu vai spriegumu (arī izlieču) vērtības visiem iezīmētajiem un zīmējumā parādītajiem stieņiem fiksētos šķēlumos (parasti 20). Print ^D raw ing: Nodrukā uz ekrāna redzamo zīmējumu. P rint ^ P r i n t Heading: Papildina izdrukājamos materiālus ar nepieciešamajiem komentāriem (5 rindas). Print ^ C o lo r Print: Pārslēdz drukāšanas režīmu no krāsaina uz melnbaltu un otrādi. 110

112 3.9. Stieņu sistēmu piepuļu aprēķina piemers P=10kN Ï I q=4kn/m P UUUUIU co co Uzdevums. Dotajam rāmim uzkonstruēt iekšējo piepūļu epīras, izmantojot galīgo elementu programmu Analysis for Windows interaktīvā režīmā. D arba gaita: 1. Darbu sākam ievadot mezglus un vienlaicīgi arī balstus. Tā kā mezglos 1 un 7 ir iespīlējumi un konstrukcijā ir stingi mezgli (3), tad aprēķins jāveic režīmā Frame. Pārslēdzam programmu šajā režīmā dodot komandu Structure ^ Frame. Koordinātu sākumpunktā kreisajā apakšējā ekrāna stūrī pazūd locīkla un koordinātu asis pieņem attēlā redzamo veidu. Tas nozīmē, ka programma ir pārslēgta no režīma Truss (Kopne), kad visos mezglos aprēķina gaitā automātiski tiek ievietotas locīklas (ekrānā nav redzamas) uz režīmu Fram e (Rāmis). Ja kādā mezglā ir pielikta slodze, arī tā var tikt ievadīta vienlaicīgi ar atbilstošo mezglu. Lai ievadītu mezglu, divreiz paklikšķinām ar peles kreiso taustiņu jebkurā brīvā ekrāna vietā. Atveras dialoga logs Joint Coordinates, kuru nav ieteicams pārvietot, jo pretēj ā gadījumā programma bieži uzkaras. Logā Joint Coordinates parādās mezgla numurs Joint No. (mezglus programma numurē pati). Mezgla koordinātes jāievada logos X[m] un Y[m]. Koordinātu sākumpunktu varam izvēlēties brīvi. Šoreiz par sākumpunktu pieņemam pirmo mezglu. Telpiskai sistēmai būtu jāievada arī koordināte Z[m]. Lai izveidotu pirmajā mezglā iespīlējumu izvēlamies pogu Support. Support Joints D isplacem ents [mm] or R=Restrasnt [^ D is p la c e d S=Sprmg Sfļfjrļg t t ô & m ĶM/m] Joint No, R x R y Rz M x M y Mz!)x Dy Dz LJ!_!!_! 0 Ok Cancel R em ove Logs Support Joints izmantojams gan plakanu, gan telpisku sistēmu balstu izveidošanai. Plakanai sistēmai ir iespējams ierobežot trīs pārvietojumus: Rx - pārvietojumu x 111

113 ass virzienā; Ry - pārvietojumu y ass virzienā un pagriezienu ap z asi Rz (z ass nāk ārā no ekrāna plaknes), kas šeit arī ir izdarīts, izveidojot iespīlējumu. Telpiskai sistēmai iespējams ierobežot 3 pārvietojumus un 3 pagriezienus. Vajadzības gadījumā konstrukcija var tikt aprēķināta arī uz balstu sēšanos, atbilstošos laukos ievadot simbolus D un pārvietojumu skaitliskās vērtības, kā arī ņemt vērā elastīgus pamatus, ievadot simbolus S. Otrajā mezglā ierobežojam tikai pārvietojumu vertikālā virzienā, izveidojot kustīgu locīklas balstu. Support Joints - R =R estraint 0 = D isp ia c ed S^Sprintj Joint No, R x R y R z M x M y M z m n f n D isplacem ents [mm] or Spring C oustanis [kn/mj Ox D y Dz Ok Cancel R em ove Trešajā mezglā nav nepieciešami nekādi ierobežojumi, bet ir nepieciešams pielikt slodzi. Slodzes vērtību ievadam logā Joint Load, ko iegūst izvēloties pogu Load. Mīnus zīme jāliek, jo slodze darbojas pretēji Y ass pozitīvajam virzienam. Mezglos konstrukcija var tikt slogota ar spēkiem (Forces) un spēkpāriem (Moments). Tādā pat veidā ievadam pārējos mezglus, vienlaicīgi monitora ekrānā sekojot, vai konstrukcija veidojas pareiza. Padoms! Regulāri saglabājiet izveidoto struktūru, lai nebūtu jāsāk darbs no jauna! 112

114 2. Pēc visu mezglu ievadīšanas varam ievadīt stieņus. Lai ievadītu pirmo stieni pa reizei paklikšķinām uz pirmā un otrā mezgla. Programma parāda stieņa numuru (piešķir pati), stieņa sākuma (Start) un beigu (End) mezglus. Šī informācija ir būtiska ievedot locīklas. Logā Section ievadam profila numuru, kuru izvēlamies izmantojot komandu Structure Cross Sectional Data. Atbilstošais saraksts var tikt papildināts ar saviem profiliem, ja tas ir nepieciešams. Logā Material ievadam izvēlēto materiālu (Structure ^ M aterial Data). Arī materiālu saraksts var tikt papildināts. Izvēlne Hinge nosaka kur atbilstošajam stienim ir locīklas (B - stieņa sakumā, E - beigās, 2 - abos galos, 0 - nav locīklu). Izvēlne Angle nosaka profila orientāciju. Stienim 1 nav locīklu, toties ir pielikta slodze. Poga Load atver logu Member Loads, kurš ļauj ievadīt koncentrētu spēku - C=1, spēkpāri - C=2 un trīs veidu izkliedētās slodzes - C=3,4,5 (skat. iepriekš). Mūsu gadījumā koncentrēts spēks pretēji Y ass virzienam attālumā a[m]=2 no stieņa sākuma. Izmantota globālā koordinātu sistēma G, kas sakrīt ar ekrāna stūrī parādīto. Member Loads HHX1 Y1 Z1 a ļm] -1Ū 2 X2 Y2 Z2 b[m] *j Ok Cancel Remove New Next 1: Point Load 2: Moment 3: Distributed 4: Trapezoidal 5: Non symmetrical Trešajam stienim locīkla ievadīta stieņa beigās, tas ir 4 mezglā. 113

115 Lai slīpajam trešajam stienim pieliktu slodzi perpendikulāri stieņa asij, jāizvēlas lokālā koordinātu sistēma L, kura ir piesaistīta stienim un kuras asu virzieni mainās kopā ar stieņa virziena maiņu. I M ember Loads *1 M em ber No. C L/G X I Y1 Z1 a [m] X? Y2 7.2 b[m ] r IPIHI Ū.00Ū o Cancel R em ove N ew N ext 1 : Point Load 2: Moment 3: Distributed A: Trapezoidal 5: Non symmetrical Ceturtajam un piektajam stienim pieliekam vienmērīgi izkliedētu slodzi q, sestajam P pretēji X ass virzienam. Ekrānā redzam ievadīto sistēmu un varam pārliecināties par tās atbilstību dotajam uzdevumam. nīga vai acumirklīgi mainīga, parādās ziņojums The Construction is not stable un aprēķins netiek veikts. Šādā gadījumā sistēmā jāveic izmaiņas, lai tā kļūtu ģeometriski nemainīga un jāatkārto aprēķins. Mūsu gadījumā šāds paziņojums neparādās un tiek parādīts sistēmas deformētais stāvoklis. Informācija par aprēķina rezultātiem iegūstama komandu grupā Results. Ja gribam, lai programma parāda pie- 114

116 puļu epiras, izveļamies Results ^ NTM-Forces. Epiras iespejams iegūt tikai programmas režīmā Frame. Varam izvēlēties vai nu atsevišķus stieņus vai visu sistēmu, atzīmējot All Members Calculate ^ OK. Šeit pat varam iegūt piepūļu skaitliskās vērtības (N - asspēks, Ty - šķērsspēks, Mz - lieces moments, fy - izliece perpendikulāri stienim), kaut gan ērtāk tās iegūt no teksta faila ko iegūstam dodot komandu File ^ Text Out. Ilustrācijai parādīta daļa no teksta faila fram e.txt satura - piepūles 1 stienī. Member No. 1: Joint No. 1 to 2 distance N Ty Mz fy

117 Axial- and Shear Forces [kn], Moments [knm], Deflection [mm]. Uz ekrāna tiek izvadītas iekšējo piepūļu epīras dažādās krāsās. Lai rezultāts butu parskatamaks, loga Drawing ^ Drawing Options izmainam NTMcourse mērogu no 1 uz 4. Drawing Options X N u m b e rin g v- J o in ts Angle of view H o riz o n ta l1/ V e rtic a ly Drawing R Forces... W Joint Restraints 1.GO Drawing scale W Joint Displacements.. io,ac F NTM-course... 4 Drawing scale Drawing scale OK Cancel 116

118 Katras iekšejas piepūles epira ir iekrāsotā sava krasa Axial Force " ass sp^ks, Shear Force - šķērsspēks; Bending Moment Torsion - lieces moments; ' vērpes moments (paradas telpiskas sistēmas, mums = 0); Deflection - izliece. Epiru krāsa var tikt mainīta izvēloties Drawing ^ Colors. Izvēloties kādai piepūlei balto krāsu, šīs piepūles epīra ekrānā nebūs redzama. 117