function gensim(net,st)
%GENSIM Generate a SIMULINK block to simulate a neural network.
%
%  Syntax
%
%    gensim(net,st)
%
%  Description
%
%    GENSIM(NET,ST) takes these inputs,
%      NET - Neural network.
%      ST  - Sample time (default = 1).
%    and creates a SIMULINK system containing a block which
%    simulates neural network NET with a sampling time of ST.
%
%    If NET has no input or layer delays (NET.numInputDelays
%    and NET.numLayerDelays are both 0) then you can use -1 for ST to
%    get a continuously sampling network. 
%
%  Example
%
%    net = newff([0 1],[5 1]);
%    gensim(net)

%  Mark Beale, 11-31-97
%  Copyright 1992-2004 The MathWorks, Inc.
% $Revision: 1.11.4.1 $ $Date: 2004/03/24 20:42:57 $

% Input arguments and defaults
if nargin < 1, error('Not enough input arguments.'), end
if nargin < 2, st = 1; end

% Check ST
if (st <= 0) & (st ~= -1),
  error('Sample time must be -1, or a positive number.')
end
if (st == -1) & (net.numInputDelays | net.numLayerDelays)
  error('Sample time cannot be -1 because the network contains delays.')
end
st = num2str(st);

% Neural Network Toolbox Simulink Block Library
neural

% Untitled System
sysName = get_param(new_system,'name');
open_system(sysName)
y = max(max(net.numInputs,net.numOutputs),1)*20 + 20;

% Sample Inputs
pos = y-net.numInputs*20-20;
for i=1:net.numInputs
  inputName = ['p{' num2str(i) '}'];
  inputNameL = [sysName '/' inputName];
  add_block('built-in/Constant',inputNameL,...
    'value',mat2str(rand(net.inputs{i}.size,1),2),...
  'maskdisplay',['disp(''Input ' num2str(i) ' '')'],...
    'position',[40 pos+i*40 80 pos+i*40+20])
end

% Sample Outputs
pos = y-net.numOutputs*20-20;
for i=1:net.numOutputs
  outputName = ['y{' num2str(i) '}'];
  outputNameL = [sysName '/' outputName];
  add_block('built-in/Scope',outputNameL,...
    'position',[300 pos+i*40 320 pos+i*40+20])
end

% Network Block
netName = 'Neural Network';
genNetwork(net,y,netName,sysName,st)

% Connections
for i=1:net.numInputs
  add_line(sysName,[['p{' num2str(i) '}'] '/1'],[netName '/' num2str(i)])
end
for i=1:net.numOutputs
  add_line(sysName,[netName '/' num2str(i)],[['y{' num2str(i) '}'] '/1'])
end

%======================================================================
function genNetwork(net,y,netName,sysName,st)

% Network System
netNameL = [sysName '/' netName];

add_block('built-in/SubSystem',netNameL);
set_param(netNameL, ...
  'position',[160 y-10 220 y+max([net.numInputs,net.numOutputs,1])*40-10],...
  'BackgroundColor','lightblue')
  
% Layer2Layer
Layer2LayerInd = find(sum(net.layerConnect,1));
numLayer2Layers = length(Layer2LayerInd);

% Network Block Names
inputNames = cell(1,net.numInputs);
outputNames = cell(1,net.numOutputs);
fromNames = cell(1,net.numLayers);
toNames = cell(1,net.numLayers);
layerNames = cell(1,net.numLayers);
for i=1:net.numInputs, inputNames{i} = sprintf('p{%g}',i); end
for i=1:net.numOutputs, outputNames{i} = sprintf('y{%g}',i); end
for i=1:net.numLayers, fromNames{i} = sprintf(' a{%g} ',i); end
for i=1:net.numLayers, toNames{i} = sprintf('a{%g}',i); end
for i=1:net.numLayers, layerNames{i} = sprintf('Layer %g',i); end

% Network Blocks
for i=1:net.numInputs
  genNetworkInput(net,i,i,inputNames{i},netNameL,st);
end
for i=1:net.numOutputs
  genNetworkOutput(net,i,i+1+numLayer2Layers,outputNames{i},netNameL);
end
for k=1:numLayer2Layers
  i = Layer2LayerInd(k);
  genNetworkFrom(net,i,k+net.numInputs+1,fromNames{i},netNameL);
end
for k=1:numLayer2Layers
  i = Layer2LayerInd(k);
  genNetworkTo(net,i,k,toNames{i},netNameL);
end
layerPos = 40;
for i=1:net.numLayers
  layerPos = genNetworkLayer(net,i,layerNames{i},netNameL,inputNames,toNames,fromNames,layerPos,st);
end

% Network Block Connections
for i=1:net.numLayers
  inputInd = find(net.inputConnect(i,:));
  numInputs = length(inputInd);
  for j=1:numInputs
    add_line(netNameL,[inputNames{inputInd(j)} '/1'],[layerNames{i} '/' num2str(j)])
  end
end
for k=1:numLayer2Layers
  j = Layer2LayerInd(k);
  add_line(netNameL,[layerNames{j} '/1'],[toNames{j} '/1'])
  layerInd = find(net.layerConnect(:,j)');
  numLayers = length(layerInd);
  for m=1:numLayers
    i = layerInd(m);
    numInputs = length(find(net.inputConnect(i,:)));
  x = sum(net.layerConnect(i,1:j));
    add_line(netNameL,[fromNames{j} '/1'],[layerNames{i} '/' num2str(numInputs+x)])
  end
end
outputInd = find(net.outputConnect);
numOutputs = length(outputInd);
for i=1:numOutputs
  add_line(netNameL,[layerNames{outputInd(i)} '/1'],[outputNames{i} '/1'])
end

%======================================================================
function genNetworkInput(net,i,pos,inputName,netNameL,st)

  y = pos*40;
  inputNameL = [netNameL '/' inputName];
  add_block('built-in/Inport',inputNameL,...
    'port',sprintf('%g',i), ...
  'position',[40 y 60 y+20],...
  'portwidth',num2str(net.inputs{i}.size),...
  'sampletime',st,...
  'BackgroundColor','Magenta')

%======================================================================
function genNetworkOutput(net,i,pos,outputName,netNameL)

  outputInd = find(net.outputConnect);
  siz = net.outputs{outputInd(i)}.size;

  y = pos*40;
  outputNameL = [netNameL '/' outputName];
  add_block('built-in/Outport',outputNameL,...
    'port',sprintf('%g',i), ...
  'position',[380 y 400 y+20],...
  'BackgroundColor','Magenta',...
  'InitialOutput',mat2str(zeros(siz,1)))

%======================================================================
function genNetworkFrom(net,i,pos,fromName,netNameL)

  y = pos*40;
  fromNameL = [netNameL '/' fromName];
  add_block('built-in/From',fromNameL,...
    'gototag',sprintf('feedback%g',i), ...
  'position',[40 y 60 y+20],...
  'maskdisplay','plot(cos(0:.1:2*pi),sin(0:.1:2*pi))',...
  'MaskIconFrame','off',...
  'ForegroundColor','black')

%======================================================================
function genNetworkTo(net,i,pos,toName,netNameL)

  y = pos*40;
  toNameL = [netNameL '/' toName];
  add_block('built-in/Goto',toNameL,...
    'gototag',sprintf('feedback%g',i), ...
  'position',[380 y 400 y+20],...
  'maskdisplay','plot(cos(0:.1:2*pi),sin(0:.1:2*pi))',...
  'MaskIconFrame','off',...
  'ForegroundColor','black')

%======================================================================
function layerPos = genNetworkLayer(net,i,layerName,netNameL,inputName,toName,fromName,layerPos,st)

  % Useful constants
  inputInd = find(net.inputConnect(i,:));
  numInputs = length(inputInd);
  layerInd = find(net.layerConnect(i,:));
  numLayers = length(layerInd);
  hasBias = net.biasConnect(i);
  y = (numInputs+numLayers+hasBias)/2 * 40 + 30;
  dy = max(10,(numInputs+numLayers+hasBias)*5);

  % Layer System
  layerNameL = [netNameL '/' layerName];
  layerHeight = max(1,numInputs+numLayers)*20;
  add_block('built-in/SubSystem',layerNameL)
  set_param(layerNameL,...
  'position',[190 layerPos 250 layerPos+layerHeight],...
  'BackgroundColor','lightblue')
  
  % increase LayerPos
  layerPos = layerPos + layerHeight + 20;

  % Layer Block Names
  outputName = sprintf('a{%g}',i);
  transferName = net.layers{i}.transferFcn;
  netInputName = net.layers{i}.netInputFcn;
  for k=1:numInputs
    j = inputInd(k);
    IWName{k} = sprintf('IW{%g,%g}',i,j);
  IDName{k} = sprintf('Delays %g',k);
  PName{k} = inputName{j};
  end
  for k=1:numLayers
    j = layerInd(k);
    LWName{k} = sprintf('LW{%g,%g}',i,j);
  LDName{k} = sprintf('Delays %g',k+numInputs);
  AName{k} = sprintf('a{%g} ',j);
  end
  if hasBias
    bName = sprintf('b{%g}',i);
  end
    
  % Layer Blocks
  genLayerOutput(net,i,y,layerNameL,outputName);
  genLayerTransfer(y,layerNameL,transferName);
  numSignals = numInputs+numLayers+hasBias;
  genLayerNet(numSignals,y,dy,layerNameL,netInputName);
  for k=1:numInputs
    j = inputInd(k);
    genInputSignal(net,i,j,k,layerNameL,PName{k},st);
  genInputDelays(net,i,j,k,layerNameL,IDName{k},st);
    genInputWeight(net,i,j,k,layerNameL,IWName{k},st);
  end
  for k=1:numLayers
    j = layerInd(k);
    genLayerSignal(net,i,j,k+numInputs,layerNameL,AName{k},st);
  genLayerDelays(net,i,j,k+numInputs,layerNameL,LDName{k},st);
    genLayerWeight(net,i,j,k+numInputs,layerNameL,LWName{k},st);
  end
  if hasBias
   genLayerBias(net,i,numInputs+numLayers+1,layerNameL,bName);
  end
  
  % Layer Block Connections
  for j=1:numInputs
    add_line(layerNameL,[PName{j} '/1'],[IDName{j} '/1'])
    add_line(layerNameL,[IDName{j} '/1'],[IWName{j} '/1'])
    add_line(layerNameL,[IWName{j} '/1'],[netInputName '/' num2str(j)])
  end
  for j=1:numLayers
    add_line(layerNameL,[AName{j} '/1'],[LDName{j} '/1'])
    add_line(layerNameL,[LDName{j} '/1'],[LWName{j} '/1'])
    add_line(layerNameL,[LWName{j} '/1'],[netInputName '/' num2str(j+numInputs)])
  end
  if hasBias
    add_line(layerNameL,[bName '/1'],[netInputName '/' num2str(numInputs+numLayers+1)])
  end
  add_line(layerNameL,[netInputName '/1'],[transferName '/1'])
  add_line(layerNameL,[transferName '/1'],[outputName '/1'])

%======================================================================
function genLayerOutput(net,i,y,layerNameL,outputName)

  outputNameL = [layerNameL '/' outputName];
  add_block('built-in/Outport',outputNameL,...
    'port','1',...
    'position',[360 y-10 380 y+10],...
  'BackgroundColor','Magenta',...
  'InitialOutput',mat2str(zeros(net.layers{i}.size,1)))

%======================================================================
function genLayerTransfer(y,layerNameL,transferName)

  transferNameL = [layerNameL '/' transferName];
  transferBlock = ['neural/Transfer Functions/' transferName];
  add_block(transferBlock,transferNameL,...
    'position',[300 y-10 320 y+10],...
  'BackgroundColor','lightblue')

%======================================================================
function genLayerNet(numSignals,y,dy,layerNameL,netInputName)

  netInputNameL = [layerNameL '/' netInputName];
  if (numSignals > 1)
    netInputBlock = ['neural/Net Input Functions/' netInputName];