Scilab

informație

Dezvoltat de	Scilab Enterprises
Ultima versiune	6.1.0 (25 februarie 2020)
Depozit	git: //git.scilab.org/scilab
Scris in	C ++ , C , Java și Fortran
Interfață	GTK
Sistem de operare	Linux , Microsoft Windows , macOS și distribuția software Berkeley
Tip	Calcul numeric
Licență	CeCILL v2 , GPLv2
Site-ul web	www.scilab.org , scilab.io

Scilab (pronunțat [ s a d l a b ] Contraction Scientific Laboratory în limba engleză) este un software gratuit pentru calcul numeric multiplatformă care oferă un mediu de calcul pentru aplicații științifice. Are un limbaj de programare orientat spre calcul numeric la nivel înalt . Poate fi utilizat pentru procesarea semnalului , analiza statistică , procesarea imaginilor , simulări de dinamică a fluidelor , optimizare numerică și modelarea și simularea sistemelor dinamice explicite și implicite.

Este disponibil pentru Windows , Mac OS X , GNU / Linux și BSD .

Sintaxa și posibilitățile oferite de Scilab sunt similare cu cele ale MATLAB , dar cele două programe nu sunt compatibile cu toate că există un traducător de la MATLAB la Scilab.

Istoric

Proiectul s-a născut la Inria în 1982 sub numele Blaise , de la Matlab. Prin urmare, este inițial o suprapunere Fortran care permite programarea structurată , sintaxa fiind aproape de Pascal . În 1984, Inria a fondat un start-up, Simulog, pentru a comercializa produsul sub numele Basile .

În anii '90, Simulog a încetat distribuția Basile și proiectul, numit atunci Meta2 , a devenit rodul unei colaborări între cercetătorii de la Inria și Ecole Nationale des Ponts et Chaussées . Prima versiune a Scilab, numită apoi Ψlab ( Psilab , aceeași pronunție), a fost disponibilă în 1994. Dezvoltarea Scicos a început în același timp, ca o cutie de instrumente grafice.

În 1998, un fost doctorand al proiectului Meta2, Habib Jreige, a fondat start-up-ul Saphir-Control pentru a oferi asistență companiilor private care utilizează Scilab.

Echipa Metalau a fost fondată în 2000 pentru a dezvolta un traducător Matlab / Scilab și pentru a asigura integrarea bibliotecilor grafice orientate obiect și, în special, a unei interfețe grafice în Java.

La începutul anului 2003, Inria a decis să creeze Consorțiul Scilab, cu sprijinul companiilor și organizațiilor academice pentru a face față creșterii numărului de persoane care descarcă și utilizează Scilab și pentru a-i asigura viitorul și dezvoltarea. În 2005, Scilab Consortium a decis să se orienteze către dezvoltarea Java; echipa Metalau decide să rămână pe tehnologia Gtk și, prin urmare, creează un split (furcă) numit ScilabGtk bazat pe Scilab 4; acest proiect va fi redenumit ScicosLab .

În conformitate cu dezvoltarea industrială, Consorțiul Scilab se alătură Fundației Digiteo de Cooperare Științifică diniulie 2008 să ofere un mediu propice creșterii susținute a operațiunii și să se pregătească pentru transferul său treptat către o structură privată.

Deci în iunie 2010, Scilab Enterprises a fost creat pe modelul economic clasic Open Source pentru a asigura dezvoltarea software-ului Scilab gratuit bazat pe cod deschis și pentru a oferi servicii profesionale plătite. De candIulie 2012, software-ul Scilab este dezvoltat de Scilab Enterprises .

În 2015, Inria și OCamlPro au înființat un proiect comun de interpretare OCaml numit Scilint . Acest lucru dă naștere Sciweb , un interpret accesibil de un browser web , deși incomplet și mai lent.

Licență

Distribuit gratuit și cu codul său sursă prin Internet din 1994 , este disponibil precompilat pentru un număr mare de arhitecturi . Cu toate acestea, nu era nici un software open source conform Open Source Initiative, nici software gratuit . Într-adevăr, vechea licență Scilab nu autorizează distribuirea comercială a unei versiuni modificate. Conform clasificării FSF , a fost deci un software destul de semi-liber . Prin urmare, Scilab a devenit software gratuit când s-a schimbat licența: este distribuit sub licența CeCILL v2 de la versiunea 5.0, o licență gratuită compatibilă cu GNU GPL .

Scurtă prezentare a utilizării

Scilab poate executa instrucțiuni pe linia de comandă , precum și fișiere de comandă (scripturi) care conțin instrucțiuni (format text). Puteți rula programe Fortran sau C de la Scilab. De asemenea, este posibil să utilizați motorul Scilab dintr-o aplicație externă datorită API-ului call_scilab. Scilab este completat de un mediu grafic Xcos (bazat pe Scicos ) comparabil cu mediul grafic Simulink furnizat cu Matlab.

Sintaxa de bază a liniei de comandă

Linia de comandă promptul constă dintr - o „săgeată“: două linii de pauză și un semn superioară -->. Instrucțiunea este tastată apoi validată cu cheia de returnare a căruței ( Enter , Return ). Rezultatul este afișat după, cu excepția cazului în care linia se termină cu punct și virgulă, caz în care rezultatul este ascuns. De exemplu :

-->a = 1; -->A = 2; -->a + A ans = 3.

Prima comandă asociază valoarea "1" variabilei "a" (rezultat ascuns), a doua comandă asociază valoarea "2" variabilei "A" (sintaxa este susceptibilă de spargere ), al treilea control calculează suma dintre cele două ( ans este abrevierea de răspuns care înseamnă „răspuns” în engleză).

Puteți scrie mai multe instrucțiuni pe aceeași linie, separându-le cu virgulă sau cu punct și virgulă dacă nu doriți să afișați rezultatul. De asemenea, puteți pune o instrucțiune pe mai multe linii (de exemplu, din motive de prezentare), punând trei puncte " ... " înainte de a apăsa tasta de returnare a căruciorului.

Scilab utilizează funcțiile și funcțiile de poarta ( +, -, *, /, ^sau **, sqrt()la rădăcina pătrată , cos()pentru cosinus , int()în partea întreagă , round()pentru rotunjire la cel mai apropiat, abs()la valoarea absolută ...) și altele ( de exemplu, randpentru un număr aleator între 0 și 1). Funcția whoafișează variabilele declarate. Variabila ansconține ultimul rezultat.

Separatorul zecimal este punctul. Pentru a intra în imaginarul $i$ , trebuie să utilizați %i ; pur și simplu apare ca „i” în rezultate. Pentru a intra în infinit $\infty$ , trebuie să utilizați %inf ; pur și simplu apare ca „inf” în rezultate. Valoarea lui $π este$ obținută de %pi, iar constanta Neper $e$ de %e.

Booleeni

Când atribuiți o valoare, booleanul este folosit %Tpentru „adevărat” ( adevărat ) și %F„fals” ( fals ). Rezultatul operației afișate este respectiv Tsau F.

Operatorul Or este notat „| „( Tube ), Și se notează„ & ”( ampersand ), Non se notează„ ~ ”( tilde ). Exemplu

-->(%T & %F) | %F ans = F.

Un boolean poate fi obținut prin compararea a două valori cu relațiile de egalitate == și diferență <>, sau ~=, și relațiile de ordine < , <=, >și >=.

Polinoame și fracții raționale

Nu este vorba aici de funcții polinomiale care ar permite doar evaluarea lor numerică, ci de polinoame formale .

Declararea unui polinom se face cu două funcții. Prima funcție, x = poly(0, "x")care definește „x” ca indeterminată a unui polinom, apoi enunțul polinomului folosind acest nedeterminat. Exemplu

-->x = poly(0, "x"); p = x ^ 2 + 2 * x + 1 p = 2 1 + 2x + x

Funcția roots(p)dă rădăcinile polinomului p , funcția coeff(p)dă o matrice ai cărei coeficienți sunt coeficienții polinomului p . Funcția varn(p)returnează numele indeterminatului lui p (aici, x ).

De fapt, comanda x = poly(0, "x")definește că x este cel mai simplu polinom al cărui nedeterminat este caracterul „x” și a cărui rădăcină este 0, adică x monomial . Comanda x = poly(2, "x")definește, de asemenea, cel mai simplu polinom cu rădăcina 2, adică x - 2.

Această funcție permite definirea unui polinom având mai multe rădăcini, folosind o matrice de rânduri în loc de un număr simplu. De exemplu, x=poly([1 2], "x")definiți cel mai simplu polinom cu rădăcinile 1 și 2, adică polinomul x 2 - 3 x + 2.

Putem folosi această funcție și pentru a genera un polinom ai cărui coeficienți sunt conținuți într-o matrice de rânduri, prin adăugarea caracterului 'c'la sfârșitul argumentelor. De exemplu, definiți polinomul a0 + a1 · x + ... + an · x n . x = poly([a0, a1, …, an], "x", "c")

Scilab gestionează fracțiile raționale în același mod . Este suficient să declare un monomial cu poly()și apoi să definească fracția rațională. Exemplu

-->x = poly(0, "x"); f = (1 + x) / (1 - x) f = 1 + x ----- 1 - x -->1/f ans = 1 - x ----- 1 + x

Pentru a obține numeratorul lui ƒ, tastați f.num ; numitorul lui ƒ se obține cu f.den.

Funcția dă derivarea formală a polinomului sau a unei fracții raționale p . Funcția simplifică fracția rațională q . derivat(p)simp(q)

Utilizarea polinomului sau a unei fracții raționale ca funcție se face prin funcția horner : horner(p,2)calculați p (2).

Caracter

Caracterele simple sau șirurile sunt notate între ghilimele simple sau între ghilimele duble: 'abc'sau "abc".

Apostroful indică sfârșitul unui șir; pentru a pune un apostrof într-un șir, trebuie să scrieți două contigue '', iar pentru a pune un ghilimel dublu, trebuie să scrieți și două contigue "".

Adăugarea +peste șiruri produce concatenare . Un șir de caractere poate fi evaluat, adică transformat într-o comandă Scilab, prin funcție evstr().

Matrici

Scilab a fost conceput pentru calculul matricial . Toate funcțiile se aplică matricilor ; de exemplu, dacă M este o matrice, atunci log(M)va fi matricea ai cărei coeficienți sunt logaritmii coeficienților lui M. Elementele matricei pot fi de orice tip ( numere reale , numere complexe , booleene , polinomiale , raționale , șiruri ... ).

Pentru a defini o matrice din coeficienții săi, le plasăm între două paranteze […]. Elementele unei linii sunt separate printr-un spațiu sau o virgulă, liniile sunt separate printr-un punct și virgulă. Când este afișată, matricea este reprezentată ca o matrice fără încadrare (cu excepția matricilor de șiruri care sunt încadrate de puncte de exclamare). De exemplu :

-->[1, 2, 3 ; 0, 1, 0 ; 0, 0, 1] ans = 1. 2. 3. 0. 1. 0. 0. 0. 1.

Matricea goală este notat cu []. Expresia M(i,j)desemnează elementul ( i , j ) al matricei M. Caracterul :( colon ) înseamnă „toți indicii”, de exemplu M(1, :)este primul rând al matricei (este un vector de rând ). Caracterul $( dolar ) desemnează ultimul index (rând sau coloană) al unei matrice.

Expresia este N1:N'utilizată pentru a genera o matrice de rând al cărui prim coeficient este N1, ultimul este mai mic sau egal cu N ', iar pasul dintre coeficienți este 1. Expresia este utilizată pentru a genera o matrice de rânduri alegând pasul. de exemplu N1:pas:N2

-->1.1:5.2 ans = ! 1.1 2.1 3.1 4.1 5.1 ! --> 1:2:5 ans = ! 1 3 5 ! -->"a":"d" ans = abcd

Funcția creează o matrice m × n umplută cu 0; funcția creează o m × n matrice umplut cu 1. Funcția creează o n × n matrice unitate . De asemenea, putem trece o matrice M ca parametru al acestor funcții; apoi creează o matrice cu aceeași dimensiune ca matricea M. De exemplu, stabilește toți coeficienții lui M la zero. zeros(m,n)ones(m,n)eye(n,n) M = zeros(M)

Dacă ƒ este o funcție externă (adică definită de deffsau de function, a se vedea mai jos) și că x și y sunt vectori, atunci funcția fevalpermite să se construiască o matrice z = ƒ ( x , y )

z = feval(x, y, f) : avem z ( i , j ) = ƒ ( x ( i ), y ( j ))

Funcția size(M)returnează dimensiunea matricei ca o matrice 2 × 1 care conține numărul de rânduri și apoi numărul de coloane.

Operațiile specifice matricilor convenționale sunt:

transpunere: puneți doar o perioadă urmată de un apostrof .’după matrice; utilizarea apostrofului singură 'face transpunerea matricei conjugate ( operator asistent );
produsul matricilor * ;
produs și raportați articol cu articol: .*și ./ ;
produsul tensorial .*. ;
determinantul unei matrice pătratică M: det(M)( determ()pentru o matrice de polinoame și detr()pentru o matrice de fracție rațională);
Trasarea unei matrice pătratică M: trace(M) ;
inversa unei matrice inversabilă M: inv(M).

Un vector este o matrice de rând sau coloană (1 × n sau n × 1 matrice ); expresia V(i)denotă componenta i a vectorului V. Dacă V1 și V2 sunt vectori de coloană , atunci produsul punct este V1.' * V2 ; dacă sunt vectori rând , produsul punct este V1 * V2.'.

Calcul numeric

Scilab poate efectua calcule numerice.

Poate fi folosit în mod trivial ca calculator , prin simpla introducere a operațiunilor de efectuat.

Funcția deffface posibilă definirea de noi funcții (numite „funcții externe”) care pot fi exprimate cu operatorii deja predefiniți („funcțiile primitive”). Trecem două șiruri de caractere ca parametru; prima indică numele funcției și variabilele utilizate ca intrare și ieșire, iar a doua indică formula. De exemplu, funcția

ƒ ( x ) = 2 x

poate fi definit de

deff("[y] = f(x)", "y = 2 * x")

(vezi și secțiunea Programare ).

Integrare integrate("expression", "x", x0, x1)calculați numeric integralul funcției descrise prin expresie (este un șir de caractere care poate fi interpretat de Scilab, ca "sin(x)"), x fiind variabila de integrare, între valorile x 0 și x 1. Rezolvarea ecuațiilor Scilab are mai multe primitive pentru rezolvarea ecuațiilor (vezi Solverul ecuațiilor ), inclusiv:

linsolve : rezolvarea unui sistem de ecuații liniare,
sintaxă: [x0, kerA] = linsolve(A, b)
unde A este matricea reală a coeficienților sistemului de ecuații și b un vector de constante; soluțiile lui A × x + b = 0 sunt de forma x 0 + w × kerA, w fiind un real arbitrar;
solve : rezoluția simbolică a unui sistem liniar,
sintaxă: w = solve(A, b)
unde A este o matrice triunghiulară superioară de caractere (coeficienții sistemului de ecuații), b este un vector de caractere (partea din dreapta semnelor egale), și w este rezultatul matricei lui A × w = b ;
ode : Rezoluția unei ecuații diferențiale ordinare ( ecuație diferențială ordinară ) ; dacă ecuația diferențială este d y / d t = ƒ ( t ), atunci ƒ fiind definită (funcție externă), sintaxa pentru determinarea y ( t ) este
y = ode(y0, t0, t, f)
unde y 0 și t 0 sunt valorile inițiale ale sistemului , t este un vector al valorilor pentru care se calculează soluțiile, iar y este vectorul soluțiilor ( plot(t, y)permite desenarea graficului soluțiilor);
primitivul odeadmite argumente care permit rezolvarea unor situații specifice: "roots"pentru a adăuga o ecuație g ( t , y ) = 0, "discrete"pentru a calcula recursiv y ( k + 1) = ƒ ( k , y ( k )) din „o stare inițială y ( k 0).

Există și alte primitive pentru sisteme specifice.

Complot funcțional

Complot 2D

Desenarea unei funcții se face în doi pași

definiți întinderea variabilei abscisei și pasul, de exemplu, sub forma unui vector coloană ;x = [début:pas:fin]'
trasați funcția cu comanda plot(x, f(x))dacă ƒ este funcția.

Putem parcela mai multe funcții simultan punându-le într-o matrice, de exemplu plot(x, [f1(x) f2(x) f3(x)]).

Observăm de fapt că ƒ ( x ) este el însuși un vector. În general, putem defini un vector al valorilor lui x și un vector al valorilor lui y , iar funcția plot(x, y)va desena graficul de împrăștiere.

Dacă ƒ este o funcție externă (de exemplu definită cu deff, a se vedea mai sus sau function, a se vedea mai jos), atunci putem trasa direct funcția cu fplot2d(x, f). De asemenea, putem defini y prin y = feval(x, f), apoi desenăm cu plot(x,y).

Funcția este xgridutilizată pentru a afișa o grilă corespunzătoare gradărilor.

Funcțiile , utilizate în loc de , vă permit să modificați aspectul general al complotului: plot2diplot

plot2d : Linie „normală”; identic cu plot, dar permite utilizarea markerilor;
plot2d2 : linie în trepte;
plot2d3 : complot în baruri;
plot2d4 : grafic în „săgeți” (pentru un câmp vector);

Aceste funcții acceptă argumente care modifică complotul, în formă . Argumentele sunt de formă și sunt separate prin virgule. plot2diplot2di(x, y, arguments)mot-clef = valeur

Pentru a plasa markeri, folosim argumentul în care n este un număr întreg pozitiv sau negativ (de exemplu ); un număr negativ înlocuiește punctele cu markeri (o stea pentru -10, cercuri pentru -9, ..., puncte mici pentru 0, lista se obține prin tastarea comenzii ) și un număr pozitiv indică o linie continuă, dar de culoare determinată (conform cartelei color definite, vezi mai jos). style = nplot2d(x, y, style = 1)getsymbol

Dacă graficul are mai multe curbe (așadar plasate într-un rând Y matrice), argumentul styleeste o matrice, valoarea fiecărui element indicând stilul fiecărei curbe, de exemplu

Y = [cos(x), sin(x)]; plot2d(x, Y, style = [-2, -1])

Puteți utiliza comanda legend()pentru a introduce subtitrări, de exemplu

legend("cosinus", "sinus")

Pentru o scară logaritmică , folosim argumentul în care tipul este un șir de două caractere, „n” (pentru normal) sau „l” (pentru logaritmic), primul caracter corespunzător axei x și al doilea la l ' y axă . de exemplu logflag = type

plot2d(x, y, logflag = "nl")pentru o axă x liniară și o axă y logaritmică;
plot2d(x, y, logflag = "ll") să aibă două scale logaritmice.

Putem alege tipul de axă cu argumentul în care n este un număr întreg pozitiv: 0 să nu aibă axă, 1 pentru axe „clasice” care se intersectează în dreapta jos, 4 pentru axe „clasice”. Tăiere în centru, 5 pentru axe intersectând la (0, 0) ... axesflag = n

Putem defini numărul de gradații și subgradații ale axelor cu argumentul în care N x este numărul de gradații ale axei x , nx numărul de subgradații ... nax = [nx, Nx, ny, Ny]

Argumentul este utilizat pentru a limita complotul la aria inclusă în dreptunghiul definit de valorile din matrice. rect = [xmin, ymin, xmax, ymax]

Funcția polarplotefectuează un grafic în coordonate polare . Funcția r ( theta ) este trasată de comanda:

polarplot(theta,r)

unde r și theta sunt două matrice de aceeași dimensiune.

Harta unui câmp

Dacă x este un vector coloană de m elemente, y un vector coloană de n elemente și z o matrice m × n , atunci funcția

grayplot(x, y, z)

va asocia o culoare cu fiecare valoare a lui z și va desena o hartă a culorilor, fiecare punct ( x ( i ), y ( j )) având culoarea asociată cu coeficientul z ( i , j ).

Nivelurile de culoare sunt indicate de funcție

xset('colormap', cmap)

unde cmap este o matrice de trei coloane, fiecare rând din care conține culoarea asociată unui nivel, sub formă de RGB (elementele matricei mergând de la 0 la 1). Primul rând al matricei corespunde celui mai scăzut nivel, ultimul rând cu cel mai înalt. Această matrice poate fi generată automat de funcții …colormap, de exemplu ( n niveluri de gri între negru și alb), gradient între albastru și roșu) sau (gradient între roșu și galben). graycolormap(n)jetcolormap(n)hotcolormap(n)

De exemplu, putem folosi xset("colormap", graycolormap(32))32 de niveluri de gri. Putem obține un gradient de la negru la roșu cu

cmap = graycolormap(32); cmap(:, 2:3) = 0

sau cu

r = linspace(0, 32, 32)'; cmap = [r zeros(32, 2)]

și un gradient de la albastru la alb cu

cmap = graycolormap(32); cmap(:, 2:3) = 1

sau cu

r = linspace(0, 32, 32)'; cmap = [r ones(32, 2)]

Nivelurile de culoare sunt, de asemenea, utilizate atunci când se trasează mai multe curbe pe același grafic. În acest caz, gradienții nu oferă un contrast care să faciliteze distincția curbelor vecine; puteți obține nivelurile de culoare implicite cu get(sdf(), "color_map").

Putem desena o curbă de nivel cu funcția

contour2d(x, y, z, n)

unde n este numărul de niveluri pe care dorim să le apară; putem da și valorile nivelurilor z 1 , z 2 , ..., z n printr-un vector

contour2d(x, y, z, [z1, z2, …, zn])

De asemenea, putem desena un câmp vector. Pentru aceasta, avem nevoie de o matrice vx care să aibă componentele de-a lungul x al câmpului vector, o matrice vy care să aibă componentele de-a lungul y al acestui câmp și să folosim funcția

champ(x, y, vx, vy)

Cu funcția champ1, vectorii reprezentați au aceeași lungime, norma câmpului este indicată de culoarea vectorului, urmând principiul explicat pentru grayplot.

Complot 3D

Scilab permite, de asemenea, trasarea suprafețelor tridimensionale ( x , y , z ). Dacă x este o matrice coloană de m elemente, y este o matrice coloană de n elemente, iar z este o matrice m × n , atunci funcția

plot3d(x, y, z)

va desena suprafața punctelor ( x ( i ), y ( j ), z ( i , j )). Dacă este o suprafață reprezentativă pentru o funcție ƒ, avem

z ( i , j ) = f ( x ( i ), y ( j )).

Dacă ƒ este o funcție „externă” (de exemplu definită de deffsau function), putem defini z cu funcția feval(vezi mai sus), sau altfel o folosim fplot3d(x, y, f).

Funcția param3d(fx(t), fy(t), fz(t))trasează curba parametrică; t este un vector care conține valorile succesive ale parametrului.

Cele plot3d1, fplot3d1și funcții param3d1vă permit să utilizați niveluri de culoare pentru a indica valoarea z . Utilizarea este aceeași ca și pentru plot3d, dar nivelurile de culoare sunt indicate de funcție

xset("colormap", cmap)

(Vezi deasupra).

Vederea suprafeței 3D este definită de două unghiuri în grade, θ, rotație în jurul axei Z și α, rotație în jurul axei Y (vezi unghiurile lui Euler ) , ...; plot3d(x, y, z, theta, alpha)param3d(x, y, z, theta, alpha)

plot3d(x, y, z, 0, 0) oferă o vedere de sus, similară cu hărțile 2D, proiecția suprafeței pe planul XY de-a lungul axei Z;
plot3d(x, y, z, 90, 0) oferă o vedere frontală, proiecția suprafeței pe planul XZ de-a lungul axei Y;
plot3d(x, y, z, 0, 90) oferă o vedere laterală, proiecția suprafeței pe planul YZ de-a lungul axei X;
plot3d(x, y, z, 45, 45)este vizualizarea implicită , tip de perspectivă izometrică.

De asemenea, putem defini limitele axelor cu cuvântul cheie ebox :

plot3d(x, y, z, ebox=[xmin, xmax, ymin, ymax, zmin, zmax])
plot3d(x, y, z, theta, alpha, ebox=[xmin, xmax, ymin, ymax, zmin, zmax])

Reprezentarea datelor statistice

Dacă x este un vector, funcția , n fiind un număr întreg, va tăia intervalul valorilor luate de coeficienții lui x în n felii de lățime egală și va trasa histograma distribuției valorilor în funcție de aceste felii . Dacă n este un vector ai cărui coeficienți sunt strict crescători, valorile coeficienților lui n sunt folosite pentru a determina feliile. histplot(n, x)

Dacă x este o matrice, desenați o histogramă 3D astfel încât paralelipipedul situat la ( i , j ) să aibă înălțimea x ( i , j ). Ca și în cazul tuturor funcțiilor de grafic tridimensional, putem defini unghiul de vizualizare cu θ și α. hist3d(x)

Desen

Este posibil să desenați figuri geometrice direct pe grafic.

Funcția xpoly(x, y, "lines", 1)face posibilă trasarea unui poligon închis, xfiind lista absciselor vârfurilor (sub forma unui vector sau a unei matrice) și yfiind lista ordonatelor vârfurilor (este o matrice de aceeași dimensiune ca x). Funcția xfpoly(x, y, "lines", 1)vă permite să desenați un poligon umplut.

Funcția xrect(x, y, l, h)desenează un dreptunghi al cărui punct din stânga sus este ( x , y ), lățimea l și înălțimea h . Funcția xfrect(x, y, l, h)desenează un dreptunghi umplut.

Funcția scrie linia șirului pe grafic, punctul din stânga jos al textului fiind în punctul ( x , y ). xstring(x, y, "chaîne")

Funcția xarc(x, y, l, h, a1, a2)desenează un arc al unei elipse incluse în dreptunghiul al cărui punct stânga sus este ( x , y ), cu lățimea l și înălțimea h . Fiecare grad de unghi este împărțit în 64 de sectoare, arcul începe de la unghiul trigonometric a 1 × 64 ° și urcă până la unghiul ( a 1 + a 2) × 64 °. Funcția xfarc(x, y, l, h)desenează un arc eliptic umplut.

Pentru a modifica proprietățile liniilor desenelor, trebuie să utilizați comanda . Principalele proprietăți ale unui obiect sunt:set("propriété", valeur)

line_style : tipul liniei; este un număr întreg, 0 pentru o linie continuă, 2 pentru linii punctate lungi, trei pentru linii punctate scurte, 4 pentru o linie axială (alternând linie și punct) ...
thickness : grosimea liniei, ca număr întreg pozitiv;
mark_size : în cazul unui complot după markere, dimensiunea markerilor.

De asemenea, puteți asocia o variabilă cu elementul desenat; acest lucru se face cu funcția care
variable = get("hdl")
hdlînseamnă mâner (literalmente „mâner”, intermediar al acțiunii). Pentru a defini proprietatea acestui element, o facem

variable.propriété = valeur

Aceste două metode sunt valabile indiferent de obiect (curbă, poligon, arcul unei elipse etc.).

de exemplu

xarc(0, 1, 0.5, 0.5, 0, 360*64) // ellipse set("line_style", 2) // pointillés

xarc(0, 1, 0.5, 0.5, 0, 360*64) // ellipse a=get("hdl") a.line_style=2 // pointillés Formatare, axe și ferestre

Funcția este xsetutilizată pentru a defini aspectul:

fontul absolvirilor și titlurilor :, unde xset("font", type, taille)
- mărimea este un număr care desemnează dimensiunea caracterelor, în unități arbitrare;
- type este un număr care desemnează tipul de font: 1 pentru literele grecești (font Symbol), 2-5 pentru un font serif de tip Times (2 pentru literele romane, 3 în italice, 4 în bold, 5 în bold în italice); 6-9 pentru un font Arial sans serif (6 pentru litere romane, 7 cu caractere cursive, 8 cu caractere aldine, 9 cu caractere aldine)
grosimea liniei centrale și a graficului: unde e este un număr care desemnează grosimea în unități arbitrare;xset("thickness", e)
mărimea marcajelor (dacă este cazul, vezi mai jos) cu .xset("mark size", taille)

În ceea ce privește toate obiectele grafice, puteți modifica proprietățile axelor atribuindu-le unei variabile folosind comanda var = get("current_axes"). Principalele proprietăți sunt:

x_locationși y_location : să ia valorile "top", "middle"sau în "bottom"funcție de faptul dacă dorim axa să fie în sus, prin origine, sau în jos;
isoview : valabil 'on'dacă vrem ca cântarele să fie identice pe axe, "off"dacă cântarul este liber;
sub_ticks : matrice în care nx și ny este numărul de sub-absolviri (sunt necesare 4 sub-absolviri pentru ca absolvirea principală să fie împărțită în 5);[nx, ny]

Exemplu:

a = get("current_axes") a.x_location = "middle" a.y_location = "middle" a.isoview = "on" a.sub_ticks = [4,4]

Puteți plasa mai multe parcele unul lângă altul cu instrucțiunile subplot :

subplot(m, n, i)plasează graficul urmând instrucțiunile de la i - a celulei (în ordinea de citire europeană) de m × n matrice ; traseul poate avea mai multe instrucțiuni plot, xset, xtitle.

Funcția dă un titlu graficului și axelor. Funcția pune un titlu în mijlocul graficului. Funcția șterge fereastra grafică. xtitle("nom du graphique", "axe des x", "axe des y")titlepage("titre")clf

Exemplu

Iată graficul pe care îl obținem cu instrucțiunile de mai jos.

clear; clf; deff("[z] = f(x, y)", "z = sin(x) * cos(y)") xset("colormap", jetcolormap(32)) x = %pi * [-1:0.05:1]'; y = x; z = feval(x, y, f); subplot(2, 2, 1) grayplot(x, y, z) subplot(2, 2, 2) contour2d(x, y, z, 5) subplot(2, 2, 3) plot3d1(x, y, z, 0, 90) subplot(2, 2, 4) plot3d1(x, y, z, 70, 70)

Programare

Puteți introduce instrucțiunile Scilab într-un fișier text cu extensia numelui fișierului .sce. Aceasta se numește un script Scilab.

Scilab acceptă o serie de instrucțiuni:

executarea condiționată if condition then, …, else, …, end
bucla iterativă saufor variable = début : fin, …, endfor variable = début : pas : fin, …, end
bucla iterativă precondiționată: sauwhile condition do, …, endwhile condition do, …, else, …, end

Este posibil să definiți funcții prin trecerea parametrilor. Funcția este un subrutină cu variabile proprii și care poate conține bucle, ramuri condiționate etc. De exemplu, pentru a defini o funcție f (x):

function [y] = f(x) … endfunction

Parametrul x este trecut la funcția ƒ; valoarea returnată de ƒ va fi cea atribuită lui y în funcție.

Dacă un fișier conține doar definiții de funcții, atunci i se oferă extensia .sci. Acest lucru face posibilă crearea de biblioteci de funcții comune mai multor scripturi, ceea ce facilitează întreținerea software-ului (îmbunătățirile beneficiază de toate scripturile, o eroare va apărea în toate scripturile și, prin urmare, va fi detectată și corectată mai rapid). Acest fișier .scieste apoi încărcat de script cu comanda exec("chemin/nomdefichier").

Puteți salva mediul, adică toate variabilele, inclusiv funcțiile, cu comanda . Aceasta creează un fișier binar (Scilab nu adaugă o extensie). Acest mediu poate fi reîncărcat cu funcția . save("fichier")load("fichier")

De asemenea, puteți scrie instrucțiunile într-un fișier text, apoi copiați / lipiți din editorul de text în linia de comandă Scilab. Codul sursă poate conține comentarii introduse de două fracțiuni //.

Mediu inconjurator

În Scilab, mediul este toate variabilele (inclusiv funcțiile) care au fost definite; mediul conține o serie de variabile predefinite. Setul de variabile este dat de comandă who.

Când utilizați o funcție, funcția este executată într-un mediu nou, o copie a mediului inițial. Variabilele care sunt modificate acolo nu sunt modificate în mediul inițial (lucrăm doar cu variabile locale), doar rezultatul funcției este returnat.

Puteți deschide un mediu intenționat, cu funcția pause ; promptul devine apoi -1->, indicând faptul că suntem în primul nivel al sub-mediului. Suntem, de asemenea, într-o astfel de configurație atunci când întrerupem executarea unei funcții (de exemplu, cu combinația de taste CTRL + C). Pentru a reveni la mediul anterior, trebuie să utilizați comanda return.

Dacă se folosește returnfără argument, variabilele nu sunt transmise mediului părinte. Este posibil să se transmită variabilele a 1, a 2, ..., an în mediul părinte, cu sintaxa , unde x 1, x 2, ..., xn sunt numele variabilelor din mediul părinte. (x1, x2, …, xn) = return(a1, a2, …, an)

Comanda clearface posibilă „curățarea” unui mediu, adică ștergerea tuturor variabilelor.

Interfață cu alte limbi

Scilab se interfață ușor cu limbajul de scriptare Tcl-Tk și vă permite să afișați interfețe grafice. Funcția TCL_EvalFile()evaluează scripturile Tcl-Tk care pot apela funcțiile Scilab prin trecerea parametrilor prin ScilabEval.

Exemplu: Calculul unei distanțe ale cărei valori x, y sau z pot varia datorită mișcării unui cursor în interfața grafică scrisă în Tcl-Tk .

Creăm trei fișiere ( lancement.sce, distance.sci, gui.tcl).

Cele două fișiere Scilab:

// lancement.sce - lancement de l’application exec distance.sci; TCL_EvalFile("gui.tcl"); // distance.sci - fonction Scilab function dist = distance(x, y, z) dist = sqrt(x*x + y*y + z*z) endfunction

Și codul Tcl-Tk:

# gui.tcl - interface graphique global x y z dist set x 10; set y 10; set z 10; set dist " " toplevel .w scale .w.scx -from 0 -to 200 -length 200 -resolution 1 -label "X" \ -orient horiz -bd 1 -showvalue true -variable x \ -command CalculDistance scale .w.scy -from 0 -to 200 -length 200 -resolution 1 -label "Y" \ -orient horiz -bd 1 -showvalue true -variable y \ -command CalculDistance scale .w.scz -from 0 -to 200 -length 200 -resolution 1 -label "Z" \ -orient horiz -bd 1 -showvalue true -variable z \ -command CalculDistance label .w.lt -text Distance label .w.ldist -textvariable dist -bg lightblue eval pack [winfo children .w] proc CalculDistance w { global x y z dist ScilabEval "dist = distance($x,$y,$z) ; TK_SetVar('dist',string(dist));" }

Note și referințe

Note

Numele acestei funcții, gornist , se referă la metoda de Horner utilizată la numeric calcula un polinom, facand cel mai mic număr posibil de multiplicări: . ${\ displaystyle a_ {0} + a_ {1} x + a_ {2} x ^ {2} + ... + a_ {n} x ^ {n} = a0 + x \, (a1 + x \, ( a_ {2} + x \, (... + x \, a_ {n}) ...))}$

Referințe

„ https://www.scilab.org/download/6.1.0 ”
„ mfile2sci (funcția de conversie MATLAB în Scilab M-file) ” (accesat la 18 februarie 2020 ) , consultați și „ Ajutor pentru conversia MATLAB în Scilab ” (accesat la 18 februarie 2020 ) .
http://www.scicos.org/history.html
http://www.scilab.org/scilab/history
http://raweb.inria.fr/rapportsactivite/RA94/meta2/META2.3.1.1.html
„ Sciweb ” (accesat la 9 februarie 2016 )
Licență Scilab
Definiția software-ului semi-liber
Anunț de modificare a licenței

Vezi și tu

Articole similare

Tcl / Tk

Instrument asociat

Xcos

Software similar

MATLAB
GNU Octave
SageMath
FreeMat
SciPy , Instrumente de calcul științifice pentru Python
Julia (limbaj de programare)

linkuri externe