first version of new profile

Dockerfile.txt

+# Specify parent image. Please select a fixed tag here.
+ARG BASE_IMAGE=registry.git.rwth-aachen.de/jupyter/profiles/octave
+FROM ${BASE_IMAGE}
+
+# Install packages via requirements.txt
+ADD requirements.txt .
+RUN pip install -r requirements.txt
+
+# .. Or update conda base environment to match specifications in environment.yml
+ADD environment.yml /tmp/environment.yml
+
+# All packages specified in environment.yml are installed in the base environment
+RUN conda env update -f /tmp/environment.yml && \
+    conda clean -a -f -y

README.md

+# Jupyter Example Profile
+
+## Introduction
+
+This repository contains an exemplary Jupyter profile which works with the RWTH Jupyter server. To be more specific, it includes the following files
+* `Dockerfile` which defines the linux environment. In the end, the packages of an `environment.yml` or here the `requirements.txt` are installed.
+
+[Here is a quick start guide of an example profile](https://git.rwth-aachen.de/jupyter/example-profile/-/blob/master/Quickstart.ipynb).
+
+## Installation
+
+### Local Installation
+
+To run the notebooks on your local machine, you may use [Anaconda](https://www.anaconda.com/) (using `pip` is also possible for experienced users. You have to install all the requirements listed in `environment.yml` and install the commands listed in `postBuild.sh`).
+
+* Install [Anaconda](https://www.anaconda.com/).
+* Download this repository to your local disk. You can download it as a zip-File or use `git`:  
+
+  ```bash
+  git clone git@git.rwth-aachen.de:acs/public/teaching/systemtheorie2/lecture-tutorials.git
+  ```
+
+* It is highly recommended to run the notebooks in an isolated Anaconda environment. You can create a new environment called `jupyter-sys2-profile` from the provided `environment.yml` by running the following command in the Anaconda prompt
+
+  ```bash
+  conda env create -f environment.yml
+  ```
+  
+  This makes sure that all required packages are installed amd don't interfere with the packages in your base environment.
+* Activate this environment with
+
+  ```bash
+  conda activate jupyter-sys2-profile
+  ```
+
+### Local Run
+
+* Activate the environment  with `conda activate jupyter-sys2-profile`.
+* Run JupyterLab  `jupyter lab`. In your browser, JupyterLab should start. You can then open `index.ipynb` for an overview over all notebooks.
+* You can deactivate the environment with `conda deactivate`.
+
+## Contact
+
+* If you found a bug, please use the [issue tracker](https://git.rwth-aachen.de/acs/public/teaching/systemtheorie2/lecture-tutorials/-/issues).
+* In all other cases, please contact [your system theory team](https://www.acs.eonerc.rwth-aachen.de/cms/E-ON-ERC-ACS/Studium/Lehrveranstaltungen/~bycsp/Systemtheorie/).
+
+The code is licensed under the [MIT license](https://opensource.org/licenses/MIT).

environment.yml

+name: base
+channels:
+  - conda-forge
\ No newline at end of file

matlab/V1/V1_1_soundsamples.m

+
+% Abstast Frequenz
+fa = 10000;
+T = 1/fa
+
+maxk = 20000
+k=1:maxk;
+t=k.*T;
+
+% A Tone 440 Hz
+om = 2*pi*440
+y = sin(om*t);
+
+soundsc(y,fa/2  )
\ No newline at end of file

matlab/V1/V1_2_aliasing.m

+% Frequenz Signal 1
+om1 = 1
+
+% Frequenz Signal 2
+om2 = 1+2*pi
+
+% Abtast Frequenz
+om_T = 2*pi
+
+% Abtast Zeit
+T = 2*pi/om_T
+
+maxk = 200
+k=1:maxk
+t=k.*T
+
+%Signal 1
+y1 = sin(om1*k*T)
+
+%Signal 2
+y2 = sin(om2*k*T)
+
+plot(t,y1,t,y2)
+

matlab/V10/kalman1.m

+function [sys,x0,str,ts] = kalman1(t,x,u,flag,sigma,Ts,xo,ro)
+%SFUNTMPL General M-file S-function template
+%   With M-file S-functions, you can define you own ordinary differential
+%   equations (ODEs), discrete system equations, and/or just about
+%   any type of algorithm to be used within a Simulink block diagram.
+%
+%   The general form of an M-File S-function syntax is:
+%       [SYS,X0,STR,TS] = SFUNC(T,X,U,FLAG,P1,...,Pn)
+%
+%   What is returned by SFUNC at a given point in time, T, depends on the
+%   value of the FLAG, the current state vector, X, and the current
+%   input vector, U.
+%
+%   FLAG   RESULT             DESCRIPTION
+%   -----  ------             --------------------------------------------
+%   0      [SIZES,X0,STR,TS]  Initialization, return system sizes in SYS,
+%                             initial state in X0, state ordering strings
+%                             in STR, and sample times in TS.
+%   1      DX                 Return continuous state derivatives in SYS.
+%   2      DS                 Update discrete states SYS = X(n+1)
+%   3      Y                  Return outputs in SYS.
+%   4      TNEXT              Return next time hit for variable step sample
+%                             time in SYS.
+%   5                         Reserved for future (root finding).
+%   9      []                 Termination, perform any cleanup SYS=[].
+%
+%
+%   The state vectors, X and X0 consists of continuous states followed
+%   by discrete states.
+%
+%   Optional parameters, P1,...,Pn can be provided to the S-function and
+%   used during any FLAG operation.
+%
+%   When SFUNC is called with FLAG = 0, the following information
+%   should be returned:
+%
+%      SYS(1) = Number of continuous states.
+%      SYS(2) = Number of discrete states.
+%      SYS(3) = Number of outputs.
+%      SYS(4) = Number of inputs.
+%               Any of the first four elements in SYS can be specified
+%               as -1 indicating that they are dynamically sized. The
+%               actual length for all other flags will be equal to the
+%               length of the input, U.
+%      SYS(5) = Reserved for root finding. Must be zero.
+%      SYS(6) = Direct feedthrough flag (1=yes, 0=no). The s-function
+%               has direct feedthrough if U is used during the FLAG=3
+%               call. Setting this to 0 is akin to making a promise that
+%               U will not be used during FLAG=3. If you break the promise
+%               then unpredictable results will occur.
+%      SYS(7) = Number of sample times. This is the number of rows in TS.
+%
+%
+%      X0     = Initial state conditions or [] if no states.
+%
+%      STR    = State ordering strings which is generally specified as [].
+%
+%      TS     = An m-by-2 matrix containing the sample time
+%               (period, offset) information. Where m = number of sample
+%               times. The ordering of the sample times must be:
+%
+%               TS = [0      0,      : Continuous sample time.
+%                     0      1,      : Continuous, but fixed in minor step
+%                                      sample time.
+%                     PERIOD OFFSET, : Discrete sample time where
+%                                      PERIOD > 0 & OFFSET < PERIOD.
+%                     -2     0];     : Variable step discrete sample time
+%                                      where FLAG=4 is used to get time of
+%                                      next hit.
+%
+%               There can be more than one sample time providing
+%               they are ordered such that they are monotonically
+%               increasing. Only the needed sample times should be
+%               specified in TS. When specifying than one
+%               sample time, you must check for sample hits explicitly by
+%               seeing if
+%                  abs(round((T-OFFSET)/PERIOD) - (T-OFFSET)/PERIOD)
+%               is within a specified tolerance, generally 1e-8. This
+%               tolerance is dependent upon your model's sampling times
+%               and simulation time.
+%
+%               You can also specify that the sample time of the S-function
+%               is inherited from the driving block. For functions which
+%               change during minor steps, this is done by
+%               specifying SYS(7) = 1 and TS = [-1 0]. For functions which
+%               are held during minor steps, this is done by specifying
+%               SYS(7) = 1 and TS = [-1 1].
+
+%   Copyright 1990-2000 The MathWorks, Inc.
+%   $Revision: 1.16 $
+
+%
+% The following outlines the general structure of an S-function.
+%
+switch flag,
+
+  %%%%%%%%%%%%%%%%%%
+  % Initialization %
+  %%%%%%%%%%%%%%%%%%
+  case 0,
+    [sys,x0,str,ts]=mdlInitializeSizes(Ts,xo,ro);
+
+  %%%%%%%%%%%%%%%
+  % Derivatives %
+  %%%%%%%%%%%%%%%
+  case 1,
+    sys=mdlDerivatives(t,x,u);
+
+  %%%%%%%%%%
+  % Update %
+  %%%%%%%%%%
+  case 2,
+    sys=mdlUpdate(t,x,u,sigma);
+
+  %%%%%%%%%%%
+  % Outputs %
+  %%%%%%%%%%%
+  case 3,
+    sys=mdlOutputs(t,x,u);
+
+  %%%%%%%%%%%%%%%%%%%%%%%
+  % GetTimeOfNextVarHit %
+  %%%%%%%%%%%%%%%%%%%%%%%
+  case 4,
+    sys=mdlGetTimeOfNextVarHit(t,x,u,Ts);
+
+  %%%%%%%%%%%%%
+  % Terminate %
+  %%%%%%%%%%%%%
+  case 9,
+    sys=mdlTerminate(t,x,u);
+
+  %%%%%%%%%%%%%%%%%%%%
+  % Unexpected flags %
+  %%%%%%%%%%%%%%%%%%%%
+  otherwise
+    error(['Unhandled flag = ',num2str(flag)]);
+
+end
+
+% end sfuntmpl
+
+%
+%=============================================================================
+% mdlInitializeSizes
+% Return the sizes, initial conditions, and sample times for the S-function.
+%=============================================================================
+%
+function [sys,x0,str,ts]=mdlInitializeSizes(Ts,xo,ro)
+
+%
+% call simsizes for a sizes structure, fill it in and convert it to a
+% sizes array.
+%
+% Note that in this example, the values are hard coded.  This is not a
+% recommended practice as the characteristics of the block are typically
+% defined by the S-function parameters.
+%
+sizes = simsizes;
+
+sizes.NumContStates  = 0;
+sizes.NumDiscStates  = 2;
+sizes.NumOutputs     = 1;
+sizes.NumInputs      = 1;
+sizes.DirFeedthrough = 1;
+sizes.NumSampleTimes = 1;   % at least one sample time is needed
+
+sys = simsizes(sizes);
+
+%
+% initialize the initial conditions
+%
+x0  = [xo ro];
+
+%
+% str is always an empty matrix
+%
+str = [];
+
+%
+% initialize the array of sample times
+%
+ts  = [Ts 0];
+
+% end mdlInitializeSizes
+
+%
+%=============================================================================
+% mdlDerivatives
+% Return the derivatives for the continuous states.
+%=============================================================================
+%
+function sys=mdlDerivatives(t,x,u)
+
+sys = [];
+
+% end mdlDerivatives
+
+%
+%=============================================================================
+% mdlUpdate
+% Handle discrete state updates, sample time hits, and major time step
+% requirements.
+%=============================================================================
+%
+function sys=mdlUpdate(t,x,u,sigma)
+
+sys(2) = sigma*sigma*x(2)/(sigma*sigma+x(2));
+K = sys(2)/(sigma*sigma);
+sys(1) = x(1)+K*(u(1)-x(1));
+
+% end mdlUpdate
+
+%
+%=============================================================================
+% mdlOutputs
+% Return the block outputs.
+%=============================================================================
+%
+function sys=mdlOutputs(t,x,u)
+
+sys(1) = x(1);
+
+% end mdlOutputs
+
+%
+%=============================================================================
+% mdlGetTimeOfNextVarHit
+% Return the time of the next hit for this block.  Note that the result is
+% absolute time.  Note that this function is only used when you specify a
+% variable discrete-time sample time [-2 0] in the sample time array in
+% mdlInitializeSizes.
+%=============================================================================
+%
+function sys=mdlGetTimeOfNextVarHit(t,x,u)
+
+
+sys = [];
+
+% end mdlGetTimeOfNextVarHit
+
+%
+%=============================================================================
+% mdlTerminate
+% Perform any end of simulation tasks.
+%=============================================================================
+%
+function sys=mdlTerminate(t,x,u)
+
+sys = [];
+
+% end mdlTerminate

matlab/V10/kalman2.m

+function [sys,x0,str,ts] = kalman2(t,x,u,flag,sigma,Ts,xo,ro)
+%SFUNTMPL General M-file S-function template
+%   With M-file S-functions, you can define you own ordinary differential
+%   equations (ODEs), discrete system equations, and/or just about
+%   any type of algorithm to be used within a Simulink block diagram.
+%
+%   The general form of an M-File S-function syntax is:
+%       [SYS,X0,STR,TS] = SFUNC(T,X,U,FLAG,P1,...,Pn)
+%
+%   What is returned by SFUNC at a given point in time, T, depends on the
+%   value of the FLAG, the current state vector, X, and the current
+%   input vector, U.
+%
+%   FLAG   RESULT             DESCRIPTION
+%   -----  ------             --------------------------------------------
+%   0      [SIZES,X0,STR,TS]  Initialization, return system sizes in SYS,
+%                             initial state in X0, state ordering strings
+%                             in STR, and sample times in TS.
+%   1      DX                 Return continuous state derivatives in SYS.
+%   2      DS                 Update discrete states SYS = X(n+1)
+%   3      Y                  Return outputs in SYS.
+%   4      TNEXT              Return next time hit for variable step sample
+%                             time in SYS.
+%   5                         Reserved for future (root finding).
+%   9      []                 Termination, perform any cleanup SYS=[].
+%
+%
+%   The state vectors, X and X0 consists of continuous states followed
+%   by discrete states.
+%
+%   Optional parameters, P1,...,Pn can be provided to the S-function and
+%   used during any FLAG operation.
+%
+%   When SFUNC is called with FLAG = 0, the following information
+%   should be returned:
+%
+%      SYS(1) = Number of continuous states.
+%      SYS(2) = Number of discrete states.
+%      SYS(3) = Number of outputs.
+%      SYS(4) = Number of inputs.
+%               Any of the first four elements in SYS can be specified
+%               as -1 indicating that they are dynamically sized. The
+%               actual length for all other flags will be equal to the
+%               length of the input, U.
+%      SYS(5) = Reserved for root finding. Must be zero.
+%      SYS(6) = Direct feedthrough flag (1=yes, 0=no). The s-function
+%               has direct feedthrough if U is used during the FLAG=3
+%               call. Setting this to 0 is akin to making a promise that
+%               U will not be used during FLAG=3. If you break the promise
+%               then unpredictable results will occur.
+%      SYS(7) = Number of sample times. This is the number of rows in TS.
+%
+%
+%      X0     = Initial state conditions or [] if no states.
+%
+%      STR    = State ordering strings which is generally specified as [].
+%
+%      TS     = An m-by-2 matrix containing the sample time
+%               (period, offset) information. Where m = number of sample
+%               times. The ordering of the sample times must be:
+%
+%               TS = [0      0,      : Continuous sample time.
+%                     0      1,      : Continuous, but fixed in minor step
+%                                      sample time.
+%                     PERIOD OFFSET, : Discrete sample time where
+%                                      PERIOD > 0 & OFFSET < PERIOD.
+%                     -2     0];     : Variable step discrete sample time
+%                                      where FLAG=4 is used to get time of
+%                                      next hit.
+%
+%               There can be more than one sample time providing
+%               they are ordered such that they are monotonically
+%               increasing. Only the needed sample times should be
+%               specified in TS. When specifying than one
+%               sample time, you must check for sample hits explicitly by
+%               seeing if
+%                  abs(round((T-OFFSET)/PERIOD) - (T-OFFSET)/PERIOD)
+%               is within a specified tolerance, generally 1e-8. This
+%               tolerance is dependent upon your model's sampling times
+%               and simulation time.
+%
+%               You can also specify that the sample time of the S-function
+%               is inherited from the driving block. For functions which
+%               change during minor steps, this is done by
+%               specifying SYS(7) = 1 and TS = [-1 0]. For functions which
+%               are held during minor steps, this is done by specifying
+%               SYS(7) = 1 and TS = [-1 1].
+
+%   Copyright 1990-2000 The MathWorks, Inc.
+%   $Revision: 1.16 $
+
+%
+% The following outlines the general structure of an S-function.
+%
+switch flag,
+
+  %%%%%%%%%%%%%%%%%%
+  % Initialization %
+  %%%%%%%%%%%%%%%%%%
+  case 0,
+    [sys,x0,str,ts]=mdlInitializeSizes(Ts,xo,ro);
+
+  %%%%%%%%%%%%%%%
+  % Derivatives %
+  %%%%%%%%%%%%%%%
+  case 1,
+    sys=mdlDerivatives(t,x,u);
+
+  %%%%%%%%%%
+  % Update %
+  %%%%%%%%%%
+  case 2,
+    sys=mdlUpdate(t,x,u,sigma);
+
+  %%%%%%%%%%%
+  % Outputs %
+  %%%%%%%%%%%
+  case 3,
+    sys=mdlOutputs(t,x,u);
+
+  %%%%%%%%%%%%%%%%%%%%%%%
+  % GetTimeOfNextVarHit %
+  %%%%%%%%%%%%%%%%%%%%%%%
+  case 4,
+    sys=mdlGetTimeOfNextVarHit(t,x,u,Ts);
+
+  %%%%%%%%%%%%%
+  % Terminate %
+  %%%%%%%%%%%%%
+  case 9,
+    sys=mdlTerminate(t,x,u);
+
+  %%%%%%%%%%%%%%%%%%%%
+  % Unexpected flags %
+  %%%%%%%%%%%%%%%%%%%%
+  otherwise
+    error(['Unhandled flag = ',num2str(flag)]);
+
+end
+
+% end sfuntmpl
+
+%
+%=============================================================================
+% mdlInitializeSizes
+% Return the sizes, initial conditions, and sample times for the S-function.
+%=============================================================================
+%
+function [sys,x0,str,ts]=mdlInitializeSizes(Ts,xo,ro)
+
+%
+% call simsizes for a sizes structure, fill it in and convert it to a
+% sizes array.
+%
+% Note that in this example, the values are hard coded.  This is not a
+% recommended practice as the characteristics of the block are typically
+% defined by the S-function parameters.
+%
+sizes = simsizes;
+
+sizes.NumContStates  = 0;
+sizes.NumDiscStates  = 2;
+sizes.NumOutputs     = 1;
+sizes.NumInputs      = 1;
+sizes.DirFeedthrough = 1;
+sizes.NumSampleTimes = 1;   % at least one sample time is needed
+
+sys = simsizes(sizes);
+
+%
+% initialize the initial conditions
+%
+x0  = [xo ro];
+
+%
+% str is always an empty matrix
+%
+str = [];
+
+%
+% initialize the array of sample times
+%
+ts  = [Ts 0];
+
+% end mdlInitializeSizes
+
+%
+%=============================================================================
+% mdlDerivatives
+% Return the derivatives for the continuous states.
+%=============================================================================
+%
+function sys=mdlDerivatives(t,x,u)
+
+sys = [];
+
+% end mdlDerivatives
+
+%
+%=============================================================================
+% mdlUpdate
+% Handle discrete state updates, sample time hits, and major time step
+% requirements.
+%=============================================================================
+%
+function sys=mdlUpdate(t,x,u,sigma)
+
+sys(2) = sigma*sigma*x(2)/(sigma*sigma+x(2));
+K = sys(2)/(sigma*sigma);
+sys(1) = x(1)+K*(u(1)-x(1));
+
+% end mdlUpdate
+
+%
+%=============================================================================
+% mdlOutputs
+% Return the block outputs.
+%=============================================================================
+%
+function sys=mdlOutputs(t,x,u)
+
+sys(1) = x(1);
+
+% end mdlOutputs
+
+%
+%=============================================================================
+% mdlGetTimeOfNextVarHit
+% Return the time of the next hit for this block.  Note that the result is
+% absolute time.  Note that this function is only used when you specify a
+% variable discrete-time sample time [-2 0] in the sample time array in
+% mdlInitializeSizes.
+%=============================================================================
+%
+function sys=mdlGetTimeOfNextVarHit(t,x,u)
+
+
+sys = [];
+
+% end mdlGetTimeOfNextVarHit
+
+%
+%=============================================================================
+% mdlTerminate
+% Perform any end of simulation tasks.
+%=============================================================================
+%
+function sys=mdlTerminate(t,x,u)
+
+sys = [];
+
+% end mdlTerminate

matlab/V10/kalman3.m

+function [sys,x0,str,ts] = kalman3(t,x,u,flag,Ts,xo,ro,r1,r2)
+%SFUNTMPL General M-file S-function template
+%   With M-file S-functions, you can define you own ordinary differential
+%   equations (ODEs), discrete system equations, and/or just about
+%   any type of algorithm to be used within a Simulink block diagram.
+%
+%   The general form of an M-File S-function syntax is:
+%       [SYS,X0,STR,TS] = SFUNC(T,X,U,FLAG,P1,...,Pn)
+%
+%   What is returned by SFUNC at a given point in time, T, depends on the
+%   value of the FLAG, the current state vector, X, and the current
+%   input vector, U.
+%
+%   FLAG   RESULT             DESCRIPTION
+%   -----  ------             --------------------------------------------
+%   0      [SIZES,X0,STR,TS]  Initialization, return system sizes in SYS,
+%                             initial state in X0, state ordering strings
+%                             in STR, and sample times in TS.
+%   1      DX                 Return continuous state derivatives in SYS.
+%   2      DS                 Update discrete states SYS = X(n+1)
+%   3      Y                  Return outputs in SYS.
+%   4      TNEXT              Return next time hit for variable step sample
+%                             time in SYS.
+%   5                         Reserved for future (root finding).
+%   9      []                 Termination, perform any cleanup SYS=[].
+%
+%
+%   The state vectors, X and X0 consists of continuous states followed
+%   by discrete states.
+%
+%   Optional parameters, P1,...,Pn can be provided to the S-function and
+%   used during any FLAG operation.
+%
+%   When SFUNC is called with FLAG = 0, the following information
+%   should be returned:
+%
+%      SYS(1) = Number of continuous states.
+%      SYS(2) = Number of discrete states.
+%      SYS(3) = Number of outputs.
+%      SYS(4) = Number of inputs.
+%               Any of the first four elements in SYS can be specified
+%               as -1 indicating that they are dynamically sized. The
+%               actual length for all other flags will be equal to the
+%               length of the input, U.
+%      SYS(5) = Reserved for root finding. Must be zero.
+%      SYS(6) = Direct feedthrough flag (1=yes, 0=no). The s-function
+%               has direct feedthrough if U is used during the FLAG=3
+%               call. Setting this to 0 is akin to making a promise that
+%               U will not be used during FLAG=3. If you break the promise
+%               then unpredictable results will occur.
+%      SYS(7) = Number of sample times. This is the number of rows in TS.
+%
+%
+%      X0     = Initial state conditions or [] if no states.
+%
+%      STR    = State ordering strings which is generally specified as [].
+%
+%      TS     = An m-by-2 matrix containing the sample time
+%               (period, offset) information. Where m = number of sample
+%               times. The ordering of the sample times must be:
+%
+%               TS = [0      0,      : Continuous sample time.
+%                     0      1,      : Continuous, but fixed in minor step
+%                                      sample time.
+%                     PERIOD OFFSET, : Discrete sample time where
+%                                      PERIOD > 0 & OFFSET < PERIOD.
+%                     -2     0];     : Variable step discrete sample time
+%                                      where FLAG=4 is used to get time of
+%                                      next hit.
+%
+%               There can be more than one sample time providing
+%               they are ordered such that they are monotonically
+%               increasing. Only the needed sample times should be
+%               specified in TS. When specifying than one
+%               sample time, you must check for sample hits explicitly by
+%               seeing if
+%                  abs(round((T-OFFSET)/PERIOD) - (T-OFFSET)/PERIOD)
+%               is within a specified tolerance, generally 1e-8. This
+%               tolerance is dependent upon your model's sampling times
+%               and simulation time.
+%
+%               You can also specify that the sample time of the S-function
+%               is inherited from the driving block. For functions which
+%               change during minor steps, this is done by
+%               specifying SYS(7) = 1 and TS = [-1 0]. For functions which
+%               are held during minor steps, this is done by specifying
+%               SYS(7) = 1 and TS = [-1 1].
+
+%   Copyright 1990-2000 The MathWorks, Inc.
+%   $Revision: 1.16 $
+
+%
+% The following outlines the general structure of an S-function.
+%
+switch flag,
+
+  %%%%%%%%%%%%%%%%%%
+  % Initialization %
+  %%%%%%%%%%%%%%%%%%
+  case 0,
+    [sys,x0,str,ts]=mdlInitializeSizes(Ts,xo,ro);
+
+  %%%%%%%%%%%%%%%
+  % Derivatives %
+  %%%%%%%%%%%%%%%
+  case 1,
+    sys=mdlDerivatives(t,x,u);
+
+  %%%%%%%%%%
+  % Update %
+  %%%%%%%%%%
+  case 2,
+    sys=mdlUpdate(t,x,u,r1,r2);
+
+  %%%%%%%%%%%
+  % Outputs %
+  %%%%%%%%%%%
+  case 3,
+    sys=mdlOutputs(t,x,u);
+
+  %%%%%%%%%%%%%%%%%%%%%%%
+  % GetTimeOfNextVarHit %
+  %%%%%%%%%%%%%%%%%%%%%%%
+  case 4,
+    sys=mdlGetTimeOfNextVarHit(t,x,u,Ts);
+
+  %%%%%%%%%%%%%
+  % Terminate %
+  %%%%%%%%%%%%%
+  case 9,
+    sys=mdlTerminate(t,x,u);
+
+  %%%%%%%%%%%%%%%%%%%%
+  % Unexpected flags %
+  %%%%%%%%%%%%%%%%%%%%
+  otherwise
+    error(['Unhandled flag = ',num2str(flag)]);
+
+end
+
+% end sfuntmpl
+
+%
+%=============================================================================
+% mdlInitializeSizes
+% Return the sizes, initial conditions, and sample times for the S-function.
+%=============================================================================
+%
+function [sys,x0,str,ts]=mdlInitializeSizes(Ts,xo,ro)
+
+%
+% call simsizes for a sizes structure, fill it in and convert it to a
+% sizes array.
+%
+% Note that in this example, the values are hard coded.  This is not a
+% recommended practice as the characteristics of the block are typically
+% defined by the S-function parameters.
+%
+sizes = simsizes;
+
+sizes.NumContStates  = 0;
+sizes.NumDiscStates  = 2;
+sizes.NumOutputs     = 1;
+sizes.NumInputs      = 2;
+sizes.DirFeedthrough = 1;
+sizes.NumSampleTimes = 1;   % at least one sample time is needed
+
+sys = simsizes(sizes);
+
+%
+% initialize the initial conditions
+%
+x0  = [xo ro];
+
+%
+% str is always an empty matrix
+%
+str = [];
+
+%
+% initialize the array of sample times
+%
+ts  = [Ts 0];
+
+% end mdlInitializeSizes
+
+%
+%=============================================================================
+% mdlDerivatives
+% Return the derivatives for the continuous states.
+%=============================================================================
+%
+function sys=mdlDerivatives(t,x,u)
+
+sys = [];
+
+% end mdlDerivatives
+
+%
+%=============================================================================
+% mdlUpdate
+% Handle discrete state updates, sample time hits, and major time step
+% requirements.
+%=============================================================================
+%
+function sys=mdlUpdate(t,x,u,r1,r2)
+
+sys(2) = r2*(r1+0.25*x(2))/(r2+r1+0.25*x(2));
+K = sys(2)/(r2);
+sys(1) = 0.5*x(1)+u(2)+K*(u(1)-(0.25*x(1)+u(2)));
+
+% end mdlUpdate
+
+%
+%=============================================================================
+% mdlOutputs
+% Return the block outputs.
+%=============================================================================
+%
+function sys=mdlOutputs(t,x,u)
+
+sys(1) = x(1);
+
+% end mdlOutputs
+
+%
+%=============================================================================
+% mdlGetTimeOfNextVarHit
+% Return the time of the next hit for this block.  Note that the result is
+% absolute time.  Note that this function is only used when you specify a
+% variable discrete-time sample time [-2 0] in the sample time array in
+% mdlInitializeSizes.
+%=============================================================================
+%
+function sys=mdlGetTimeOfNextVarHit(t,x,u)
+
+
+sys = [];
+
+% end mdlGetTimeOfNextVarHit
+
+%
+%=============================================================================
+% mdlTerminate
+% Perform any end of simulation tasks.
+%=============================================================================
+%
+function sys=mdlTerminate(t,x,u)
+
+sys = [];
+
+% end mdlTerminate

matlab/V2/V2_1_inverseZ.m

+% Inverse z-Transformation
+
+N = [8 0]
+D = [1 -3 2]
+
+[fo R] = deconv(N,D)
+pause
+
+pause
+
+R = conv(R,[1 0])
+[f1 R] = deconv(R,D)
+pause
+
+R = conv(R,[1 0])
+[f2 R] = deconv(R,D)
+pause
+

matlab/V2/V2_2_inverseZ.m

+% Inverse z-Transformation - 2
+
+N = [8 2 3 2 1]
+D = [1 0 0 0 0]
+
+[fo R] = deconv(N,D)
+pause
+
+R = conv(R,[1 0])
+[f1 R] = deconv(R,D)
+pause
+
+R = conv(R,[1 0])
+[f2 R] = deconv(R,D)
+pause
+
+R = conv(R,[1 0])
+[f3 R] = deconv(R,D)
+pause
+
+R = conv(R,[1 0])
+[f4 R] = deconv(R,D)
+pause
+
+R = conv(R,[1 0])
+[f5 R] = deconv(R,D)
+pause

matlab/V2/V2_3_longdiv.m

+% Example #6: 
+
+% Step 1: Define variables with following values
+    %num= [8  0];
+    %den =[1 -3 2];
+    %npoint = 20;
+
+%Step 2: Call function longdiv to determine y
+    %y = longdiv(num,den,npoint)
+
+%Step 3: Plot y
+    %plot(y)
+
+function y = longdiv(num,den,npoint)
+[y(1) R] = deconv(num,den);
+
+for i=2:npoint
+    num = conv(R,[1 0]);
+    [f R] = deconv(num,den);
+    y(i) = f(length(f));
+end
+end
\ No newline at end of file

matlab/V2/V2_4_tdomain.m

+Ts = 0.1;
+p = -1;
+npoint = 20;
+
+y1 = longdiv([1 0],[1 -exp(Ts*p)],npoint);
+t =(1:npoint)*Ts-Ts;
+
+yc = impulse(1,[1 1],t);
+plot(t,yc,'r',t,y1,'*')
+
+hold on
+
+yh = longdiv(1-exp(Ts*p),[1 -exp(Ts*p)],npoint);
+plot(t,yh,'+')

matlab/V2/V2_5_BodeZOH.m

+function [G Ph] = BodeZOH(Ts,ommax,dom)
+k=0;
+kmax = round(ommax/dom);
+for k=1:kmax
+    om(k) = k*dom;
+    Renum = 1 -cos(-om(k)*Ts);
+    Imnum = -sin(-om(k)*Ts);
+    Gnum = sqrt(Renum*Renum+Imnum*Imnum);
+    G(k) = Gnum/(om(k)*Ts);
+    Ph(k) = atan2(Imnum,Renum)-pi/2;
+end
+
+subplot(2,1,1), semilogx(om,20*log10(G));
+subplot(2,1,2), semilogx(om,Ph*90/pi);
+
+%Ts = 0.1
+%ommax = 100
+%dom = 0.1
\ No newline at end of file

matlab/V2/V2_6_UTFDiskretizierung.m

+disp('Abtastzeit')
+Ts = 0.1
+
+disp('Kontinuierliche Systeme')
+G = tf(1,[1 1])
+
+disp('Beispiel 1: ZOH')
+Gh = c2d(G,Ts,'zoh')
+
+disp('Beispiel 2: Impulse')     
+Gz = c2d(G,Ts,'impulse')
+
+disp('Bespiel 3: Verfahren G(s)/s')
+Gi = tf([1],[1 0])
+Gs = G*Gi
+Gsz = c2d(Gs,Ts,'impulse')
+Gh = tf([1 -1], [1 0],Ts)
+Gf = Gh*Gsz/Ts;
+minreal(Gf)
+
+
+

matlab/V2/V2_7_multiZ.m

+Ts = 0.1;
+Gz = tf([1 0],[1 -exp(-0.1)],Ts);
+%Impuls: longdiv(num,den,100)
+y1=longdiv(cell2mat(Gz.num),cell2mat(Gz.den),100);
+plot(y1);
+
+hold on;
+
+Uz = tf([1 0],[1 -1],Ts);
+Yz = Gz*Uz;
+y2=longdiv(cell2mat(Yz.num),cell2mat(Yz.den),100);
+plot(y2);
+
+Gz2 = tf([1-exp(-0.1) 0],[1 -1-exp(-0.1) exp(-0.1)],Ts);
+y3=longdiv(cell2mat(Gz2.num),cell2mat(Gz2.den),100);
+plot(y3);
\ No newline at end of file