Equation engine

all.m

%% Signal synthesizer functions
function s = construct_with_n_N()
    n = get_n();
    N = get_N();
    phi = data.phi;
    
    k = 0:n-1;
    k = k/n;
    phi = phi*pi/180;
    s = trigfun(2*pi*N*k + phi);
end

function s = construct_with_L_N_fs()
    L = get_L();
    N = get_N();
    fs = get_fs();
    phi = data.phi;
    
    k = 0:1/fs:L-1/fs;
    k=k/L;
    phi = phi*pi/180;
    s = trigfun(2*pi*N*k + phi);
end

function s = construct_with_f_N_fs()
    f = get_f();
    N = get_N();
    fs = get_fs();
    phi = data.phi;
    
    k = 0:1/fs:(N/f)-1/fs;
    phi = phi*pi/180;
    s = trigfun(2*pi*f*k + phi);
end

function s = construct_with_n_f_fs()
    n = get_n();
    f = get_f();
    fs = get_fs();
    phi = data.phi;
    
    k = 0:n-1;
    k = k*(1/fs);
    phi = phi*pi/180;
    s = trigfun(2*pi*f*k + phi);
end

function s = construct_with_L_f_fs()
    L = get_L();
    f = get_f();
    fs = get_fs();
    phi = data.phi;
    
    n = 0:1/fs:L-1/fs;
    phi = phi*pi/180;
    s = trigfun(2*pi*f*n + phi);
end


%% Parameter construction
function f = get_f()
    if flags.f
        f = data.f;
    elseif flags.T
        f = 1 / data.T;
    elseif flags.N && flags.L
        f = data.N / data.L;
    elseif flags.n && flags.dt && flags.L && flags.T
        f = data.n * data.dt / data.L / data.T;
    elseif flags.n && flags.fs && flags.L && flags.T
        f = data.n / data.fs / data.L / data.T;
    else
        throw('.');
    end
end

function T = get_T()
    if flags.T
        T = data.T;
    elseif flags.f
        T = 1 / data.f;
    elseif flags.L && flags.N
        T = data.L / data.N;
    elseif flags.L && flags.n && flags.dt && flags.f
        T = data.L / data.n / data.dt / data.f;
    elseif falgs.L && flags.n && flags.fs && flags.f
        T = data.L * data.fs / data.n / data.f;
    else
        throw('.');
    end
end

function n = get_n()
    if flags.n
        n = data.n;
    elseif flags.L && flags.fs
        n = data.L * data.fs;
    elseif flags.L && flags.dt
        n = data.L / data.dt;
    elseif flags.N && flags.T && flags.dt
        n = data.N * data.T / data.dt;
    elseif flags.N && flags.T && flags.fs
        n = data.N * data.T * data.fs;
    else
        throw('.')
    end
end

function N = get_N()
    if flags.N
        N = data.N;
    elseif flags.L && flags.T
        N = data.L / data.T;
    elseif flags.L && flags.f
        N = data.L * data.f;
    elseif flags.n && flags.dt && flags.T
        N = data.n * data.dt / data.T;
    elseif flags.n && flags.dt && flags.f
        N = data.n * data.dt * data.f;
    elseif flags.n && flags.fs && flags.T
        N = data.n / data.fs / data.T;
    elseif flags.n && flags.f && flags.fs
        N = data.n * data.f / data.fs;
    else
        throw('.')
    end
end

function fs = get_fs()
    if flags.fs
        fs = data.fs;
    elseif flags.dt
        fs = 1 / data.dt;
    elseif flags.n && flags.L
        fs = data.n / data.L;
    elseif flags.n && flags.N && flags.T
        fs = data.n / data.N / data.T;
    elseif flags.n && flags.L && flags.f && flags.T
        fs = data.n / data.L / data.f / data.T;
    else
        throw('.');
    end
end

function dt = get_dt()
    if flags.dt
        dt = data.dt;
    elseif flags.fs
        dt = 1 / data.fs;
    elseif flags.L && flags.n
        dt = data.L / data.n;
    elseif flags.N && flags.T && flags.n
        dt = data.N * data.T / data.n;
    elseif flags.L && flags.f && flags.T && flags.n
        dt = data.L * data.f * data.T / data.n;
    else
        throw('.');
    end
end

function L = get_L()
    if flags.L
        L = data.L;
    elseif flags.N && flags.T
        L = data.N * data.T;
    elseif flags.n && flags.dt
        L = data.n * data.dt;
    elseif flags.N && flags.f
        L = data.N / data.f;
    elseif flags.n && flags.fs
        L = data.n / data.fs;
    else
        throw('.');
    end
end

%% Mode Selection
try
    s = construct_with_n_N();
catch
   try
       s = construct_with_L_N_fs();
   catch
      try 
          s = construct_with_f_N_fs();
      catch 
          try
              s = construct_with_n_f_fs();
          catch
              try
                  s = construct_with_L_f_fs();
              catch
                  throw_exception('parameterError','With the given parameters there is no way to construct a sinusoid signal!'); 
              end
          end
          
      end
   end
end

equation_selection.m

%% Mode Selection
try
    s = construct_with_n_N();
catch
   try
       s = construct_with_L_N_fs();
   catch
      try 
          s = construct_with_f_N_fs();
      catch 
          try
              s = construct_with_n_f_fs();
          catch
              try
                  s = construct_with_L_f_fs();
              catch
                  throw_exception('parameterError','With the given parameters there is no way to construct a sinusoid signal!'); 
              end
          end
          
      end
   end
end

generator_functions.m

%% Signal synthesizer functions
function s = construct_with_n_N()
    n = get_n();
    N = get_N();
    phi = data.phi;
    
    k = 0:n-1;
    k = k/n;
    phi = phi*pi/180;
    s = trigfun(2*pi*N*k + phi);
end

function s = construct_with_L_N_fs()
    L = get_L();
    N = get_N();
    fs = get_fs();
    phi = data.phi;
    
    k = 0:1/fs:L-1/fs;
    k=k/L;
    phi = phi*pi/180;
    s = trigfun(2*pi*N*k + phi);
end

function s = construct_with_f_N_fs()
    f = get_f();
    N = get_N();
    fs = get_fs();
    phi = data.phi;
    
    k = 0:1/fs:(N/f)-1/fs;
    phi = phi*pi/180;
    s = trigfun(2*pi*f*k + phi);
end

function s = construct_with_n_f_fs()
    n = get_n();
    f = get_f();
    fs = get_fs();
    phi = data.phi;
    
    k = 0:n-1;
    k = k*(1/fs);
    phi = phi*pi/180;
    s = trigfun(2*pi*f*k + phi);
end

function s = construct_with_L_f_fs()
    L = get_L();
    f = get_f();
    fs = get_fs();
    phi = data.phi;
    
    n = 0:1/fs:L-1/fs;
    phi = phi*pi/180;
    s = trigfun(2*pi*f*n + phi);
end

input_parsing.m

[data, flags] = simple_input_parser(data, raw_varargin, validators);

parameter_calculators.m

%% Parameter construction
function f = get_f()
    if flags.f
        f = data.f;
    elseif flags.T
        f = 1 / data.T;
    elseif flags.N && flags.L
        f = data.N / data.L;
    elseif flags.n && flags.dt && flags.L && flags.T
        f = data.n * data.dt / data.L / data.T;
    elseif flags.n && flags.fs && flags.L && flags.T
        f = data.n / data.fs / data.L / data.T;
    else
        throw('.');
    end
end

function T = get_T()
    if flags.T
        T = data.T;
    elseif flags.f
        T = 1 / data.f;
    elseif flags.L && flags.N
        T = data.L / data.N;
    elseif flags.L && flags.n && flags.dt && flags.f
        T = data.L / data.n / data.dt / data.f;
    elseif falgs.L && flags.n && flags.fs && flags.f
        T = data.L * data.fs / data.n / data.f;
    else
        throw('.');
    end
end

function n = get_n()
    if flags.n
        n = data.n;
    elseif flags.L && flags.fs
        n = data.L * data.fs;
    elseif flags.L && flags.dt
        n = data.L / data.dt;
    elseif flags.N && flags.T && flags.dt
        n = data.N * data.T / data.dt;
    elseif flags.N && flags.T && flags.fs
        n = data.N * data.T * data.fs;
    else
        throw('.')
    end
end

function N = get_N()
    if flags.N
        N = data.N;
    elseif flags.L && flags.T
        N = data.L / data.T;
    elseif flags.L && flags.f
        N = data.L * data.f;
    elseif flags.n && flags.dt && flags.T
        N = data.n * data.dt / data.T;
    elseif flags.n && flags.dt && flags.f
        N = data.n * data.dt * data.f;
    elseif flags.n && flags.fs && flags.T
        N = data.n / data.fs / data.T;
    elseif flags.n && flags.f && flags.fs
        N = data.n * data.f / data.fs;
    else
        throw('.')
    end
end

function fs = get_fs()
    if flags.fs
        fs = data.fs;
    elseif flags.dt
        fs = 1 / data.dt;
    elseif flags.n && flags.L
        fs = data.n / data.L;
    elseif flags.n && flags.N && flags.T
        fs = data.n / data.N / data.T;
    elseif flags.n && flags.L && flags.f && flags.T
        fs = data.n / data.L / data.f / data.T;
    else
        throw('.');
    end
end

function dt = get_dt()
    if flags.dt
        dt = data.dt;
    elseif flags.fs
        dt = 1 / data.fs;
    elseif flags.L && flags.n
        dt = data.L / data.n;
    elseif flags.N && flags.T && flags.n
        dt = data.N * data.T / data.n;
    elseif flags.L && flags.f && flags.T && flags.n
        dt = data.L * data.f * data.T / data.n;
    else
        throw('.');
    end
end

function L = get_L()
    if flags.L
        L = data.L;
    elseif flags.N && flags.T
        L = data.N * data.T;
    elseif flags.n && flags.dt
        L = data.n * data.dt;
    elseif flags.N && flags.f
        L = data.N / data.f;
    elseif flags.n && flags.fs
        L = data.n / data.fs;
    else
        throw('.');
    end
end