Octave Programming Examples

aaaaaa

octave

function y=complejo
a= input ('ingrese lap parte real: ')
b= input ('ingrese lap parte compleja: ')
z=sqrt(a^2+b^2)
theta=atan(b/a)

Execute MATLAB/Octave Online

octave

n=10
x = linspace(1628,1885,11);
y = [791, 856, 978, 1050, 1262, 1544, 1650, 2532, 6122, 8170,11560];
p = polyfit(x,y,n)

Execute MATLAB/Octave Online

octave

Clear all;
x=double(imread(‘lena.jpg’));
figure,imshow(x/255);
y=x;
a=zeros(300,500);
a(100:250 ,100:350) =1;
figure, imshow(a);
% watermarking
x1=x( :, :, 1);
x2=x( :, :, 2);
x3=x( :, :, 3);
dx1=dct2(x1);  dx11=dx1;
dx2=dct2(x2);  dx22=dx2;
dx3=dct2(x3);  dx33=dx3;
load m.dat  %binary mask for watermarking
g=10     %coefficient of watermarking  strength
(rm,cm)= size (m);
dx1(1:rm,1:cm)= dx1(1:rm,1:cm)+g*m;
dx2(1:rm,1:cm)= dx2(1:rm,1:cm)+g*m;
dx3(1:rm,1:cm)= dx3(1:rm,1:cm)+g*m;
figure , imshow(dx1);
figure , imshow(dx2);
figure , imshow(dx3);
y1=idct2(dx1);
y2=idct2(dx2);
y3=idct2(dx3);
y( : , : , 1)=y1;
y( : , : , 2)=y2;
y( : , : , 3)=y3;
figure, imshow(y1);
figure, imshow(y2);
figure, imshow(y3);
figure, imshow(y);
figure, imshow(y/255);
z=y;
(r,c,s) = size(z)

asss

octave

p = 1000;
in = 4.5;
t = 0;
while p~=50000
	p = p + in*p*0.01;
	p = p+1000;
	t = t+1;
end
disp(t)
help i

hghh

octave

t=(-3:.001:5);
rect1=t>=-2;
rect2=t>=2;
subplot(2,2,1);
plot(t,rect1-rect2);
xlabel('time');
ylabel('amplitude');
legend('rectangular function');

RunThat

octave

# **Toutes les dimensions sont en mètres**
# Dimensions de la navette
global navette_cyl_h = 27.93
global navette_cyl_r = 3.5
global navette_cone_h = 9.31
global navette_cone_r = navette_cyl_r

global navette_masse_kg = 109 * 1000

# Dimensions du réservoir
global reservoir_cyl_h = 39.1
global reservoir_cyl_r = 4.2
global reservoir_cone_h = 7.8
global reservoir_cone_r = reservoir_cyl_r

global reservoir_cyl_h_hydrogene = (reservoir_cyl_h + reservoir_cone_h)*(2/3)
global reservoir_cyl_h_oxygene = (reservoir_cyl_h - reservoir_cyl_h_hydrogene)

global reservoir_masse_kg_hydrogene = 108 * 1000
global reservoir_masse_kg_oxygene = 631 * 1000

# Dimensions des propulseurs d'appoint
global booster_cyl_h = 39.9
global booster_cyl_r = 1.855
global booster_cone_h = 5.6
global booster_cone_r = booster_cyl_r

global booster_masse_kg = 469 * 1000


function centre_de_masse = CentreDeMasse(AngRot, posNL)
  %Navette
  global navette_cyl_h;
  global navette_cone_h;
  global navette_cyl_r;
  global navette_cone_r;
  global reservoir_cyl_h;
  global reservoir_cone_h;
  global reservoir_cyl_r;
  global reservoir_cone_r;
  global reservoir_cyl_h_hydrogene;
  global reservoir_cyl_h_oxygene;
  global booster_cyl_r;
  global booster_cone_r;
  global booster_cyl_h;
  global booster_cone_h;
  
  global navette_masse_kg;
  global reservoir_masse_kg_hydrogene;
  global reservoir_masse_kg_oxygene;
  global booster_masse_kg;
  
  %Cylindre de la navette
  global navette_cyl_c = [0; 0; navette_cyl_h/2];
  %Cône de la navette
  global navette_cone_c = [0; 0; navette_cyl_h + navette_cone_h/4];
  
  %Cylindre de la réservoir (2/3 en bas)
  global reservoir_cyl_hydrogene_c = [0; navette_cyl_r + reservoir_cyl_r; reservoir_cyl_h_hydrogene * 1/2];
  %Cylindre de la réservoir (1/3 en haut)
  global reservoir_cyl_oxygene_c = [0; navette_cyl_r + reservoir_cyl_r; reservoir_cyl_h - reservoir_cyl_h_oxygene /2];
  %Cône de la réservoir
  global reservoir_cone_c = [0; navette_cone_r +  reservoir_cone_r; reservoir_cyl_h + reservoir_cone_h/4];

  % Propulseur gauche
  global booster_cyl_gauche_c = [
    -(reservoir_cyl_r + booster_cyl_r);
    (navette_cyl_r + reservoir_cyl_r);
    booster_cyl_h/2];

  global booster_cone_gauche_c = [
    -(reservoir_cyl_r + booster_cyl_r);
    (navette_cyl_r + reservoir_cyl_r);
    (booster_cyl_h + booster_cone_h/4)];

  % Propulseur droite
  global booster_cyl_droite_c = [
    -booster_cyl_gauche_c(1);
    booster_cyl_gauche_c(2);
    booster_cyl_gauche_c(3)];

  global booster_cone_droite_c = [
    -booster_cone_gauche_c(1);
    booster_cone_gauche_c(2);
    booster_cone_gauche_c(3)];
    
  % Volume des parties de la navette 
  navette_cyl_volume = navette_cyl_r^2 * pi * navette_cyl_h;
  navette_cone_volume = (navette_cone_r^2 * pi * navette_cone_h) / 3;
  navette_total_volume = navette_cyl_volume + navette_cone_volume;
  
  % Masse des parties de la navette
  global navette_cyl_masse_kg = navette_cyl_volume / navette_total_volume * navette_masse_kg;
  global navette_cone_masse_kg = navette_cone_volume / navette_total_volume * navette_masse_kg;
  
  % Volume des parties des propulseurs
  booster_cyl_volume = (pi*booster_cyl_r^2) * booster_cyl_h;
  booster_cone_volume = (pi*booster_cone_h*booster_cone_r^2) / 3;
  booster_total_volume = booster_cyl_volume + booster_cone_volume;        
  
  % Masse des parties des propulseurs
  global booster_cyl_masse_kg = booster_cyl_volume / booster_total_volume * booster_masse_kg;
  global booster_cone_masse_kg = booster_cone_volume / booster_total_volume * booster_masse_kg;
  
  % Volume des parties du réservoir
  reservoir_cyl_oxygene_volume = (pi*reservoir_cyl_r^2) * reservoir_cyl_h_oxygene;
  reservoir_cone_volume = (pi*reservoir_cone_h*reservoir_cone_r^2) / 3;
  reservoir_oxygene_total_volume = reservoir_cyl_oxygene_volume + reservoir_cone_volume;
  
  % Masse des parties du réservoir
  global reservoir_cyl_oxygene_masse_kg = reservoir_cyl_oxygene_volume / reservoir_oxygene_total_volume * reservoir_masse_kg_oxygene; 
  global reservoir_cone_oxygene_masse_kg = reservoir_cone_volume / reservoir_oxygene_total_volume * reservoir_masse_kg_oxygene;
  
  % Masse totale de la fusée
  global masse_totale = reservoir_masse_kg_hydrogene + reservoir_masse_kg_oxygene + navette_masse_kg + booster_masse_kg * 2;
  
  % Somme pondérée
  global c_de_masse = (navette_cone_c * navette_cone_masse_kg + navette_cyl_c * navette_cyl_masse_kg +
                     reservoir_cone_c * reservoir_cone_oxygene_masse_kg + reservoir_cyl_hydrogene_c * reservoir_masse_kg_hydrogene + 
                     reservoir_cyl_oxygene_c * reservoir_cyl_oxygene_masse_kg +
                     (booster_cone_droite_c + booster_cone_gauche_c)* booster_cone_masse_kg +
                     (booster_cyl_droite_c + booster_cyl_gauche_c) * booster_cyl_masse_kg) / masse_totale;
  
  % Matrice de rotation autour de x
  R_x = [1, 0, 0; 0, cos(AngRot), -sin(AngRot); 0, sin(AngRot), cos(AngRot)];
  % Appliquer la rotation
  %c_rot = R_x * (c_de_masse + posNL);
  
  c_rot = R_x * c_de_masse;
  %Appliquer la translation
  centre_de_masse = c_rot + posNL;  
  
endfunction

function moment_inertie = MomentInertie(AngRot, posNL)
  global navette_cyl_h;
  global navette_cone_h;
  global navette_cyl_r;
  global navette_cone_r;
  global reservoir_cyl_h;
  global reservoir_cone_h;
  global reservoir_cyl_r;
  global reservoir_cone_r;
  global reservoir_cyl_h_hydrogene;
  global reservoir_cyl_h_oxygene;
  global booster_cyl_r;
  global booster_cone_r;
  global booster_cyl_h;
  global booster_cone_h;
  
  global reservoir_cyl_oxygene_masse_kg;
  global reservoir_cone_oxygene_masse_kg;
  global reservoir_masse_kg_hydrogene;
  global navette_cone_masse_kg;
  global navette_cyl_masse_kg;
  global booster_cyl_masse_kg;
  global booster_cone_masse_kg;
  global masse_totale;
  % centre de masses
  global navette_cyl_c;
  global navette_cone_c;
  global reservoir_cyl_hydrogene_c;
  global reservoir_cyl_oxygene_c;
  global reservoir_cone_c;
  global booster_cyl_gauche_c;
  global booster_cyl_droite_c;
  global booster_cone_droite_c;
  global booster_cone_gauche_c;
  global c_de_masse;
  
  % Moment inertie locale
  %reservoir (local)
  reservoir_cone_oxygene_I = MomentInertieCone(reservoir_cone_oxygene_masse_kg , reservoir_cone_r, reservoir_cone_h);
  reservoir_cyl_oxygene_I = MomentInertieCyl(reservoir_cyl_oxygene_masse_kg , reservoir_cyl_r, reservoir_cyl_h_oxygene);
  reservoir_cyl_hydrogene_I = MomentInertieCyl(reservoir_masse_kg_hydrogene , reservoir_cyl_r, reservoir_cyl_h_hydrogene);
  
  %navette(local)
  navette_cone_I = MomentInertieCone(navette_cone_masse_kg , navette_cone_r, navette_cone_h);
  navette_cyl_I = MomentInertieCyl(navette_cyl_masse_kg , navette_cyl_r, navette_cyl_h);
  
  %propulseurs(local)
  booster_cone_I = MomentInertieCone(booster_cone_masse_kg , booster_cone_r, booster_cone_h);
  booster_cyl_I = MomentInertieCyl(booster_cyl_masse_kg , booster_cyl_r, booster_cyl_h);
  
  %distance entre les centres de masses des parties et le centre de masse fusee
  d_reservoir_cone = reservoir_cone_c - c_de_masse;
  d_reservoir_cyl_oxygene = reservoir_cyl_oxygene_c - c_de_masse;
  d_reservoir_cyl_hydrogene = reservoir_cyl_hydrogene_c - c_de_masse;
  d_navette_cone = navette_cone_c - c_de_masse;
  d_navette_cyl = navette_cyl_c - c_de_masse;
  d_booster_cyl_gauche = booster_cyl_gauche_c - c_de_masse;
  d_booster_cyl_droite = booster_cyl_droite_c - c_de_masse;
  d_booster_cone_gauche = booster_cone_droite_c - c_de_masse;
  d_booster_cone_droite = booster_cone_gauche_c - c_de_masse;
  
  % Moment inertie par rapport au centre de masse de la fusee
  % reservoir
  reservoir_cone_I_G = reservoir_cone_oxygene_I +  reservoir_cone_oxygene_masse_kg  * MatriceTranslation(d_reservoir_cone);  
  reservoir_cyl_oxygene_I_G = reservoir_cyl_oxygene_I + reservoir_cyl_oxygene_masse_kg  * MatriceTranslation(d_reservoir_cyl_oxygene);
  reservoir_cyl_hydrogene_I_G = reservoir_cyl_hydrogene_I + reservoir_masse_kg_hydrogene  * MatriceTranslation(d_reservoir_cyl_hydrogene);
  
  %navette
  navette_cone_I_G = navette_cone_I + navette_cone_masse_kg  * MatriceTranslation(d_navette_cone);
  navette_cyl_I_G = navette_cyl_I + navette_cyl_masse_kg  * MatriceTranslation(d_navette_cyl);
  
  %propulseur 
  booster_cone_gauche_I_G = booster_cone_I + booster_cone_masse_kg  * MatriceTranslation(d_booster_cone_gauche);
  booster_cyl_gauche_I_G = booster_cyl_I + booster_cyl_masse_kg  * MatriceTranslation(d_booster_cyl_gauche);
  booster_cone_droite_I_G = booster_cone_I + booster_cone_masse_kg  * MatriceTranslation(d_booster_cone_droite);
  booster_cyl_droite_I_G = booster_cyl_I + booster_cyl_masse_kg  * MatriceTranslation(d_booster_cyl_droite);
  
  % Somme des moments d'inertie
  fusee_I = (reservoir_cone_I_G + reservoir_cyl_oxygene_I_G + reservoir_cyl_hydrogene_I_G + navette_cone_I_G + navette_cyl_I_G + booster_cone_gauche_I_G + booster_cone_droite_I_G + booster_cyl_gauche_I_G + booster_cyl_droite_I_G);

  % Ramener dans le système d'axes du laboratoire en appliquant la rotation du système local
  % Matrice de rotation autour de x
  R_x = [1, 0, 0; 0, cos(AngRot), -sin(AngRot); 0, sin(AngRot), cos(AngRot)];
  R_x_inverse = inv(R_x);

  % Appliquer la rotation
  global moment_inertie = R_x * fusee_I * R_x_inverse;
    
endfunction

function momentinertiecone = MomentInertieCone(m, r, h)
  momentinertiecone = m * [(12*r^2 + 3*h^2)/80, 0, 0; 0, (12*r^2 + 3*h^2)/80, 0; 0, 0, (3*r^2)/10];
endfunction

function momentinertiecyl = MomentInertieCyl(m, r, h)
  momentinertiecyl = m * [(r^2)/4 + (h^2)/12, 0, 0; 0, (r^2)/4 + (h^2)/12, 0; 0, 0, (r^2)/2];
endfunction

function matricetranslation = MatriceTranslation(d)
  matricetranslation = [(d(2)^2 + d(3)^2), -d(1)*d(2), -d(1)*d(3);
                        -d(2)*d(1), (d(1)^2 + d(3)^2), -d(2)*d(3);
                        -d(3)*d(1), -d(3)*d(2), (d(1)^2 + d(2)^2)];
endfunction

function a_ang = AccelerationAngulaire(AngRot, vangulaire, forces)
  global c_de_masse;
  global moment_inertie;
  
  global reservoir_cyl_r;
  global navette_cyl_r;
  global booster_cyl_r;
  
  moment_cinetique = moment_inertie * vangulaire;
  
  d_force_booster_gauche = [-reservoir_cyl_r-booster_cyl_r; navette_cyl_r+reservoir_cyl_r; 0] - c_de_masse;
  d_force_booster_droite = [reservoir_cyl_r+booster_cyl_r; navette_cyl_r+reservoir_cyl_r; 0] - c_de_masse;
  d_force_navette = [0;0;0] - c_de_masse;

  moment_navette = cross(d_force_navette, [0; 0; forces(1)]);
  moment_booster_gauche = cross(d_force_booster_gauche, [0; 0; forces(2)]);
  moment_booster_droite = cross(d_force_booster_droite, [0; 0; forces(3)]);
  
  somme_moments = moment_navette + moment_booster_gauche + moment_booster_droite;
  
  % Matrice de rotation autour de x pour les moments de force
  R_x = [1, 0, 0; 0, cos(AngRot), -sin(AngRot); 0, sin(AngRot), cos(AngRot)];
  moments_rot = R_x * somme_moments;
  
  % alpha = I^-1 * (tau + L x omega)
  a_ang = inverse(moment_inertie)*(moments_rot+cross(moment_cinetique, vangulaire));
  
endfunction

function [pcmNL INL alphaNL]=Devoir1(AngRot, vangulaire, forces, posNL)
  format short g
  % Load les valeurs
  % Centre de masse
  pcmNL = CentreDeMasse(AngRot, posNL);

  % Moment inertie
  INL = MomentInertie(AngRot, posNL);
  
  % Accélération angulaire
  alphaNL = AccelerationAngulaire(AngRot, vangulaire, forces);
endfunction

[pcmNL INL alphaNL] = Devoir1(-pi/3, [-0.54;0;0], [11000000;8750000;0], [0;-19.6075;50])
display(pcmNL)
display(INL)
display(alphaNL)

aaaaa

octave

rgb = imread('pears.png');
I = rgb2gray(rgb);
imshow(I)

text(732,501,'Image courtesy of Corel(R)',...
     'FontSize',7,'HorizontalAlignment','right')
hy = fspecial('sobel');
hx = hy';
Iy = imfilter(double(I), hy, 'replicate');
Ix = imfilter(double(I), hx, 'replicate');
gradmag = sqrt(Ix.^2 + Iy.^2);
figure
imshow(gradmag,[]), title('Gradient magnitude (gradmag)')
L = watershed(gradmag);
Lrgb = label2rgb(L);
figure, imshow(Lrgb), title('Watershed transform of gradient magnitude (Lrgb)')
se = strel('disk', 20);
Io = imopen(I, se);
figure
imshow(Io), title('Opening (Io)')
Ie = imerode(I, se);
Iobr = imreconstruct(Ie, I);
figure
imshow(Iobr), title('Opening-by-reconstruction (Iobr)')
Ioc = imclose(Io, se);
figure
imshow(Ioc), title('Opening-closing (Ioc)')
Iobrd = imdilate(Iobr, se);
Iobrcbr = imreconstruct(imcomplement(Iobrd), imcomplement(Iobr));
Iobrcbr = imcomplement(Iobrcbr);
figure
imshow(Iobrcbr), title('Opening-closing by reconstruction (Iobrcbr)')
fgm = imregionalmax(Iobrcbr);
figure
imshow(fgm), title('Regional maxima of opening-closing by reconstruction (fgm)')
I2 = I;
I2(fgm) = 255;
figure
imshow(I2), title('Regional maxima superimposed on original image (I2)')
se2 = strel(ones(5,5));
fgm2 = imclose(fgm, se2);
fgm3 = imerode(fgm2, se2);
fgm4 = bwareaopen(fgm3, 20);
I3 = I;
I3(fgm4) = 255;
figure
imshow(I3)
title('Modified regional maxima superimposed on original image (fgm4)')
bw = imbinarize(Iobrcbr);
figure
imshow(bw), title('Thresholded opening-closing by reconstruction (bw)')
D = bwdist(bw);
DL = watershed(D);
bgm = DL == 0;
figure
imshow(bgm), title('Watershed ridge lines (bgm)')
gradmag2 = imimposemin(gradmag, bgm | fgm4);
L = watershed(gradmag2);
I4 = I;
I4(imdilate(L == 0, ones(3, 3)) | bgm | fgm4) = 255;
figure
imshow(I4)
title('Markers and object boundaries superimposed on original image (I4)')
Lrgb = label2rgb(L, 'jet', 'w', 'shuffle');
figure
imshow(Lrgb)
title('Colored watershed label matrix (Lrgb)')
figure
imshow(I)
hold on
himage = imshow(Lrgb);
himage.AlphaData = 0.3;
title('Lrgb superimposed transparently on original image')

Execute MATLAB/Octave Online

octave

%x = [1 2 3 4 5 6 7 8 9 10];
%y1 = [.16 .08 .04 .02 .013 .007 .004 .002 .001 .0008 ];
%y2 = [.16 .07 .03 .01 .008 .003 .0008 .0003 .00007 .00002 ];

%semilogy(x,y1,'-bo;y1;',x,y2,'-kx;y2;');
%title('Plot title');
%xlabel('X Axis');
%ylabel('Y Axis');

%print -dpng figure.png

  function demo(in)
  x = linspace(1, in, 1000);
  
  y = linspace(1:1000);
  
  figure
  plot(x,y)

memo

octave

angle = 0:1/1000:90;
s1 = cos(angle).^2 .* cos(3*angle).^2;
s2 = sin(angle);
s3 = sin(angle).^2;
polar(angle,s1)
hold on
polar(angle,s2)
polar(angle,s3)
hpbw1 = rad2deg(acos(0.707./cos(3*angle)));
mina = min (find(imag(hpbw1) > 0));
s1(mina:end) = [];
s1 (find (s1-0.5 < 0 ))=[];
s1_hpbw1 = hpbw1(length(s1))

s2_hpbw = rad2deg(asin(max(s2)/2))
s3_hpbw = rad2deg(asin(sqrt(max(s3)/2)))

fucku

octave

x = [1 2 3 4 5 6 7 8 9 10];
y1 = [.16 .08 .04 .02 .013 .007 .004 .002 .001 .0008 ];
y2 = [.16 .07 .03 .01 .008 .003 .0008 .0003 .00007 .00002 ];

semilogy(x,y1,'-bo;y1;',x,y2,'-kx;y2;');
title('Plot title');
xlabel('X Axis');
ylabel('Y Axis');

print -dpng figure.png

Follow

Newsletter