dism /online /enable-feature /featurename:netfx3 /all /source:c:\sxs /limitaccess

%------------------------------------
%-Codigos para lab TPO

%-captura

function [senyal] = Captura(Fs)

s = audiorecorder(Fs, 16, 1);
record (s);
pause (5);
r=getaudiodata(s, 'int16');
% Converteixo a Double
senyal = double(r);

end

%--------------------------------
%Radar doppler

close all
% Frequencia de mostreig
Fs=22050;
% Funció que captura el senyal del radar

% NOMÉS APARTATS 2a i 3
% x=Captura(Fs);

% APARTAT 2 (Comentar apartat 3)
%     % Transformada de Fourier
%     N=length(x); 
% 
%     % % Nombre de punts, per zero padding augmentar N
%     % % AFEGUIU ELS ZEROS OPORTUNS DEPENEN DE LA RESOLUCIÓ FREQÜENCIAL
%     % % COMENTEU FUNCIÓ CAPTURA
%     % N=
% 
%     % % Representació de l'espectre
%     f=Fs*(-N/2:N/2-1)/N;
% 
%     w1 = window(@rectwin,length(x));
%     x1=x.*w1;
%     X1=1/length(x)*fftshift(fft(x1,N));
%     figure;
%     plot(f,abs(X1));
%     grid on
%     xlabel('f[Hz]'); ylabel('abs(X)');

    % % NOMES APARTAT 2c
    % % Enfinestrat triangular
    % w2 = window(@triang,length(x));
    % x1=x.*w2;
    % X1=1/length(x)*fftshift(fft(x1,N));
    % hold on
    % plot(f,abs(X1),'r');
    % legend('Rectangular','Triangular')

    % % NOMES APARTAT 2d
    % % COMENTAR APARTATs 2a, 2b, 2c i 3
    % % Enfinestrat Hamming
    % w3 = window(@hamming,length(x));
    % x1=x.*w3;
    % X1=1/length(x)*fftshift(fft(x1,N));
    % plot(f,abs(X1),'g');
    % legend('Rectangular','Triangular','Hamming')


% % APARTAT 3 (Comentar apartat 2)
% % DESCOMENTAR FUNCIÓ CAPTURA
    % Transformada chirp
    fs = Fs; f1 = 100; f2 = 600;  % en hertz
    m = 1024;
    w = exp(-j*2*pi*(f2-f1)/(m*fs));
    a = exp(j*2*pi*f1/fs);
 
    figure;
    Z = czt(x,m,w,a);
    fz = ((0:length(Z)-1)'*(f2-f1)/length(Z)) + f1;
    plot(fz,1/length(x)*abs(Z)); 
    xlabel('f(Hz)'); ylabel('Z')
    title('CZT')


%-------------------------------
      %_---------------------------
      %-Practica 

%Frequencia de mostreig
Fs=22050*2;

%Nombre de mostres
N=44100;

%Captura senyal audio
s  = wavrecord(N, Fs, 'int16');

%Converteixo a Double
x=double(s);

%Transformada de Fourier
N=length(x); %Nombre de punts, per zero padding augmentar N
X=fftshift(fft(x,N));
f=Fs*(-N/2:N/2-1)/N;
figure;
plot(f,abs(X));
xlabel('f(Hz)'); ylabel('X');

%Enfinestrat
w1 = window(@rectwin,length(x));
w2 = window(@hamming,length(x));
x1=x.*w1;
x2=x.*w2;
X1=fftshift(fft(x1,N));
X2=fftshift(fft(x2,N));
figure;
plot(f,abs(X1),f,abs(X2));
xlabel('f(Hz)'); ylabel('X');legend('Rectangular','Hamming');

%Transformada chirp
fs = Fs; f1 = 100; f2 = 600;  % en hertz
m = 1024;
w = exp(-j*2*pi*(f2-f1)/(m*fs));
a = exp(j*2*pi*f1/fs);

figure;
Z = czt(x,m,w,a);
fz = ((0:length(Z)-1)'*(f2-f1)/length(Z)) + f1;
plot(fz,abs(Z)); 
xlabel('f(Hz)'); ylabel('Z')
title('CZT')

%-----------------------------------------
  %-Prueba

Fs=22050*2;
x=double(DATA);
X=fftshift(abs(fft(x)));
figure(1)
       N=length(X); f=Fs*(-N/2:N/2-1)/N;h=plot(f,X)
       
       fs = Fs; f1 = 400; f2 = 600;  % in hertz
m = 1024;
w = exp(-j*2*pi*(f2-f1)/(m*fs));
a = exp(j*2*pi*f1/fs);

figure(2)
z = czt(x,m,w,a);
fz = ((0:length(z)-1)'*(f2-f1)/length(z)) + f1;
plot(fz,abs(z)); %axis([f1 f2 0 1.2])
title('CZT')

%--------------------------------------------------------------------------

%-Radar doppler

function varargout = radardoppler(varargin)
% RADARDOPPLER M-file for radardoppler.fig
%      RADARDOPPLER, by itself, creates a new RADARDOPPLER or raises the existing
%      singleton*.
%
%      H = RADARDOPPLER returns the handle to a new RADARDOPPLER or the handle to
%      the existing singleton*.
%
%      RADARDOPPLER('CALLBACK',hObject,eventData,handles,...) calls the local
%      function named CALLBACK in RADARDOPPLER.M with the given input arguments.
%
%      RADARDOPPLER('Property','Value',...) creates a new RADARDOPPLER or raises the
%      existing singleton*.  Starting from the left, property value pairs are
%      applied to the GUI before radardoppler_OpeningFunction gets called.  An
%      unrecognized property name or invalid value makes property application
%      stop.  All inputs are passed to radardoppler_OpeningFcn via varargin.
%
%      *See GUI Options on GUIDE's Tools menu.  Choose "GUI allows only one
%      instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES

% Copyright 2002-2003 The MathWorks, Inc.

% Edit the above text to modify the response to help radardoppler

% Last Modified by GUIDE v2.5 06-Oct-2008 21:14:40

% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',       mfilename, ...
                   'gui_Singleton',  gui_Singleton, ...
                   'gui_OpeningFcn', @radardoppler_OpeningFcn, ...
                   'gui_OutputFcn',  @radardoppler_OutputFcn, ...
                   'gui_LayoutFcn',  [] , ...
                   'gui_Callback',   []);
if nargin && ischar(varargin{1})
    gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
    gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT


% --- Executes just before radardoppler is made visible.
function radardoppler_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
% varargin   command line arguments to radardoppler (see VARARGIN)

% Choose default command line output for radardoppler
handles.output = hObject;

%
%Poso fons blanc i amago boto
%
set(hObject,'color','w');
set(handles.hboto,'visible','off');

% Update handles structure
guidata(hObject, handles);

% UIWAIT makes radardoppler wait for user response (see UIRESUME)
% uiwait(handles.figure1);


% --- Outputs from this function are returned to the command line.
function varargout = radardoppler_OutputFcn(hObject, eventdata, handles) 
% varargout  cell array for returning output args (see VARARGOUT);
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure
varargout{1} = handles.output;


% --------------------------------------------------------------------
function LoadCaptura_Callback(hObject, eventdata, handles)
% hObject    handle to Load (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

global CaptureData

[filename, pathname] = uigetfile('*.vel', 'Pick an vel-file');
    if isequal(filename,0) | isequal(pathname,0)
       disp('User pressed cancel')
    else
      
           file=fullfile(pathname, filename);
           load(file,'-mat');
           
    end
% --------------------------------------------------------------------
function Exit_Callback(hObject, eventdata, handles)
% hObject    handle to Exit (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
ButtonName=questdlg('Que vol fer?', ...
                       'Sortir del programa', ...
                       'Sortir','Cancelar','Cancelar');
                   
 switch ButtonName,
     case 'Sortir',
         close(gcf);
 end

% --------------------------------------------------------------------
function Parametres_Callback(hObject, eventdata, handles)
% hObject    handle to Parametres (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

global SamplingParameters

S.Sampling_Rate = {'8000|11025|22050|{44100}', 'Sampling Rate(Hz)'};
S.Samples_Number={[10240] 'Number of Samples' [1 100000]};
S.Oscillator_Frequency={[24] 'Oscillator Frequency (GHz)' };
S.FFT_Points={[1024] 'Number of FFT points' [1 100000]};
S.Window_Type={ {'{rectwin}','bartlett' 'blackman' 'hamming'} };
S.Frequency_Unit={ {'{Hz}','m/s' 'km/h' 'mph'} };
SamplingParameters=StructDlg(S,'Sampling Parameters')
    if ~isempty(SamplingParameters),
       set(handles.hboto,'visible','on','string','Sample'); 
        
    end;

% --------------------------------------------------------------------
function TransformadaChirp_Callback(hObject, eventdata, handles)
% hObject    handle to TransformadaChirp (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

global SamplingData


S.Oscillator_Frequency={[24] 'Oscillator Frequency (GHz)' };
S.Chirp_Points={[1024] 'Number of Chirp points' [1 100000]};
S.Window_Type={ {'{rectwin}','bartlett' 'blackman' 'hamming'} };
S.Start_Frequency={ [100] '' [0 44100]};
S.Stop_Frequency={ [700] '' [0 44100]};
S.Frequency_Unit={ {'{Hz}','m/s' 'km/h' 'mph'} };
SamplingParameters=StructDlg(S,'Sampling Parameters');
if ~isempty(SamplingParameters),
Fs=SamplingData.Sampling_Rate;
SamplingParameters.Samples_Number=length(SamplingData.Data);

switch SamplingParameters.Window_Type,
        case 'rectwin',
        win=window(@rectwin,SamplingParameters.Samples_Number);
        case 'bartlett',
        win=window(@bartlett,SamplingParameters.Samples_Number);
        case 'blackman',
        win=window(@blackman,SamplingParameters.Samples_Number);
        case 'hamming',
        win=window(@hamming,SamplingParameters.Samples_Number);
end

m = SamplingParameters.Chirp_Points;
f1=SamplingParameters.Start_Frequency;
f2=SamplingParameters.Stop_Frequency;
w = exp(-j*2*pi*(f2-f1)/(m*Fs));
a = exp(j*2*pi*f1/Fs);


Z = czt(SamplingData.Data.*win,m,w,a);
fz = ((0:length(Z)-1)'*(f2-f1)/length(Z)) + f1;
    



figure;
subplot(211);
t=linspace(0,(SamplingParameters.Samples_Number-1)/Fs,SamplingParameters.Samples_Number)*1e3; %temps en ms
plot(t,SamplingData.Data);
xlabel('t(ms)'); ylabel('x(t)');

subplot(212);




switch SamplingParameters.Frequency_Unit,
    case 'Hz',
        escala=1;
        TextUnit='Hz';
    case 'm/s',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8/f0)/2;
        TextUnit='m/s';
    case 'km/h',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/f0)/2;
        TextUnit='km/s';
    case 'mph',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/1.6/f0)/2;
        TextUnit='mph';
end

       plot(fz*escala,abs(Z));
       xlabel(TextUnit);
       ylabel('mag');
       
       [m,I]=max(abs(Z));
       title(['Maxim ',num2str(fz(I)*escala),' ',TextUnit]);
end

% --------------------------------------------------------------------
function PlotVelocitat_Callback(hObject, eventdata, handles)
% hObject    handle to ParametresVelocimetre (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

global CaptureData 

S.Oscillator_Frequency={[24] 'Oscillator Frequency (GHz)' };
S.Frequency_Unit={ {'{Hz}','m/s' 'km/h' 'mph'} };
SamplingParameters=StructDlg(S,'Sampling Parameters');

if ~isempty(SamplingParameters),
    switch SamplingParameters.Frequency_Unit,
    case 'Hz',
        escala=1;
        TextUnit='Hz';
    case 'm/s',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8/f0)/2;
        TextUnit='m/s';
    case 'km/h',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/f0)/2;
        TextUnit='km/h';
    case 'mph',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/1.609344/f0)/2;
        TextUnit='mph';
    end
    figure; 
    plot(1:length(CaptureData.FrequencyDoppler),CaptureData.FrequencyDoppler*escala);
    xlabel('Sample');ylabel(TextUnit);
end;


% --------------------------------------------------------------------
function CapturaVelocimetre_Callback(hObject, eventdata, handles)
% hObject    handle to CapturaVelocimetre (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
 
global CaptureData SamplingData


S.Sampling_Rate = {'8000|11025|22050|{44100}', 'Sampling Rate(Hz)'};
S.Samples_Number={[10240] 'Number of Samples' [1 100000]};
S.Oscillator_Frequency={[24] 'Oscillator Frequency (GHz)' };
S.Chirp_Points={[1024] 'Number of Chirp points' [1 100000]};
S.Window_Type={ {'{rectwin}','bartlett' 'blackman' 'hamming'} };
S.Start_Frequency={ [100] '' [0 44100]};
S.Stop_Frequency={ [700] '' [0 44100]};
S.Frequency_Unit={ {'{Hz}','m/s' 'km/h' 'mph'} };
SamplingParameters=StructDlg(S,'Sampling Parameters');

if ~isempty(SamplingParameters),
    set(handles.hboto,'string','Stop','visible','on');
    
    clear CaptureData
    
    %Capura de la tarja de so
    Fs=SamplingParameters.Sampling_Rate;
    
    SamplingData.Sampling_Rate=Fs;
    
    switch SamplingParameters.Frequency_Unit,
    case 'Hz',
        escala=1;
        TextUnit='Hz';
    case 'm/s',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8/f0)/2;
        TextUnit='m/s';
    case 'km/h',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/f0)/2;
        TextUnit='km/h';
    case 'mph',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/1.609344/f0)/2;
        TextUnit='mph';
    end
    
    switch SamplingParameters.Window_Type,
        case 'rectwin',
        win=window(@rectwin,SamplingParameters.Samples_Number);
        case 'bartlett',
        win=window(@bartlett,SamplingParameters.Samples_Number);
        case 'blackman',
        win=window(@blackman,SamplingParameters.Samples_Number);
        case 'hamming',
        win=window(@hamming,SamplingParameters.Samples_Number);
    end
    
    
    m = SamplingParameters.Chirp_Points;
    f1=SamplingParameters.Start_Frequency;
    f2=SamplingParameters.Stop_Frequency;
    w = exp(-j*2*pi*(f2-f1)/(m*Fs));
    a = exp(j*2*pi*f1/Fs);
count=0;
    while ~strcmp(get(handles.hboto,'string'),'End')
    SamplingData.Data=wavrecord(SamplingParameters.Samples_Number,Fs,'double');
    Z = czt(SamplingData.Data.*win,m,w,a);
    fz = ((0:length(Z)-1)'*(f2-f1)/length(Z)) + f1;
   [M,I]=max(abs(Z));
   count=count+1;
   CaptureData.FrequencyDoppler(count)=fz(I);
   if count==1,
       figure; h=plot(1:count,CaptureData.FrequencyDoppler*escala);
       xlabel('Sample');ylabel(TextUnit);
   else
       set(h,'XData',1:length(CaptureData.FrequencyDoppler),'YData',CaptureData.FrequencyDoppler*escala);
       drawnow;
   end;
    end;
       
   
   



end;

% --------------------------------------------------------------------
function About_Callback(hObject, eventdata, handles)
% hObject    handle to About (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
msgbox('(C) 2008 A.L\E1zaro/D.Girbau');

% --------------------------------------------------------------------
function File_Callback(hObject, eventdata, handles)
% hObject    handle to File (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


% --------------------------------------------------------------------
function Mesura_Callback(hObject, eventdata, handles)
% hObject    handle to Mesura (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


% --------------------------------------------------------------------
function Velocimetre_Callback(hObject, eventdata, handles)
% hObject    handle to Velocimetre (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


% --------------------------------------------------------------------
function Help_Callback(hObject, eventdata, handles)
% hObject    handle to Help (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)


% --------------------------------------------------------------------
function SaveSample_Callback(hObject, eventdata, handles)
% hObject    handle to Untitled_1 (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
global SamplingData

[filename, pathname] = uiputfile('*.mat', 'Pick an MAT-file');
    if isequal(filename,0) | isequal(pathname,0)
       disp('User pressed cancel')
    else
      
           file=fullfile(pathname, filename);
           eval(['save ',file,' SamplingData -mat']);
       
    end

% --------------------------------------------------------------------
function LoadSample_Callback(hObject, eventdata, handles)
% hObject    handle to Untitled_2 (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
global SamplingData

[filename, pathname] = uigetfile('*.mat', 'Pick an MAT-file');
    if isequal(filename,0) | isequal(pathname,0)
       disp('User pressed cancel')
    else
      
           file=fullfile(pathname, filename);
           load(file,'-mat');
       
    end

% --------------------------------------------------------------------
function SaveCaptura_Callback(hObject, eventdata, handles)
% hObject    handle to SaveCaptura (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
global CaptureData

[filename, pathname] = uiputfile('*.vel', 'Pick an vel-file');
    if isequal(filename,0) | isequal(pathname,0)
       disp('User pressed cancel')
    else
      
           file=fullfile(pathname, filename);
           eval(['save ',file,' CaptureData -mat']);
       
    end

% --- Executes on button press in hboto.
function hboto_Callback(hObject, eventdata, handles)
% hObject    handle to hboto (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)



global SamplingParameters SamplingData


%Si esta en mode sample
mode=get(handles.hboto,'string');

if strcmp(mode,'Sample'),

%Capura de la tarja de so
Fs=SamplingParameters.Sampling_Rate;
SamplingData.Data=wavrecord(SamplingParameters.Samples_Number,Fs,'double');
SamplingData.Sampling_Rate=Fs;

switch SamplingParameters.Window_Type,
        case 'rectwin',
        w=window(@rectwin,SamplingParameters.Samples_Number);
        case 'bartlett',
        w=window(@bartlett,SamplingParameters.Samples_Number);
        case 'blackman',
        w=window(@blackman,SamplingParameters.Samples_Number);
        case 'hamming',
        w=window(@hamming,SamplingParameters.Samples_Number);
end
   

figure;
subplot(211);
t=linspace(0,(SamplingParameters.Samples_Number-1)/Fs,SamplingParameters.Samples_Number)*1e3; %temps en ms
plot(t,SamplingData.Data);
xlabel('t(ms)'); ylabel('x(t)');

subplot(212);
%Positius i negatius
%X=fftshift(fft(SamplingData.Data,SamplingParameters.FFT_Points));
%N=length(X); f=Fs*(-N/2:N/2-1)/N;

%Frequencies positives nomes
X=fft(SamplingData.Data.*w,SamplingParameters.FFT_Points);
N=length(X);
X=X(1:(N/2));
f=Fs*(0:(N/2-1))/N;

switch SamplingParameters.Frequency_Unit,
    case 'Hz',
        escala=1;
        TextUnit='Hz';
    case 'm/s',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8/f0)/2;
        TextUnit='m/s';
    case 'km/h',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/f0)/2;
        TextUnit='km/h';
    case 'mph',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/1.609344/f0)/2;
        TextUnit='mph';
end

       plot(f*escala,abs(X));
       xlabel(TextUnit);
       ylabel('mag');
       
       [m,I]=max(abs(X));
       title(['Maxim ',num2str(f(I)*escala),' ',TextUnit]);


else
   %Mode capture, esperant stop
   set(handles.hboto,'string','End','visible','off');
    
end


% --------------------------------------------------------------------
function Plot_Callback(hObject, eventdata, handles)
% hObject    handle to Plot (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

global SamplingData 



S.Oscillator_Frequency={[24] 'Oscillator Frequency (GHz)' };
S.FFT_Points={[1024] 'Number of FFT points' [1 100000]};
S.Window_Type={ {'{rectwin}','bartlett' 'blackman' 'hamming'} };
S.Frequency_Unit={ {'{Hz}','m/s' 'km/h' 'mph'} };
SamplingParameters=StructDlg(S,'Sampling Parameters');

Fs=SamplingData.Sampling_Rate;
SamplingParameters.Samples_Number=length(SamplingData.Data);

switch SamplingParameters.Window_Type,
        case 'rectwin',
        w=window(@rectwin,SamplingParameters.Samples_Number);
        case 'bartlett',
        w=window(@bartlett,SamplingParameters.Samples_Number);
        case 'blackman',
        w=window(@blackman,SamplingParameters.Samples_Number);
        case 'hamming',
        w=window(@hamming,SamplingParameters.Samples_Number);
end
    



figure;
subplot(211);
t=linspace(0,(SamplingParameters.Samples_Number-1)/Fs,SamplingParameters.Samples_Number)*1e3; %temps en ms
plot(t,SamplingData.Data);
xlabel('t(ms)'); ylabel('x(t)');

subplot(212);
%Positius i negatius
%X=fftshift(fft(SamplingData.Data,SamplingParameters.FFT_Points));
%N=length(X); f=Fs*(-N/2:N/2-1)/N;

%Frequencies positives nomes
X=fft(SamplingData.Data.*w,SamplingParameters.FFT_Points);
N=length(X);
X=X(1:(N/2));
f=Fs*(0:(N/2-1))/N;

switch SamplingParameters.Frequency_Unit,
    case 'Hz',
        escala=1;
        TextUnit='Hz';
    case 'm/s',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8/f0)/2;
        TextUnit='m/s';
    case 'km/h',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/f0)/2;
        TextUnit='km/h';
    case 'mph',
        f0=SamplingParameters.Oscillator_Frequency*1e9;
        escala=(3e8*3.6/1.609344/f0)/2;
        TextUnit='mph';
end

       plot(f*escala,abs(X));
       xlabel(TextUnit);
       ylabel('mag');
       
       [m,I]=max(abs(X));
       title(['Maxim ',num2str(f(I)*escala),' ',TextUnit]);
    
            %------------------------------
            %_-------------------------------
              
              
Fs=22050*2;
 r = audiorecorder(22050*2, 16, 1);
 
       record(r);     % speak into microphone...
       pause(r);
       p = play(r);   % listen
       resume(r);     % speak again
       stop(r);
       p = play(r);   % listen to complete recording
       DATA = getaudiodata(r, 'int16'); % get data as int16 array
       
       plot(DATA)
       
       
       Fs = 44100;
        y  = wavrecord(Fs, Fs, 'int16');
        %wavplay(y, Fs);
        DATA=y;
       
       X=fftshift(abs(fft(double(DATA))));
       N=length(X); f=Fs*(-N/2:N/2-1)/N;plot(f,X)

            %----------------------------------------------
       %-----------------------------------------------
         %-Struct 
            
            function [str,cur_line] = struct2str(s,units,max_width,max_struct_elem, ident_str,total_ident_len,str,cur_line)
%

% AF 11/6/01

if (exist('units','var') ~= 1)
   units = struct([]);
end
if (exist('max_width','var') ~= 1)
   max_width  = Inf;
end
if (exist('max_struct_elem','var') ~= 1)
   max_struct_elem = 3;
end
if (exist('ident_str','var') ~= 1)
   ident_str  = '|';
end
if (exist('total_ident_len','var') ~= 1)
   total_ident_len  = 2;
end
if (exist('str','var') ~= 1)
   str = repmat({''},400,1);
   first_call = 1;
else
   first_call = 0;
end
if (exist('cur_line','var') ~= 1)
   cur_line = 0;
end
spacing = 2;

fnames = fieldnames(s);
fnames_lbl = build_labels(fnames,units);
max_lbl_width = size(char(fnames_lbl),2);
for i = 1:length(fnames)
   for j = 1:spacing-1
      cur_line = cur_line+1;
      str{cur_line} = ident_str;
   end
   cur_line = cur_line+1;
   str{cur_line} = ident_str;
   leading_spaces = repmat('-', 1, total_ident_len -length(ident_str)+max_lbl_width -length(fnames_lbl{i}));
   str{cur_line} = sprintf('%s%s%s: ', str{cur_line} ,leading_spaces, fnames_lbl{i});
   x = getfield(s,fnames{i});
   %% recursive call for sub-structures
   if (isstruct(x))
      new_ident_len = total_ident_len + max_lbl_width+2;
      new_ident_str = [ident_str repmat(' ',1,new_ident_len-2 - length(ident_str) - ceil(length(fnames_lbl{i})/2)) '|'];
      for xi = 1:min(length(x),max_struct_elem)
         if (isfield(units,fnames{i}))
            sub_units = getfield(units,fnames{i});
         else
            sub_units = struct([]);
         end
         [str,cur_line] = struct2str(x(xi),sub_units,max_width,max_struct_elem, new_ident_str,new_ident_len,str,cur_line);
         cur_line = cur_line+1;
         str{cur_line} = ident_str;
      end
      if (length(x) > max_struct_elem)
         dotted_str = [ident_str repmat(' ',1,new_ident_len-2 - length(ident_str) - ceil(length(fnames_lbl{i})/2)) ':'];
         for dot_i = 1:2
            cur_line = cur_line+1;
            str{cur_line} = dotted_str;
         end
      end
   else
      xstr = element2str(x,max_width-max_lbl_width-2);
      str{cur_line} = sprintf('%s%s', str{cur_line}, xstr);
   end
end
if (first_call)
   str = str(1:cur_line);
end
return;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%      
%%                        SUB FUNCTIONS                        %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%      
function fnames_lbl = build_labels(fnames,units);
%
fnames_lbl = strrep(fnames,'_',' ');
f_units = fieldnames(units);
v_units = struct2cell(units);
for i = 1:length(f_units)
   if (ischar(v_units{i}) & ~isempty(v_units{i}))
      index = strmatch(f_units{i},fnames,'exact');
      if (~isempty(index))
         fnames_lbl{index} = strrep(v_units{i},'*',fnames_lbl{index});
         % fnames_lbl{index} = [fnames_lbl{index} ' (' v_units{i} ')'];
      end
   end
end
return;

% function fnames_lbl = build_labels(fnames,f_units);
% %
% fnames_lbl = strrep(fnames,'_',' ');
% for i = 1:min(length(fnames_lbl),length(f_units))
%    if (ischar(f_units{i}) & ~isempty(f_units{i}))
%       fnames_lbl{i} = [fnames_lbl{i} ' (' f_units{i} ')'];
%    end
% end
% return;


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function xstr = element2str(x,max_width)
if (exist('max_width','var') ~= 1)
   max_width = Inf;
end
switch (class(x))
case 'char'
   if (length(x) < max_width-2)
      xstr = ['''' x ''''];
   else
      xstr = ['''' x(1:max_width-4) '...'''];
   end
   
case {'double' 'sparse'}
   if (isempty(x))
      xstr = '[]';
   elseif (ndims(x) > 2 | min(size(x)) >1 | length(x) >150)
      dims = size(x);
      xstr = ['[' sprintf('%dx',dims(1:end-1)) sprintf('%d',dims(end)) ' ' class(x) ']'];
   else 
      % x is a vector
      if (size(x,2) == 1)
         sep = ' ; ';
      else
         sep = ' ';
      end
      if (length(x) == 1)
         xstr = num2str(x);
      else
         xstr = ['[' num2str(x(1))];
         for ix = 2:length(x)
            xstr = [xstr sep num2str(x(ix))];
         end
         xstr = [xstr ']'];
      end
      if (length(xstr) > max_width)
         xstr = [xstr(1:max_width-4) '...]'];
      end
   end
   
case 'cell'
   xstr = '{';
   if (isempty(x))
      xstr = '{}';
   elseif (ndims(x) > 2 | min(size(x)) >1)
      dims = size(x);
      xstr = ['{' sprintf('%dx',dims(1:end-1)) sprintf('%d',dims(end)) ' cell}'];
   else 
      % x is a cell vector
      if (size(x,2) == 1)
         sep = ' ; ';
      else
         sep = ' ';
      end
      xstr = ['{' element2str(x{1},max_width/3)];
      for ix = 2:length(x)
         xstr = [xstr sep element2str(x{ix},max_width/3)];
      end
      xstr = [xstr '}'];
      if (length(xstr) > max_width)
         xstr = [xstr(1:max_width-4) '...}'];
      end
   end
   
case 'function_handle'
   xstr = element2str(['@' func2str(x)],max_width);
   
end

<a id="#fromacademy">The Mindset to succed</a>

$(document).ready(function () {
	$('[data-property-slider]')
		.on('initialized.owl.carousel changed.owl.carousel', function (e) {
			$('#counter').text(
				e.relatedTarget.relative(e.item.index) + 1 + '/' + e.item.count,
			);
		})
		.owlCarousel({
			loop: false,
			nav: true,
			dots: false,
			animateIn: true,
			responsiveClass: true,
			items: 1,
			margin: 30,
			navText: [
				'<a class="arrow-left" aria-hidden="true"></a>',
				'<a class="arrow-right" aria-hidden="true"></a>',
			],
			responsive: {
				576: {
					items: 1,
				},
				789: {
					items: 2,
				},
			},
		});
});

// Add leading zero
//.on('changed.owl.carousel', function (e) {
// 	var currentSlideIndex = e.item.index + 1;
// 	var formattedSlideIndex = ('0' + currentSlideIndex).slice(-2); // Add leading zero
// 	$('#counter').text(formattedSlideIndex);
// })

// for append div
//$(document).ready(function () {
	// Append div#counter after ul
	//$('.example').after('<div id="counter">1</div>');
//});

Token Creation in Practice
In order to create tokens, we'll make use of the jsonwebtoken package. We'll need to import it inside of our project:

// controllers/users.js

const jwt = require('jsonwebtoken'); // importing the jsonwebtoken module
Afterwards, we can call the jwt.sign() method to create a token:

// controllers/users.js

const jwt = require('jsonwebtoken'); 

module.exports.login = (req, res) => {
  const { email, password } = req.body;

  return User.findUserByCredentials(email, password)
    .then((user) => {
      // we're creating a token
      const token = jwt.sign({ _id: user._id }, 'some-secret-key');

      // we return the token
      res.send({ token });
    })
    .catch((err) => {
      res
        .status(401)
        .send({ message: err.message });
    });
};
We pass two arguments to the sign() method: the token's payload and the secret key for the signature:

const token = jwt.sign({ _id: user._id }, 'some-secret-key');
The token's payload is an encrypted user object. We can send as much information as we'd like to be encrypted; however, we recommend that you avoid creating excess traffic and only encrypt the most pertinent information. In this case, it's enough to encrypt the user's unique ID.

The sign() method also has an optional third parameter, an options object. You can check out the full list of options available with this object inside the official jsonwebtoken documentation. We're really only interested in one of these options, expiresIn. This is a length of time that specifies how long a token will be valid. We can pass a number here, which the sign() method will recognize as a number of seconds:

const token = jwt.sign(
  { _id: user._id },
  'some-secret-key',
  { expiresIn: 3600 } // this token will expire an hour after creation
);
We can pass a string argument containing numbers and letters. The letters will indicate the unit of measurement, milliseconds, minutes, hours, or days:

expiresIn: '120ms' // 120 miliseconds
expiresIn: '15m' // 15 minutes
expiresIn: '2h' // 2 hours
expiresIn: '7d' // 7 days
Should we choose to pass nothing to expiresIn, the token will never expire.

The promise chain works like this:

We check if a user with the submitted email exists in the database.
If the user is found, the hash of the user's password is checked.
In this lesson, we'll improve our code. We'll actually make the code for checking emails and passwords part of the User schema itself. For this, we'll write a method called findUserByCredentials(), which has two parameters, email and password, and returns either a user object or an error.

Mongoose allows us to do this, and in order to add a custom method, we'll need to set it on the statics property on the desired schema:

// models/user.js

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true
  },
  password: {
    type: String,
    required: true,
    minlength: 8
  }
});
// we're adding the findUserByCredentials methods to the User schema 
// it will have two parameters, email and password
userSchema.statics.findUserByCredentials = function findUserByCredentials (email, password) {

};

module.exports = mongoose.model('user', userSchema);
 Save
All that's left is to write this method's code. In the future, we'll use the method like so:

User.findUserByCredentials('elisebouer@tripleten.com', 'EliseBouer1989')
  .then(user => {
        // we get the user object if the email and password match
  })
  .catch(err => {
        // otherwise, we get an error
  });
 Save
The findUserByCredentials() Method
In order to find a user by email, we'll need the findOne() method, which takes email as an argument. The findOne() method belongs to the User model, so we'll call this method using the this keyword:

// models/user.js

userSchema.statics.findUserByCredentials = function findUserByCredentials (email, password) {
  // trying to find the user by email
  return this.findOne({ email }) // this — the User model
    .then((user) => {
      // not found - rejecting the promise
      if (!user) {
        return Promise.reject(new Error('Incorrect email or password'));
      }

      // found - comparing hashes
      return bcrypt.compare(password, user.password);
    });
};

module.exports = mongoose.model('user', userSchema);
 Save
The findUserByCredentials() method should not be an arrow function. This is so that we can use this. Otherwise, the value of this would be statically set, as arrow functions remember the value of this from their initial declaration.

Now we need to add an error handler for whenever the hashes don't match. We'll write the code for this in a further then() function.

But first, let's take a quick look at how we should NOT do this:

// models/user.js

userSchema.statics.findUserByCredentials = function findUserByCredentials (email, password) {
  // trying to find the user by email
  return this.findOne({ email })
    .then((user) => {
      // not found - rejecting the promsie
      if (!user) {
        return Promise.reject(new Error('Incorrect email or password'));
      }

      // found - comparing hashes
      return bcrypt.compare(password, user.password);
    })
    .then((matched) => {
      if (!matched) // rejecting the promise
      
      return user; // oh - the user variable is not in this scope
    });
};

module.exports = mongoose.model('user', userSchema);
 Save
In the second then(), we're returning a user object which doesn't exist in that scope as it was left back in the previous then().

In order to solve this problem, we should organize our promise chain differently. Let's add a then() handler to bcrypt.compare():

// models/user.js

const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const { Schema } = mongoose;

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true
  },
  password: {
    type: String,
    required: true,
    minlength: 8
  }
});

userSchema.statics.findUserByCredentials = function findUserByCredentials (email, password) {
  return this.findOne({ email })
    .then((user) => {
      if (!user) {
        return Promise.reject(new Error('Incorrect email or password'));
      }

      return bcrypt.compare(password, user.password)
        .then((matched) => {
          if (!matched) {
            return Promise.reject(new Error('Incorrect email or password'));
          }

          return user; // now user is available
        });
    });
};

module.exports = mongoose.model('user', userSchema);
 Save
The method is ready. Now we can apply it to the authentication handler:

// controllers/users.js

module.exports.login = (req, res) => {
  const { email, password } = req.body;

  return User.findUserByCredentials(email, password)
    .then((user) => {
            // authentication successful! user is in the user variable
    })
    .catch((err) => {
            // authentication error
      res
        .status(401)
        .send({ message: err.message });
    });
};

Checking Passwords
If the user is found, we'll check the user's password next. We'll hash the password, then compare the resultant hash with the hash in the database. We can use the brcrypt.compare() method in order to do this. It accepts the password and the corresponding hash as arguments. This method performs the hash and compares it with the hash we pass as the second argument:

// controllers/users.js

module.exports.login = (req, res) => {
  const { email, password } = req.body;

  User.findOne({ email })
    .then((user) => {
      if (!user) {
        return Promise.reject(new Error('Incorrect password or email'));
      }
      // comparing the submitted password and hash from the database
      return bcrypt.compare(password, user.password);
    })
    .catch((err) => {
      res
        .status(401)
        .send({ message: err.message });
    });
};
The bcrypt.compare() method works asynchronously so its result will be returned in a chained then() function. If the hashes match, then() with return true, otherwise, it will return false:

// controllers/users.js

module.exports.login = (req, res) => {
  const { email, password } = req.body;

  User.findOne({ email })
    .then((user) => {
      if (!user) {
        return Promise.reject(new Error('Incorrect password or email'));
      }
      return bcrypt.compare(password, user.password);
    })
    .then((matched) => {
      if (!matched) {
        // the hashes didn't match, rejecting the promise
        return Promise.reject(new Error('Incorrect password or email'));
      }
      // successful authentication
      res.send({ message: 'Everything good!' });
    })
    .catch((err) => {
      res
        .status(401)
        .send({ message: err.message });
    });
};

Hashing Passwords
We'll save encrypted versions of passwords inside the database. Otherwise, our user's information might be vulnerable. For example, if a malicious individual were to gain access to the database, they could gain access to a user's account.

The password will be hashed. The purpose of a hash is to make it so that reverse-engineering passwords is impossible. As a result, attackers won't be able to access a user's account, even if the database is compromised. 

In order to hash a password, we'll need to use a module called bcryptjs. As with other modules, we'll need to install it, then import it inside the project:

// controllers/users.js

const bcrypt = require('bcryptjs'); // importing bcrypt
const User = require('../models/user');
We're adding the code to hash the passwords to the user creation controller. The hash() method is responsible for this process:

// controllers/users.js

const bcrypt = require('bcryptjs'); // importing bcrypt
const User = require('../models/user');

exports.createUser = (req, res) => {
  // hashing the password
  bcrypt.hash(req.body.password, 10)
    .then(hash => User.create({
      email: req.body.email,
      password: hash, // adding the hash to the database
    }))
    .then((user) => res.send(user))
    .catch((err) => res.status(400).send(err));
};

Adding a User to the Database
First, let’s create and record a user to our database. 

Creating a User Model
We've created a user model, which is an object, with a few fields:

// models/user.js

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  email: {
    type: String,
    required: true,
    unique: true
  },
  password: {
    type: String,
    required: true,
    minlength: 8
  }
});

module.exports = mongoose.model('user', userSchema);

c=int(input("enter no.of columns:"))
r=int(input("enter no.of rows:"))
print("enter 1st matrix elements")
m1=[]
for i in range (r):
    print("enter elemnts of row",i+1)
    n=[]
    for j in range (c):
        x=int(input())
        n.append(x)
    m1.append(n)
print("enter 2nd matrix elements")
m2=[]
for i in range (r):
    print("enter elemnts of row",i+1)
    n=[]
    for j in range (c):
        x=int(input())
        n.append(x)
    m2.append(n)
for i in range (r):
    for j in range (r):
        x=0
        for k in range (r):
            a=m1[i][k]
            b=m2[k][j]
            x=x+a*b
        print(x,end=" ")
    print(" ")

{soh #D1E7FE}{eoh}

c=int(input("enter no.of columns:"))
r=int(input("enter no.of rows:"))
print("enter 1st matrix elements")
m1=[]
for i in range (r):
    print("enter elemnts of row",i+1)
    n=[]
    for j in range (c):
        x=int(input())
        n.append(x)
    m1.append(n)
print("enter 2nd matrix elements")
m2=[]
for i in range (r):
    print("enter elemnts of row",i+1)
    n=[]
    for j in range (c):
        x=int(input())
        n.append(x)
    m2.append(n)
for i in range (r):
    for j in range (c):
        a=m1[i][j]
        b=m2[i][j]
        x=a+b
        print(x,end=" ")
    print(" ")

 npx prettier --write .

// prevent actions by user in setup
// for all actions 
[ExtensionOf(classStr(WorkflowWorkItemActionManager))]
final class WorkflowWorkItemActionManager_Proc_Extension
{
    public static void dispatchWorkItemAction(  WorkflowWorkItemTable _workItem,
                                                WorkflowComment _comment,
                                                WorkflowUser _toUser,
                                                WorkflowWorkItemActionType _workItemActionType,
                                                menuItemName _menuItemName,
                                                Name _queueName )
    {
        NW_UserWorkflowAction   NW_UserWorkflowAction;
        WorkflowTable           WorkflowTable;
        NW_WFAction             action;
        switch(_workItemActionType)
        {
            case WorkflowWorkItemActionType::Complete :
                action = NW_WFAction::Approve;
                break;
            case WorkflowWorkItemActionType::Delegate :
                action = NW_WFAction::Delegate;
                break;
            case WorkflowWorkItemActionType::Deny :
                action = NW_WFAction::Cancel;
                break;
            case WorkflowWorkItemActionType::RequestChange :
                action = NW_WFAction::RequestChange;
                break;
            case WorkflowWorkItemActionType::Return :
                action = NW_WFAction::Reject;
                break;
        }
        SysWorkflowTable sysworkflowTable = SysWorkflowTable::find(_workItem.CorrelationId);

        while select NW_UserWorkflowAction 
            join WorkflowTable 
            where NW_UserWorkflowAction.SequenceNumber == WorkflowTable.SequenceNumber
            && WorkflowTable.TemplateName == sysworkflowTable.TemplateName
            && NW_UserWorkflowAction.NW_WFAction == action
        {
            if(NW_UserWorkflowAction.NW_UserGroup == NW_UserGroup::User
                && NW_UserWorkflowAction.UserId == curUserId())
                throw error(strFmt('This user %1 not able to %2 this workflow',curUserId(), action));
            
            if(NW_UserWorkflowAction.NW_UserGroup == NW_UserGroup::Group)
            {
                UserGroupList UserGroupList;
                select UserGroupList
                where UserGroupList.userId == curUserId()
                && UserGroupList.groupId == NW_UserWorkflowAction.UserGroup;
                if(UserGroupList)
                {
                    throw error(strFmt('This user %1 not able to %2 this workflow',curUserId(), action));
                }
            }
        }

        next dispatchWorkItemAction( _workItem,
                                     _comment,
                                    _toUser,
                                    _workItemActionType,
                                    _menuItemName,
                                    _queueName );
        
    }

}


// for submit only
[ExtensionOf(classStr(Workflow))]
final class NW_Workflow_Proc_Extension
{
    public static server WorkflowCorrelationId activateFromWorkflowType(workflowTypeName _workflowTemplateName,
                                                                    recId _recId,
                                                                    WorkflowComment _initialNote,
                                                                    NoYes _activatingFromWeb,
                                                                    WorkflowUser _submittingUser)
    {
        NW_UserWorkflowAction NW_UserWorkflowAction;
        WorkflowTable  WorkflowTable;

        select NW_UserWorkflowAction join WorkflowTable where NW_UserWorkflowAction.SequenceNumber==WorkflowTable.SequenceNumber
            && WorkflowTable.TemplateName==_workflowTemplateName  && NW_UserWorkflowAction.NW_WFAction==NW_WFAction::Submit;
        if(NW_UserWorkflowAction)
        {
            if(NW_UserWorkflowAction.NW_UserGroup == NW_UserGroup::User)
                throw error(strFmt('This user %1 not able to submit this workflow',_submittingUser));
            else
            {
                UserGroupList UserGroupList;
                select UserGroupList where UserGroupList.userId==_submittingUser && UserGroupList.groupId==NW_UserWorkflowAction.UserGroup;
                if(UserGroupList)
                {
                    throw error(strFmt('This user %1 not able to submit this workflow',_submittingUser));
                }
            }
        
        }
 
      
        WorkflowCorrelationId ret = next activateFromWorkflowType(  _workflowTemplateName,
                                                                    _recId,
                                                                    _initialNote,
                                                                    _activatingFromWeb,
                                                                    _submittingUser);
        return ret; 
    }

}

<script type="text/javascript">
  document.addEventListener('DOMContentLoaded', function () {
    var link = document.getElementById('exit-intent-popup-trigger');


    function handleClick(e) {
      e.preventDefault();
    }


    link.addEventListener('click', handleClick);


    function triggerClick() {
      link.click();
      sessionStorage.setItem('eventTriggered', 'true');
    }

    // בדיקה האם המכשיר הוא נייד
    var isMobile = /Mobi|Android/i.test(navigator.userAgent);

    if (isMobile) {

      if (sessionStorage.getItem('eventTriggered') !== 'true') {
        setTimeout(triggerClick, 8000); 
      }
    } else {

      document.addEventListener('mousemove', function(e) {
        if (sessionStorage.getItem('eventTriggered') !== 'true') {
 
          if (e.clientY < 45) {
            triggerClick();
            document.removeEventListener('mousemove', arguments.callee);
            sessionStorage.setItem('eventTriggered', 'true');  
          }
        }
      });
    }
  });
</script>

var email = new GlideEmailOutbound();
email.setSubject('Who's gonna win?');
email.setBody('ChatGPT vs BARD');
email.addRecipient('vikram@example.com');
email.save();

<img alt="" src="images/2024/02/160224_Infinite_Elite_E_AppHeroImage_W750xH489px.jpg?$staticlink$" />
<img alt="" src="2024/03/0703_Infinite_Elite_E_AppHeroImage_W750xH489px.jpg?$staticlink$" />
<img alt="" src="images/2024/02/020224_New_Arrivals_E_AppHeroImage_W750xH489px.jpg?$staticlink$" />

position: -webkit-sticky; //Safari
position: sticky;
top: 162px;

wp.domReady(function () {
	wp.blocks.registerBlockStyle('core/button', {
		name: 'with-arrow',
		label: 'With Arrow',
	});
	wp.blocks.registerBlockStyle('core/button', {
		name: 'link-btn',
		label: 'Link Btn',
	});
  	wp.blocks.registerBlockStyle('core/list', {
		name: 'check',
		label: 'check mark',
	});
});

constructor(element) {
		this.$element = $(element);
		this.$slider = this.$element.find('.team-carousel__slider');

		this.init();
	}

	init() {
		const itemCount = this.$slider.find('.team-carousel__slider-item').length;
		if (itemCount > 4) {
			this.$slider.addClass('owl-carousel');
			this.$slider.owlCarousel({
				margin: 30,
				center: false,
				autoplay: true,
				autoplaySpeed: 2000,
				autoplayHoverPause: true,
				responsiveClass: true,
				items: 1,
				navText: [
					'<a class="arrow-left" aria-hidden="true"></a>',
					'<a class="arrow-right" aria-hidden="true"></a>',
				],
				responsive: {
					576: {
						items: 1,
					},
					789: {
						items: 2,
					},
					992: {
						items: 3,
					},
					1199: {
						items: 4,
					},
				},
			});
		} else if (itemCount <= 4) {
			this.$slider.removeClass('owl-carousel');
		} else {
			this.$slider.removeClass('owl-carousel');
		}
	}

//$(document).ready(function () {
// 	var $landingMasthead = $('[data-landing-masthead]');
// 	if ($landingMasthead.children().length > 1) {
// 		$landingMasthead.owlCarousel({
// 			loop: false,
// 			nav: true,
// 			dots: true,
// 			animateIn: true,
// 			responsiveClass: true,
// 			items: 1,
// 			navText: [
// 				'<a class="arrow-left" aria-hidden="true"></a>',
// 				'<a class="arrow-right" aria-hidden="true"></a>',
// 			],
// 		});
// 	} else {
// 		$landingMasthead.removeClass('owl-carousel');
// 	}
// });

$('.our-approach__row:first').addClass('active');
		$('.our-approach__content').hide();
		$('.our-approach__content:first').show();

		$('.our-approach__row').click(function () {
			$('.our-approach__row').removeClass('active');
			$(this).addClass('active');
			$('.our-approach__content').hide();

			var activeTab = $(this).find('a').attr('href');
			$(activeTab).fadeIn(700);
			return false;
		});

constructor(element) {
		this.$element = $(element);
		this.$tabs = this.$element.find('.accordion__tab');
		this.$innerConts = this.$element.find('.accordion__inner-cont');
		this.$contents = this.$element.find('.accordion__content');
		this.init();
	}

	init() {
		this.$tabs.first().addClass('active');
		this.$innerConts.first().addClass('active');
		this.$tabs.click((e) => {
			e.preventDefault();
			const $this = $(e.currentTarget);
			this.$tabs.not($this).add(this.$innerConts).removeClass('active');
			this.$contents.not($this.next()).slideUp();
			$this.toggleClass('active').parent().toggleClass('active');
			$this.find('.icon').toggleClass('icon-up icon-down');
			$this.next().slideToggle();
		});
	}

// constructor(element) {
	// 	this.$element = $(element);
	// 	this.$tabs = this.$element.find('.faq__tab');
	// 	this.init();
	// }

	// init() {
	// 	$('.faq__tab:first, .faq__inner-cont:first').addClass('active');
	// 	this.$tabs.click(function (e) {
	// 		e.preventDefault();
	// 		$('.faq__tab, .faq__inner-cont').not(this).removeClass('active');
	// 		$('.faq__content').not($(this).next()).slideUp();
	// 		$(this).toggleClass('active');
	// 		$(this).parent().toggleClass('active');
	// 		$(this).find('.icon').toggleClass('icon-up icon-down');
	// 		$(this).next().slideToggle();
	// 	});
	// }

jQuery('img').each(function($){
            var $img = jQuery(this);
            var imgID = $img.attr('id');
            var imgClass = $img.attr('class');
            var imgURL = $img.attr('src');

            jQuery.get(imgURL, function(data) {
                // Get the SVG tag, ignore the rest
                var $svg = jQuery(data).find('svg');

                // Add replaced image's ID to the new SVG
                if(typeof imgID !== 'undefined') {
                    $svg = $svg.attr('id', imgID);
                }
                // Add replaced image's classes to the new SVG
                if(typeof imgClass !== 'undefined') {
                    $svg = $svg.attr('class', imgClass+' replaced-svg');
                }

                // Remove any invalid XML tags as per http://validator.w3.org
                $svg = $svg.removeAttr('xmlns:a');

                // Replace image with new SVG
                $img.replaceWith($svg);

            }, 'xml');

        });

constructor(element) {
		this.$element = $(element);
		this.$popup = this.$element.find('.media-text__img');

		this.init();
	}

	init() {
		this.$popup.magnificPopup({
			disableOn: 0,
			type: 'iframe',
			mainClass: 'mfp-fade',
			removalDelay: 160,
			preloader: false,
			fixedContentPos: true,
		});
	}

print(getwd())

setwd(“set the path”)

data<-read.csv("population.csv")

print(data)


OUTPUT: 

 population

 1 1000

 2 2000

 3 3500

 4 4500

 5 5000

zstat<-(mean(data$population)-1000)/(sd(data$population)/sqrt(nrow(data)))

print(zstat)

OUTPUT:

[1] 2.926836

Square_number<-function(a)
{
for(k in1:a)
{
n<-k^2
print(n)
}
}
Square_number(5)
#Create a function without
argument
fun<-function()
{
print(“Printing Numbers from 1 to 8”)
for(i in 1:8)
{
print(i)
}
}
fun()




data(mtcars)

s<-mtcars$cyl

pm<-3

a<-0.08

sm<-mean(s)

sts<-sd(s)

se<-std/sqrt(length(s))

z<-(sm-pm)/se

p<-2*pnorm(-abs(z))

print(z)

print(p)

if(p<a){

 print("Reject the null hypothesis")

}else{

 print("Failed to reject the null hypothesis")

}

{% unless template == 'index' %}
   <script src="https://cdn.static.kiwisizing.com/SizingPlugin.prod.js" defer> </script>
{% endunless %}

 .slick-dots li button:before
    {
        font-family: 'slick';
        font-size: 6px;
        line-height: 20px;
        ...
    }

from django.db.models import Count

# Using Subquery
authors_with_book_count = Author.objects.annotate(book_count=Subquery(Book.objects.filter(author=OuterRef('pk')).values('author').annotate(count=Count('id')).values('count')))

# Equivalent Non-Subquery Approach
authors = Author.objects.all()
authors_with_book_count = []
for author in authors:
    book_count = Book.objects.filter(author=author).count()
    authors_with_book_count.append({'author': author, 'book_count': book_count})
Copy

DECLARE

CURSOR C1(R NUMBER) IS SELECT * FROM SAILORS WHERE RATING=R;

I INTEGER;

BEGIN

FOR I IN 1..10 LOOP

DBMS_OUTPUT.PUT_LINE('SAILORS WITH RATING '|| I || ' ARE');

DBMS_OUTPUT.PUT_LINE('SID NAME AGE');

FOR Z IN C1(I) LOOP

/* It‘s not compulsory to define variable using rowtype for simple cursor as well as for update cursor */

DBMS_OUTPUT.PUT_LINE(Z.SID ||' ' ||Z.SNAME ||' '||Z.AGE);

END LOOP;

END LOOP;

END;

/





 create table sailors (sid integer,sname varchar2(30),rating integer,age real,primary key (sid));

 insert into sailors values(22, 'dustin',7,45.0);

 insert into sailors values(31, 'lubber',8,55.5);

 insert into sailors values(58, 'rusty', 10, 35.0);

void changeOrder(Button button){
        if (button == UP){
            temp = shapes[selectedShape];
            for(int i = selectedShape; i < shapeCounter; ++i){
                shapes[i] = shapes[i+1];
                std::cout << i << std::endl;            
            }
            shapes[shapeCounter - 1] = temp;
            selectedShape = shapeCounter - 1;
        }
        else if (button == DOWN){
            temp = shapes[selectedShape];
            for(int i = selectedShape; i > 0; --i){
                shapes[i] = shapes[i-1];
            }
            shapes[0] = temp;
            selectedShape = 0;
        }
    }

#ifndef TOOLBAR_H
#define TOOLBAR_H

#include "Rectangle.h"
#include "Texture.h"

enum Button {UP, DOWN, NONE};


class Toolbar {
    Rectangle area;
    Texture upArrow;
    Button button;
    Texture downArrow;

public:
    Toolbar(){
        area = Rectangle(-1.0f, 1.0f, 2.0f, 0.2f, Color(1.0f, 1.0f, 1.0f));
        upArrow = Texture("assets/upArrow.png", 0.7f, 0.95f, 0.1f, 0.1f, true);
        downArrow = Texture("assets/downArrow.png", 0.8f, 0.95f, 0.1f, 0.1f, true);

    }

    void handleMouseClick(float x, float y){
    
    }  

    void draw(){
        area.draw();
        upArrow.draw();
        downArrow.draw();
        
    }

    Button handleMouse(float x, float y){
        if(upArrow.contains(x, y)){
            return UP;
        }
        else if(downArrow.contains(x, y)){
            return DOWN;
        }
        else{
            return NONE;
        }
    }

    bool contains(float x, float y){
        return area.contains(x, y);
    }
};

#endif

sudo lsof -i :포트번호

Client Side Code Test.jsx --
import React, { useState, useEffect, useRef } from 'react';
import { initializeApp } from 'firebase/app';
import { getAuth, RecaptchaVerifier, signInWithPhoneNumber } from 'firebase/auth';

// Firebase config - replace with your own config
const firebaseConfig = {
  apiKey: "AIzaSyCb9uireOMfRCFfJpWWr1WmKdP629rNcCk",
  authDomain: "trial-34ed7.firebaseapp.com",
  projectId: "trial-34ed7",
  storageBucket: "trial-34ed7.appspot.com",
  messagingSenderId: "71628620493",
  appId: "1:71628620493:web:7c44729da8f9c541e55f84",
  measurementId: "G-N9GPF8ZQMZ"
};

// Initialize Firebase App
const app = initializeApp(firebaseConfig);
const auth = getAuth(app);

function Test() {
  const [mobile, setMobile] = useState('');
  const [otp, setOtp] = useState('');
  let confirmationResult = useRef(null);

  useEffect(() => {
    configureCaptcha();
  }, []);

  const handleChange = (e) => {
    const { name, value } = e.target;
    if (name === 'mobile') {
      setMobile(value);
    } else if (name === 'otp') {
      setOtp(value);
    }
  };

  const configureCaptcha = () => {
    window.recaptchaVerifier = new RecaptchaVerifier(auth, 'sign-in-button', {
      'size': 'invisible',
      'callback': (response) => {
        // reCAPTCHA solved, allow signInWithPhoneNumber.
        onSignInSubmit();
      }
    }, auth);
  };

  const onSignInSubmit = async (e) => {
    e.preventDefault();
    const phoneNumber = "+91" + mobile;
    console.log(phoneNumber);
    const appVerifier = window.recaptchaVerifier;
    try {
      confirmationResult.current = await signInWithPhoneNumber(auth, phoneNumber, appVerifier);
      console.log("OTP has been sent");
    } catch (error) {
      console.error("SMS not sent", error);
    }
  };

  const onSubmitOTP = async (e) => {
    e.preventDefault();
    try {
      const result = await confirmationResult.current.confirm(otp);
      const user = result.user;
      console.log(JSON.stringify(user));
      alert("User is verified");
    } catch (error) {
      console.error("User couldn't sign in (bad verification code?)", error);
    }
  };

  return (
    <div>
      <h2>Login Form</h2>
      <form onSubmit={onSignInSubmit}>
        <div id="sign-in-button"></div>
        <input type="text" name="mobile" placeholder="Mobile number" required onChange={handleChange} />
        <button type="submit">Submit</button>
      </form>

      <h2>Enter OTP</h2>
      <form onSubmit={onSubmitOTP}>
        <input type="text" name="otp" placeholder="OTP Number" required onChange={handleChange} />
        <button type="submit">Submit</button>
      </form>
    </div>
  );
}

export default Test;

const videoPlayers = document.getElementsByClassName('video-stream html5-main-video');
var videoPlayerss = videoPlayers[0]
var startTimes = 30
var endTimes = 68
var startTimes2 = 90
var endTimes2 = 150
var startTimes3 = 185
var endTimes3 = 270
videoPlayerss.currentTime = startTimes;
videoPlayerss.play();
videoPlayerss.addEventListener('timeupdate', () => {
  if (videoPlayerss.currentTime > endTimes && videoPlayerss.currentTime < startTimes2 ) {
    videoPlayerss.currentTime = startTimes2;
  } else if (videoPlayerss.currentTime > endTimes2 && videoPlayerss.currentTime < startTimes3 ) {
    videoPlayerss.currentTime = startTimes3;
  } else if (videoPlayerss.currentTime > endTimes3) {
    videoPlayerss.currentTime = startTimes;
  } 
});

var elementss2 = document.getElementsByClassName("ud-real-toggle-input");
//console.log(elementss2)
for (var i = 0; i < elementss2.length; i++) {
  if (!elementss2[i].hasAttribute("checked")) {
    console.log(elementss2[i]);
      elementss2[i].disabled = false;
      elementss2[i].click()
  }
}

var elementss2 = document.getElementsByClassName("contents");
//console.log(elementss2)
for (var i = 0; i < elementss2.length; i++) {
 elementss2[i].style = "display: none;";  
}

#define encoder_a 2 //keep this on and interrupt pin
#define encoder_b 3 //keep this on and interrupt pin
#define motor_step 9
#define motor_direction 8
#define motor_en 10 //
 
#define senzor_front 6 // sensor depan
#define senzor_rear 7  // sensor  samping
#define load_button 4
#define eject_button 5
 
volatile long motor_position, encoder;
int home_position = 0;
int load_position = 0;
int pe_load = 0;
 
void setup() {
     pinMode(encoder_a, INPUT);
     pinMode(encoder_b, INPUT);
 
     // disable pullup as we aren't using an open collector encoder
     digitalWrite(encoder_a, LOW);
     digitalWrite(encoder_b, LOW);
 
     //set up the various outputs
     pinMode(motor_step, OUTPUT);
     pinMode(motor_direction, OUTPUT);
     pinMode(motor_en, OUTPUT);//
     digitalWrite(motor_en, HIGH);//
     
     // then the senzors inputs
     pinMode(senzor_front, INPUT_PULLUP);
     pinMode(senzor_rear, INPUT_PULLUP);
 
     pinMode(load_button, INPUT_PULLUP);
     pinMode(eject_button, INPUT_PULLUP);
  //--------------------------------------------------
     // encoder pin on interrupt 0 (pin 2)
     attachInterrupt(0, encoderPinChangeA, CHANGE);
     // encoder pin on interrupt 1 (pin 3)
     attachInterrupt(1, encoderPinChangeB, CHANGE);
     encoder = 0;
 // -------------------------------------------------
 
}
 // -------------------------------------------------
void encoderPinChangeA(){
    if (digitalRead(encoder_a) == digitalRead(encoder_b)){
        encoder--;
    }
    else{
        encoder++;
    }
}
 
void encoderPinChangeB(){
    if (digitalRead(encoder_a) != digitalRead(encoder_b)){
        encoder--;
    }
    else{
        encoder++;
    }
}
 // -------------------------------------------------
 
 void loop() {
 
     // Control platen position of boot up and move to front
     if (home_position == 0) {
         digitalWrite(motor_direction, HIGH);
         TurnStepper();
         if (digitalRead(senzor_front) == LOW) {
             home_position = 1;
         }
      }
 
     // eject platen
     if (digitalRead(eject_button) == LOW) {
         home_position = 0;
     }
 
     // load platen
     if (digitalRead(load_button) == LOW) {
         load_position = 1;
     }
     if (load_position == 1) {
        digitalWrite(motor_direction, LOW);
        TurnStepper();
        if (digitalRead(senzor_rear) == LOW) {
           load_position = 0;
           pe_load = 1;
        }
      }
 // -------------------------------------------------
     if (encoder > 0){
         digitalWrite(motor_direction, HIGH);  //  output direction HIGH
         digitalWrite(motor_step, HIGH);       //  output step HIGH
         digitalWrite(motor_step, LOW);        //  output step LOW
         _delay_us(900);                       //  tunggu 200 microsecond
         motor_position++;                     //  posisi motor bergeser tambah satu point
         encoder = 0;                          //  reset ke 0
      }
      else if (encoder < 0){
         digitalWrite(motor_direction, LOW);   //  output direction LOW
         digitalWrite(motor_step, HIGH);       //  output step HIGH
         digitalWrite(motor_step, LOW);        //  output step LOW
         _delay_us(900);                       //  tunggu 200 microsecond
         motor_position--;                     //  posisi motor bergeser tambah satu point
         encoder = 0;                          //  reset ke 0
       }
 // -------------------------------------------------
}
 
void TurnStepper() {
     digitalWrite(motor_step, HIGH);
     delayMicroseconds(1000);                    //  speed motor 
     digitalWrite(motor_step, LOW);
     delayMicroseconds(1000);                    //  speed delay, the lower it is the faster
}

<?php if(preg_match('/\Ahttps?:\/\/([-\w\.]+)+(:\d+)?(\/([\w\/_\.]*(\?\S+)?)?)?\Z/', 'http://'.$_POST['domain'])) // URL auf validität überprüfen. 
{
  $whois=array(); // Array initialisieren. Es folgen Deklarationen des mehrdimensionalem Arrays.
  $whois['.de']['server']='whois.denic.de';
  $whois['.de']['string']='Status:      free';
  $whois['.com']['server']='whois.crsnic.net';
  $whois['.com']['string']='No match for';
  $whois['.net']['server']='whois.crsnic.net';
  $whois['.net']['string']='No match for';
  $whois['.org']['server']='whois.publicinterestregistry.net';
  $whois['.org']['string']='NOT FOUND';
  $whois['.info']['server']='whois.afilias.net';
  $whois['.info']['string']='NOT FOUND';
  $whois['.biz']['server']='whois.nic.biz';
  $whois['.biz']['string']='Not found';
  $whois['.ag']['server']='whois.nic.ag';
  $whois['.ag']['string']='NOT FOUND';
  $whois['.am']['server']='whois.nic.am';
  $whois['.am']['string']='No match';
  $whois['.as']['server']='whois.nic.as';
  $whois['.as']['string']='Domain Not Found';
  $whois['.at']['server']='whois.nic.at';
  $whois['.at']['string']='nothing found';
  $whois['.be']['server']='whois.dns.be';
  $whois['.be']['string']='Status:      FREE';
  $whois['.cd']['server']='whois.cd';
  $whois['.cd']['string']='No match';
  $whois['.ch']['server']='whois.nic.ch';
  $whois['.ch']['string']='not have an entry';
  $whois['.cx']['server']='whois.nic.cx';
  $whois['.cx']['string']='Status: Not Registered';
  $whois['.dk']['server']='whois.dk-hostmaster.dk';
  $whois['.dk']['string']='No entries found';
  $whois['.it']['server']='whois.nic.it';
  $whois['.it']['string']='Status: AVAILABLE';
  $whois['.li']['server']='whois.nic.li';
  $whois['.li']['string']='do not have an entry';
  $whois['.lu']['server']='whois.dns.lu';
  $whois['.lu']['string']='No such domain';
  $whois['.nu']['server']='whois.nic.nu';
  $whois['.nu']['string']='NO MATCH for';
  $whois['.ru']['server']='whois.ripn.net';
  $whois['.ru']['string']='No entries found';
  $whois['.uk.com']['server']='whois.centralnic.com';
  $whois['.uk.com']['string']='No match for';
  $whois['.eu.com']['server']='whois.centralnic.com';
  $whois['.eu.com']['string']='No match';
  $whois['.ws']['server']='whois.nic.ws';
  $whois['.ws']['string']='No match for';

  $domain=str_replace('www.', '', $_POST['domain']); // Solche Dinge sind Detailssache (..)  Letztlich muss die Anfrage an den WHOIS-Server ohne http::// , www. usw. stattfinden. -> Nur Domainname und Domainendung.

  if(get_magic_quotes_gpc==0)
  {
    $domain=addslashes($domain);
  } 

// Verbindung zum whois server aufbauen / Status der Domain erfragen.

 $check=fsockopen($whois[$_POST['tld']]['server'], 43);
  fputs($check, $domain.$_POST['tld']."\r\n");
  while(!feof($check)) 
  {
    $report=$report.fgets($check, 128);
  }
  fclose($check);

  if(ereg($whois[$_POST['tld']]['string'], $report)) // Was soll geschehen, wenn domain noch frei ist?
  {
    print('domain frei.');
  }
  else // Was, wenn nicht?
  {
    print('domain nicht frei.');
  }
} 
?>

*{
	margin: 0;
	padding: 0;
}
body{
	background: #f4f9ff;
}
#wrapper{
	width: 100%;
	max-width: 460px;
	background: #fff;
		margin: 20px auto;
	padding: 20px;
	border-bottom: 1px solid #e7e7e7;
}
input{
	width: 100%;
	padding: 10px 0;
	margin-bottom: 20px;
}
button{
	border: none;
	background: #e7e7e7;
	padding: 10px 20px;
}
.result{
	text-align: center;
	font-size: 22px;
	margin-top: 20px;
}
.success{
	color: green;
}
.failur{
	color: red;
}

<?php
/*
 * @ PHP 5.6
 * @ Decoder version : 1.0.0.1
 * @ Release on : 24.03.2018
 * @ Website    : http://EasyToYou.eu
 */

require "init.php";
require ROOTDIR . DIRECTORY_SEPARATOR . "includes" . DIRECTORY_SEPARATOR . "clientareafunctions.php";
$domain = WHMCS\Input\Sanitize::decode(App::getFromRequest("domain"));
$ext = App::getFromRequest("ext");
$sld = App::getFromRequest("sld");
$tld = App::getFromRequest("tld");
$tlds = App::getFromRequest("search_tlds");
$captcha = new WHMCS\Utility\Captcha();
$validate = new WHMCS\Validate();
$captcha->validateAppropriateCaptcha(WHMCS\Utility\Captcha::FORM_DOMAIN_CHECKER, $validate);
if ($validate->hasErrors()) {
    WHMCS\Session::set("captchaData", array("invalidCaptcha" => true, "invalidCaptchaError" => $validate->getErrors()[0]));
    WHMCS\Session::set("CaptchaComplete", false);
} else {
    WHMCS\Session::set("captchaData", array("invalidCaptcha" => false, "invalidCaptchaError" => false));
    WHMCS\Session::set("CaptchaComplete", true);
}
if (in_array($domain, array(Lang::trans("domaincheckerdomainexample")))) {
    $domain = "";
}
if ($ext && $domain) {
    if (substr($ext, 0, 1) != ".") {
        $ext = "." . $ext;
    }
    $domain .= $ext;
}
if (!$domain && $sld && $tld) {
    if (substr($tld, 0, 1) != ".") {
        $tld = "." . $tld;
    }
    $domain = $sld . $tld;
}
if (is_array($tlds) && 0 < count($tlds)) {
    $tldToAppend = $tlds[0];
    if (substr($tldToAppend, 0, 1) != ".") {
        $tldToAppend = "." . $tldToAppend;
    }
    if ($domain) {
        $domain = $domain . $tldToAppend;
    } else {
        if ($sld) {
            $domain = $sld . $tldToAppend;
        }
    }
}
$domainRequestSuffix = $domain ? "&query=" . urlencode($domain) : "";
if (App::getFromRequest("transfer")) {
    App::redirect("cart.php", "a=add&domain=transfer" . $domainRequestSuffix);
}
if (App::getFromRequest("hosting")) {
    App::redirect("cart.php", substr($domainRequestSuffix, 1));
}
App::redirect("cart.php", "a=add&domain=register" . $domainRequestSuffix);

?>

<!DOCTYPE html>
<html lang="en">
<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>Domain checker</title>
	<link rel="stylesheet" href="./style.css">
</head>
<body>
	<div id="wrapper">		
		<form method="POST">
			<input type="text" name="domain" <?php if(isset($_POST['domain'])) echo 'value="'.$_POST['domain'].'"' ?>>
			<button type="submit">Check</button>
		</form>
		<div class="result">
			<?php 
				if(isset($_POST['domain'])){
					if ( gethostbyname($_POST['domain']) == $_POST['domain'] )
					    echo "<p class='success'>Congatulations! {$_POST['domain']} is available</p>";
					else
						echo "<p class='failur'>Sorry, {$_POST['domain']} is not available</p>";
				}
			?>
		</div>
	</div>
</body>
</html>

ng g c my-page