View source for Упражнение 3. Matlab

== Управляващи оператори ==

=== if ===
<code><pre>
if <expression>
  statment
end

if <expression>
 statement;
else
 statement;
end

if <expression>
 statement;
elseif
 statement;
else
 statement;
end
</pre></code>

=== Релации и логически оператори ===
< , <= , >, >= , ~=, ==

&, &&, |, ||, ~

<span style="red">Логическо равенство да не се ползва за числа с плаваща запетая </span>


=== switch ===
 switch expression
  case val1
    statement
  case {val2, val3
    statement
  otherwise
    statement
 end

Логическо равенство да не се ползва за числа с плаваща запетая

=== for ===
 for index = nachalo:stypka:kraj % ako nqma stypka tq e 1
   statement
 end

 for i = A % A e vektor/matrica
   statement
 end

=== while ===
 while expression
  statemnet
 end

=== Допълнителни управляващи оператори ===

'''break'''

'''continue''' - преминаване към следваща итерация на for или while цикъл

'''pause''' - пауза до натискане на клавиш ( pause(4) <=> sleep(4) )

'''keyboard''' - predawa uprawlenieto  на клавиатурата (използва се при дебъгване). Спира се програмата и може да проверяваме всички стойност

'''return''' - връща се към програмата след keyboard

== файл функции ==

Записва се като ime.m 
 function [a, b, c] = ime(x, y, z)
   global p, q;
   a = x;
   b = y;
   c = z;
 end   


<code><pre>
function y = signum(x)
  % сигнум функция
  if x>0
     y = 1;
  elseif x<0
     y = -1;
  else
     0
  end
end
</pre></code>

<code><pre>
>> signum(-5)

ans =

    -1

>> signum(0)

ans =

     0

>> signum(5)

ans =

     1
</pre></code>

== Символни преобразувания ==
clear - изчистване на workspace
=== Задаване на символни величини ===

оператори за създаване на символни величини

sym - по-универсален

 x = sym('x') ; 
 x = 
 x

 >> y = pi
 y =
    3.1416

Символите се показват по вляво!

Дефиниране на цял стринг
 >> eq = sym ('a*x^2')
 eq =
 a*x^2

 Диференциране по x
 >> diff(eq,x)
 ans =
 2*a*x

Matrica  на хилберт

 H = hilb(5)
 H =
    1.0000    0.5000    0.3333    0.2500    0.2000
    0.5000    0.3333    0.2500    0.2000    0.1667
    0.3333    0.2500    0.2000    0.1667    0.1429
    0.2500    0.2000    0.1667    0.1429    0.1250
    0.2000    0.1667    0.1429    0.1250    0.1111

Извеждане в символичен вид
 >> sym(H)
 ans =
 
 [   1, 1/2, 1/3, 1/4, 1/5]
 [ 1/2, 1/3, 1/4, 1/5, 1/6]
 [ 1/3, 1/4, 1/5, 1/6, 1/7]
 [ 1/4, 1/5, 1/6, 1/7, 1/8]
 [ 1/5, 1/6, 1/7, 1/8, 1/9]
 
В този случай няма да има грешка от закръгляне

 >> det(H)
 ans =
   3.7493e-12

 Sled  като отдясно всичко е символни величини и от ляво става символна

 >> syms x a b z
 >> f = sin(x)*exp(z)^a/b
  f =
  (exp(z)^a*sin(x))/b

По ясна визуализация
 >> pretty(f)

        a
  exp(z)  sin(x)
  --------------
        b

Получаване на директно символна матрица
 >> syms a b c
 >> A = [a b c; b c a; c a b]
 
 A =
 
 [ a, b, c]
 [ b, c, a]
 [ c, a, b]

Изчисляване на детерминанта
 >> det(A)
 ans =
 - a^3 + 3*a*b*c - b^3 - c^3


 >> pretty(inv(A))
 
  +-                                                                              -+
  |                  2                         2                         2         |
  |           b c - a                   a c - b                   a b - c          |
  |  - ----------------------, - ----------------------, - ----------------------  |
  |     3              3    3     3              3    3     3              3    3  |
  |    a  - 3 a b c + b  + c     a  - 3 a b c + b  + c     a  - 3 a b c + b  + c   |
  |                                                                                |
  |                  2                         2                         2         |
  |           a c - b                   a b - c                   b c - a          |
  |  - ----------------------, - ----------------------, - ----------------------  |
  |     3              3    3     3              3    3     3              3    3  |
  |    a  - 3 a b c + b  + c     a  - 3 a b c + b  + c     a  - 3 a b c + b  + c   |
  |                                                                                |
  |                  2                         2                         2         |
  |           a b - c                   b c - a                   a c - b          |
  |  - ----------------------, - ----------------------, - ----------------------  |
  |     3              3    3     3              3    3     3              3    3  |
  |    a  - 3 a b c + b  + c     a  - 3 a b c + b  + c     a  - 3 a b c + b  + c   |
  +-

=== Подразбиращи се символни променливи ===

При повече променливи се диференцира по най близката до "х", ако няма зададена

  function  F  = intAB( f )
  % интеграл от произволна функция
  % a,b, - интервал на интегриране
  %UNTITLED3 Summary of this function goes here
  %   Detailed explanation goes here
    syms x a b;
    F = int(f, x, a, b);
  end

 >> y = intAB( sin(x) )
 y =
 cos(a) - cos(b)


=== Аритметика с променлива точност ===
Три типа аретмитични операции

*Numеric - тип double (точност)
*Rational - точната аритметика
*VPA - Variable Precision Arithmetic - сами задаваме броя на значещите числа (32 по подразбиране)
 

 >> 1/2 +1/3
 ans =
   0.833333333333333 - този резултат не е точен

Достатъчен е да обявим един параметър в символен тип и всички се приемат за символни
 >> sym(1/2) + 1/3
 ans =
 5/6

 >> vpa(1/2 +1/3)
 ans =
 0.83333333333333325931846502498956

 >> vpa(1/2 +1/3, 20)
 ans =
 0.833333333333333

 >> vpa(1/2 +1/3)
 ans =
 0.83333333333333325931846502498956397175788879394531
 
 >>a = double(ans)
 a =
 0.833333333300000

 1.0e10+ 1.0e-10
 ans =
    1.000000000000000e+10
 
 sym('1.0e10')+ sym('1.0e-10')
 ans =
 10000000000.0000000001

Матрица double  точност

 F= [exp(1) sqrt(2); log(3) rand]
 
 F =
 
   2.718281828459046   1.414213562373095
   1.098612288668110   0.814723686393179

 V = vpa(F,30)
 
 V =
  
 [ 2.71828182845904553488480814849,  1.41421356237309514547462185874]
 [ 1.09861228866810956006361266191, 0.814723686393178936349102059467]


 S = sym(F)
 S =
  
 [ 3060513257434037/1125899906842624,                           2^(1/2)]
 [ 2473854946935173/2251799813685248, 7338378580900475/9007199254740992]

Сравнява се по елементно
 >> double(V) == double(S)
 ans =
     1     1
     1     1

== опростяване и преобразуване на изрази ==

collect - използва се с полиноми и групира събираемите по степента
<code><pre>
>> p = sym('(x+a)^4 +(x-1)^3 - (x-a)^2 - a*x +x-3')
 
p =
 
x + (x - 1)^3 - a*x + (a + x)^4 - (a - x)^2 - 3
 
>> pc = collect(p, x)
??? Undefined function or variable 'x'.
 
>> pc = collect(p)
 
pc =
 
x^4 + (4*a + 1)*x^3 + (6*a^2 - 4)*x^2 + (4*a^3 + a + 4)*x + a^4 - a^2 - 4
</code></pre>
Групирането автоматично ще избере х

Ако искаме да групираме по а, и а не е обявено с  "syms a"
 
 pc = collect(p, 'a')
 
 pc =
 
 a^4 + (4*x)*a^3 + (6*x^2 - 1)*a^2 + (4*x^3 + x)*a + x + (x - 1)^3 - x^2 + x^4 - 3

=== coeffs ===

 >> syms a b c d x;
 >> p = a*x^3 - 2*b*x^2 + 3*c*x - 4*d;
 >> coeffs(p)
 
 ans =
 [ -4, 3, -2, 1]

=== horner ===

=== expand ===
Развива израз, разкрива скоби ...

 >> expand( (x - 1)*(x-2)*(x-3))
 ans =
 x^3 - 6*x^2 + 11*x - 

 >> expand( sin(x+y))
 ans =
 cos(x)*sin(y) + cos(y)*sin(x)

=== factor ===
Obratnoto na expand

<pre>
>> expand( (x - 1)*(x-2)*(x-3))
 
ans =
 
x^3 - 6*x^2 + 11*x - 6
 
>> factor(ans)
 
ans =
 
(x - 3)*(x - 1)*(x - 2)
</pre>

=== sym2poly poly2sym ===
<pre>
>> syms x
>> ps = x^3-2*x^2+3*x + 4;
>> %da go preobrazuvame v polynom;
>> p = sym2poly(ps)

p =

     1    -2     3     4

>> qs = poly2sym(p)
 
qs =
 
x^3 - 2*x^2 + 3*x + 4
</pre>

=== simplify, simple === 

syms x
 >> f = int(1/(x^12-1))
 f =
 atan(-(3^(1/2)*x - i*x)/(3^(1/2)*i - 1))*(i/12 - 3^(1/2)/12) - atan((x + 3^(1/2)*i*x)/(3^(1/2)*i - 1))*((3^(1/2)*i)/12 + 1/12) - atan((x - 3^(1/2)*i*x)/(3^(1/2)*i + 1))*((3^(1/2)*i)/12 - 1/12) - (i*atan(-i*x))/6 - atan((3^(1/2)*x + i*x)/(3^(1/2)*i + 1))*(i/12 + 3^(1/2)/12) - atan(x)/6
 
<pre>
 syms x
>> f = int(1/(x^12-1))
 
f =
 
atan(-(3^(1/2)*x - i*x)/(3^(1/2)*i - 1))*(i/12 - 3^(1/2)/12) - atan((x + 3^(1/2)*i*x)/(3^(1/2)*i - 1))*((3^(1/2)*i)/12 + 1/12) - atan((x - 3^(1/2)*i*x)/(3^(1/2)*i + 1))*((3^(1/2)*i)/12 - 1/12) - (i*atan(-i*x))/6 - atan((3^(1/2)*x + i*x)/(3^(1/2)*i + 1))*(i/12 + 3^(1/2)/12) - atan(x)/6
 
>> simplify(diff(f))
 
ans =
 
1/(x^12 - 1)
 
>> simple(diff(f))
ans =
 
1/(x^12 - 1)
</pre>

=== sub ===

Zaместване на буква с израз
<code><pre>
 f = sym('(a^2 + b^2)/(a^2 - b^2) + a^4/b^4')
 
f =
 
(a^2 + b^2)/(a^2 - b^2) + a^4/b^4
 
>> f = subs( f, {'a' , 'b'}, {'(exp(x) + exp(-x))', 'sin(x) + cos(x)'})
 
f =
 
(1/exp(x) + exp(x))^4/(cos(x) + sin(x))^4 - ((cos(x) + sin(x))^2 + (1/exp(x) + exp(x))^2)/((cos(x) + sin(x))^2 - (exp(-x) + exp(x))^2)
 
>> pretty(f)

  /   1             \4                    2   /   1             \2
  | ------ + exp(x) | (cos(x) + sin(x))  + | ------ + exp(x) |
  \ exp(x)          /                         \ exp(x)          /
  -------------------- - -----------------------------------------
                    4                     2                     2
   (cos(x) + sin(x))     (cos(x) + sin(x))  - (exp(-x) + e
</pre></code>




== Решаване на алгебрични уравнения ==

=== solve === 
Решаване на отделни уравнения и системи от уравнения
solve(f);
<pre<
>> f = 'a*x^2 +b.x +c'

f =

a*x^2 +b.x +c

>> solve(f)
 
ans =
 
  (- bx - c)^(1/2)/a^(1/2)
 -(- bx - c)^(1/2)/a^(1/2)
 
>> pretty(solve(f))

  +-                 -+
  |             1/2   |
  |   (- bx - c)      |
  |   -------------   |
  |        1/2        |
  |       a           |
  |                   |
  |              1/2  |
  |    (- bx - c)     |
  |  - -------------  |
  |         1/2       |
  |        a          |

</pre>

sol = solve('cos(2*x) + sin(x) = 1')
 
sol =
 
        0
     pi/6
 (5*pi)/6

=== Система от уравнения  solve(f1,f2), solve(f1,f2, x,y) ===

Два начина за адресиране на решението

<pre>
>> f1= x*(2-y) - cos(x)*exp(y)
 
f1 =
 
- exp(y)*cos(x) - x*(y - 2)
 
>> f2 = 2 + x - y - cos(x) -exp(y)
 
f2 =
 
x - y - cos(x) - exp(y) + 2
 
>> [x, y] = solve
>> 
>> [x,y] = solve(f1,f2)
 
x =
 
0.73908513321516064165531208767387340401341175890075746
 
 
y =
 
0.44285440100238858314132799999933681971626212937347968

</pre>

== математически анализ ==
=== limit ===

 >> syms x
 >> limit(sin(x)/x, x, 0)
  
 ans =
 1

 >> syms n
 >> limit((1+x/n)^n, n , Inf)
  ans =
  exp(x)

=== diff ===

diff(y), diff(y,x)
<pre>
>> syms y, f = exp(-3*x)*sin(x*y)/sqrt(y)
 
f =
 
sin(x*y)/(y^(1/2)*exp(3*x))
 
>> diff(f,x)
 
ans =
 
(y^(1/2)*cos(x*y))/exp(3*x) - (3*sin(x*y))/(y^(1/2)*exp(3*x))
 
>> pretty(diff(f,y))

   x cos(x y)       sin(x y)
  ------------- - -------------
   1/2               3
  y    exp(3 x)      -
                     2
                  2 y  exp(3 x)
>> 

</pre>
[[Category:Matlab]]