PSAK, lab1, model execution | C# Online Compiler

PSAK, lab1, model execution by Anonymous

using System;
using System.Collections.Generic;
using System.Text;

public static class Initialization
{

/*****************************************/

	public const string RG1Name = "RG1";
	public const string RG2Name = "RG2";
	public const string Sum1Name = "Sum1";
	public const string SumResName = "Sum res";
	public const string Sum2Name = "Sum2";
	public const string Sum3Name = "Sum3";
	
	public const string yName = "y";
	public const string xName = "x";
	
	public const int xMax = 50;

/*****************************************/

}


public static class Constants
{
	public const string RG1Name = Initialization.RG1Name;
	
	public const string RG2Name = Initialization.RG2Name;
	
	public const string Sum1Name = Initialization.Sum1Name;
	
	public const string SumResName = Initialization.SumResName;
	
	public const string Sum2Name = Initialization.Sum2Name;
	
	public const string Sum3Name = Initialization.Sum3Name;
	
	public const string yName = Initialization.yName;
	
	public const string xName = Initialization.xName;
	
	public const int xMax = Initialization.xMax;

}

public interface IEvent
{
	MutableMemoryElement getMemoryElement();
	
	bool isOverflow();
	
	int getPrevNumber();
	
	int getNumberToAdd();
	
	int getNewNumber();
}

public class MemoryElementWithStepActivation
	:	IEvent
{
	public MemoryElementWithStepActivation(
			MemoryElementWithStep _memoryElementWithStep
		,	int _prevNumber
		,	int _step
		,	int _newNumber
		,	bool _overflow
	)
	{
		m_memoryElementWithStep = _memoryElementWithStep;
		m_prevNumber = _prevNumber;
		m_step = _step;
		m_newNumber = _newNumber;
		m_overflow = _overflow;
	}
	
	public MutableMemoryElement getMemoryElement()
	{
		return m_memoryElementWithStep;
	}
	
	public bool isOverflow()
	{
		return m_overflow;
	}
	
	public int getPrevNumber()
	{
		return m_prevNumber;
	}
	
	public int getNumberToAdd()
	{
		return m_step;
	}
	
	public int getNewNumber()
	{
		return m_newNumber;
	}
	
	public MemoryElementWithStep m_memoryElementWithStep;
	public int m_prevNumber;
	public int m_step;
	public int m_newNumber;
	public bool m_overflow;
}


/*
public class SteppingAdderActivation
	:	IEvent
{
	public SteppingAdderActivation(
			SteppingAdder _adder
		,	int _prevNumber
		,	int _step
		,	int _newNumber
	)
	{
		m_adder = _adder;
		m_prevNumber = _prevNumber;
		m_step = _step;
		m_newNumber = _newNumber;
	}
	
	public SteppingAdder m_adder;
	public int m_prevNumber;
	public int m_step;
	public int m_newNumber;
}
*/



public class AndGateActivation
	:	IEvent
{
	public AndGateActivation(
			MutableMemoryElement _mutableElement
		,	int _prevNumber
		,	int _numberToAdd
		,	int _newNumber
		,	bool _overflow
	)
	{
		m_mutableElement = _mutableElement;
		m_prevNumber = _prevNumber;
		m_numberToAdd = _numberToAdd;
		m_newNumber = _newNumber;
		m_overflow = _overflow;
	}
	
	public MutableMemoryElement getMemoryElement()
	{
		return m_mutableElement;
	}
	
	public bool isOverflow()
	{
		return m_overflow;
	}
	
	public int getPrevNumber()
	{
		return m_prevNumber;
	}
	
	public int getNumberToAdd()
	{
		return m_numberToAdd;
	}
	
	public int getNewNumber()
	{
		return m_newNumber;
	}

	public MutableMemoryElement m_mutableElement;
	public int m_prevNumber;
	public int m_numberToAdd;
	public int m_newNumber;
	public bool m_overflow;
}

public class Logger
{
	public Logger()
	{
		m_events = new List< IEvent >();
	}
	
	public void addEvent( IEvent _event )
	{
		m_events.Add( _event );
	}
	
	public void print()
	{
		foreach ( IEvent currentEvent in m_events )
		{
			MemoryElementWithStepActivation memoryElementWithStepActivation =
				currentEvent as MemoryElementWithStepActivation;
			
			AndGateActivation andGateActivation =
				currentEvent as AndGateActivation;

			if ( (object)memoryElementWithStepActivation != null )
			{
				print( memoryElementWithStepActivation );
			}
			else if ( (object)andGateActivation != null )
			{
				print( andGateActivation );
			}
		}
	}
	
	private void print( MemoryElementWithStepActivation _memoryElementWithStepActivation )
	{
		StringBuilder sb = new StringBuilder();
		
		bool overflow = _memoryElementWithStepActivation.m_overflow;
		
		sb.AppendFormat(
				"{0} : {1} + {2} = {3}"
			,	_memoryElementWithStepActivation.m_memoryElementWithStep.getName()
			,	_memoryElementWithStepActivation.m_prevNumber
			,	_memoryElementWithStepActivation.m_step
			,	_memoryElementWithStepActivation.m_newNumber
			,	_memoryElementWithStepActivation.m_overflow
		);
		
		if ( overflow )
			sb.Append( " - overflow" );
		
		Console.WriteLine( sb.ToString() );
	}
	
	private void print( AndGateActivation _andGateActivation )
	{
		StringBuilder sb = new StringBuilder();
		
		bool overflow = _andGateActivation.m_overflow;
		
		sb.AppendFormat(
				"{0} : {1} + {2} = {3}"
			,	_andGateActivation.m_mutableElement.getName()
			,	_andGateActivation.m_prevNumber
			,	_andGateActivation.m_numberToAdd
			,	_andGateActivation.m_newNumber
		);
		
		if ( overflow )
			sb.Append( " - overflow" );
		
		Console.WriteLine( sb.ToString() );
	}
	
	public List< IEvent > getEvents()
	{
		return m_events;
	}
	
	private List< IEvent > m_events;
}

public class Environment
{
	public Environment()
	{
		m_logger = new Logger();
	}
	
	public Logger getLogger()
	{
		return m_logger;
	}
	
	private Logger m_logger;
}

public interface IElement
{
	string getName();
}

public interface IActiveElement
{
	void tryActivate( Environment _environment );
}

public interface ISignalGenerator
{
	void addDrivenElement( IActiveElement _element );
	
	bool hasImpetus();
	
	void resetImpetus();
	
	void tryActivateDrivenElements( Environment _environment );
	
	void nextTurn();
	
	IEnumerable< IActiveElement > getDrivenElementsIterable();
}


public abstract class ElementBase
	:	IElement
{
	public ElementBase( string _name )
	{
		m_name = _name;
	}
	
	public string getName()
	{
		return m_name;
	}
	
	private string m_name;
}


public class XGenerator
	:	ElementBase
	,	ISignalGenerator
{
	public XGenerator( string _name )
		:	base( _name )
	{
		m_impetus = false;
		m_drivenElements = new List< IActiveElement >();
	}
	
	public bool hasImpetus()
	{
		return m_impetus;
	}
	
	public void resetImpetus()
	{
		m_impetus = false;
	}
	
	public void tryActivateDrivenElements( Environment _environment )
	{
		foreach ( IActiveElement element in m_drivenElements )
		{
			element.tryActivate( _environment );
		}
	}
	
	public IEnumerable< IActiveElement > getDrivenElementsIterable()
	{
		foreach( IActiveElement element in m_drivenElements )
		{
			yield return element;
		}
	}
	
	public void nextTurn()
	{
		m_impetus = true;
	}
	
	public void addDrivenElement( IActiveElement _element )
	{
		m_drivenElements.Add( _element );
	}
	
	private bool m_impetus;
	
	private List< IActiveElement > m_drivenElements;
}



public class MemoryElement
	:	ElementBase
{
	public MemoryElement(
			string _name
		,	int _data
	)
		:	base( _name )
	{
		m_data = _data;
	}

	public int getNumber()
	{
		return m_data;
	}
	
	public virtual bool doesOverflow()
	{
		return false;
	}
	
	protected void setNumber( int _newData )
	{
		m_data = _newData;
	}
	/*
	protected void addNumber( int _n )
	{
		m_data += _n;
	}
	*/
	
	private int m_data;
}


public class Register
	:	MemoryElement
{
	public Register(
			string _name
		,	int _data
	)
		:	base( _name, _data )
	{
	}
}

public class MutableMemoryElement
	:	MemoryElement
{
	public MutableMemoryElement(
			string _name
		,	int _data
	)
		:	base( _name, _data )
	{
		//m_data = _data;
	}
	
	public virtual void addNumber( int _n )
	{
		setNumber( getNumber() + _n );
	}
}




public class MemoryElementWithStep
	:	MutableMemoryElement
	,	IActiveElement
{
	public MemoryElementWithStep(
			string _name
		,	int _data
		,	int _step
	)
		:	base( _name, _data )
	{
		m_step = _step;
	}
	
	public void tryActivate( Environment _environment )
	{
	/*
		if ( !m_impetusProvider.hasImpetus() )
			return;
	*/
		Logger logger = _environment.getLogger();
		
		int prevNumber = getNumber();
		int step = m_step;
		
		addNumber( m_step );
		
		int newNumber = getNumber();
		
		MemoryElementWithStepActivation activationEvent = new MemoryElementWithStepActivation(
				this
			,	prevNumber
			,	step
			,	newNumber
			,	doesOverflow()
		);
		
		logger.addEvent(  activationEvent );
	}
	
	private int m_step;
}


public class MemoryElementWithOverflow
	:	MemoryElementWithStep
	,	ISignalGenerator
{
	public MemoryElementWithOverflow(
			string _name
		,	int _data
		,	int _step
	)
		:	base( _name, _data, _step )
	{
		m_drivenElements = new List< IActiveElement >();
	}
	
	public void addDrivenElement( IActiveElement _element )
	{
		m_drivenElements.Add( _element );
	}
	
	public void tryActivateDrivenElements( Environment _environment )
	{
		foreach ( IActiveElement element in m_drivenElements )
		{
			element.tryActivate( _environment );
		}
	}
	
	public IEnumerable< IActiveElement > getDrivenElementsIterable()
	{
		foreach( IActiveElement element in m_drivenElements )
		{
			yield return element;
		}
	}
	
	public bool hasImpetus()
	{
		return m_impetus;
	}
	
	public void resetImpetus()
	{
		m_impetus = false;
	}
	
	public void nextTurn()
	{
		//
	}
	
	public override bool doesOverflow()
	{
		return getNumber() >= 0;
	}
	
	public override void addNumber( int _n )
	{
		base.addNumber( _n );
		if ( doesOverflow() )
			m_impetus = true;
	}
	
	private bool m_impetus;
	
	private List< IActiveElement > m_drivenElements;
}


public class AndGate
	:	ElementBase
	,	IActiveElement
{
	public AndGate(
			string _name
		,	MemoryElement _fromElement
		,	MutableMemoryElement _toElement
	//	,	IElement _impetusProvider
		,	bool _inverting = false
		,	int _modifierPow = 0
	)
		:	base( _name )
	{
		m_fromElement = _fromElement;
		m_toElement = _toElement;
	//	m_impetusProvider = _impetusProvider;
		m_inverting = _inverting;
		m_modifierPow = _modifierPow;
	}
	
	public void tryActivate( Environment _environment )
	{
		//if ( !m_impetusProvider.hasImpetus() )
		//	return;
	
		Logger logger = _environment.getLogger();
		
		int numberToAdd = m_fromElement.getNumber();
		if ( m_inverting )
			numberToAdd *= -1;
			
		int modifier = ( int ) ( Math.Pow( 2.0, m_modifierPow ) + 0.1 );
			
		numberToAdd *= modifier;
		
		int prevNumber = m_toElement.getNumber();
		
		m_toElement.addNumber( numberToAdd );
		
		int newNumber = m_toElement.getNumber();
		
		AndGateActivation andGateActivation = new AndGateActivation(
				m_toElement
			,	prevNumber
			,	numberToAdd
			,	newNumber
			,	m_toElement.doesOverflow()
		);
		
		logger.addEvent( andGateActivation );
	}
	
	private MemoryElement m_fromElement;
	
	private MutableMemoryElement m_toElement;
	
	//private IElement m_impetusProvider;
	
	private bool m_inverting;
	
	private int m_modifierPow;
}


/*
public interface IElement
{
	string getName();
	
	int getNumber();
	
	void addNumber( int _n );
	
	bool hasImpetus();
	
	void resetImpetus();
	
	void tryActivate( Environment _environment );
	
	void nextTurn();
}
*/
/*

public abstract class ElementBase
	:	IElement
{
	public ElementBase( string _name )
	{
		m_name = _name;
	}
	
	public string getName()
	{
		return m_name;
	}
	
	public abstract int getNumber();
	
	public abstract void addNumber( int _n );
	
	public abstract bool hasImpetus();
	
	public abstract void resetImpetus();
	
	public abstract void tryActivate( Environment _environment );
	
	public virtual void nextTurn()
	{
	}
	
	private string m_name;
}
*/

/*
public class XGenerator
	:	ElementBase
{
	public XGenerator( string _name )
		:	base( _name )
	{
		m_impetus = false;
		m_drivenElements = new List< IElement >();
	}

	public override int getNumber()
	{
		return 0;
	}
	
	public override void addNumber( int _n )
	{
		throw new Exception();
	}
	
	public override bool hasImpetus()
	{
		return m_impetus;
	}
	
	public override void resetImpetus()
	{
		m_impetus = false;
	}
	
	public override void tryActivate( Environment _environment )
	{
		foreach ( IElement element in m_drivenElements )
		{
			element.tryActivate( _environment );
		}
	}
	
	public override void nextTurn()
	{
		m_impetus = true;
	}
	
	public void addDrivenElement( IElement _element )
	{
		m_drivenElements.Add( _element );
	}
	
	private bool m_impetus;
	
	private List< IElement > m_drivenElements;
}
*/

public class Adder
	:	MutableMemoryElement
{
	public Adder( string _name, int _data )
		:	base( _name, _data )
	{
	}
}

public class Counter
	:	MutableMemoryElement
{
	public Counter( string _name, int _data )
		:	base( _name, _data )
	{
	}
}


public class AdderWithStep
	:	MemoryElementWithStep
{
	public AdderWithStep( string _name, int _data, int _step )
		:	base( _name, _data, _step )
	{
	}
}

public class CounterWithStep
	:	MemoryElementWithStep
{
	public CounterWithStep( string _name, int _data, int _step )
		:	base( _name, _data, _step )
	{
	}
}


public class AdderWithOverflow
	:	MemoryElementWithOverflow
{
	public AdderWithOverflow( string _name, int _data, int _step )
		:	base( _name, _data, _step )
	{
	}
}

public class CounterWithOverflow
	:	MemoryElementWithOverflow
{
	public CounterWithOverflow( string _name, int _data, int _step )
		:	base( _name, _data, _step )
	{
	}
}


/*
public class Adder
	:	ElementBase
{
	public Adder(
			string _name
		,	int _data
	)
		:	base( _name )
	{
		m_data = _data;
	}

	public override int getNumber()
	{
		return m_data;
	}
	
	public override void addNumber( int _n )
	{
		m_data += _n;
	}
	
	public override bool hasImpetus()
	{
		return false;
	}
	
	public override void resetImpetus()
	{
		throw new Exception();
	}
	
	public override void tryActivate( Environment _environment )
	{
		//throw new Exception();
	}
	
	public override void nextTurn()
	{
	}
	
	public virtual bool doesOverflow()
	{
		return false;
	}
	
	private int m_data;
}
*/




/*
public class AdderWithOverflow
	:	Adder
{
	public AdderWithOverflow(
			string _name
		,	int _data
	)
		:	base( _name, _data )
	{
		m_overflow = false;
		m_drivenElements = new List< IElement >();
	}
	
	public override void addNumber( int _n )
	{
		base.addNumber( _n );
		if ( doesOverflow() )
			m_overflow = true;
	}
	
	public override bool hasImpetus()
	{
		return m_overflow;
	}
	
	public override void resetImpetus()
	{
		m_overflow = false;
	}
	
	public override void nextTurn()
	{
		m_overflow = false;
	}
	
	public override bool doesOverflow()
	{
		if ( getNumber() >= 0 )
			return true;
		else
			return false;
	}
	
	public override void tryActivate( Environment _environment )
	{
		foreach ( IElement element in m_drivenElements )
		{
			element.tryActivate( _environment );
		}
		//throw new Exception();
	}
	
	public void addDrivenElement( IElement _element )
	{
		m_drivenElements.Add( _element );
	}
	
	private bool m_overflow;
	
	private List< IElement > m_drivenElements;
}
*/

/*
public class SteppingAdder
	:	Adder
{
	public SteppingAdder(
			string _name
		,	int _data
		,	int _step
		//,	IElement _impetusProvider
	)
		:	base( _name, _data )
	{
		m_step = _step;
		//m_impetusProvider = _impetusProvider;
	}

	public override void tryActivate( Environment _environment )
	{
	/*
		if ( !m_impetusProvider.hasImpetus() )
			return;
	*/

/*
		Logger logger = _environment.getLogger();
		
		int prevNumber = getNumber();
		int step = m_step;
	
		addNumber( m_step );
		
		int newNumber = getNumber();
		
		SteppingAdderActivation steppingAdderActivation = new SteppingAdderActivation(
				this
			,	prevNumber
			,	step
			,	newNumber
		);
		
		logger.addEvent(  steppingAdderActivation );
	}
	
	
	private int m_step;
	
	//private IElement m_impetusProvider;
}
*/
/*
public class AndGate
	:	ElementBase
{
	public AndGate(
			string _name
		,	IElement _fromElement
		,	Adder _toElement
	//	,	IElement _impetusProvider
		,	bool _inverting = false
		,	int _modifier = 1
	)
		:	base( _name )
	{
		m_fromElement = _fromElement;
		m_toElement = _toElement;
	//	m_impetusProvider = _impetusProvider;
		m_inverting = _inverting;
		m_modifier = _modifier;
	}

	public override int getNumber()
	{
		return 0;
	}
	
	public override void addNumber( int _n )
	{
		throw new Exception();
	}
	
	public override bool hasImpetus()
	{
		throw new Exception();
	}
	
	public override void resetImpetus()
	{
		throw new Exception();
	}
	
	public override void tryActivate( Environment _environment )
	{
		//if ( !m_impetusProvider.hasImpetus() )
		//	return;
	
		Logger logger = _environment.getLogger();
		
		int numberToAdd = m_fromElement.getNumber();
		if ( m_inverting )
			numberToAdd *= -1;
			
		numberToAdd *= m_modifier;
		
		int prevNumber = m_toElement.getNumber();
		
		m_toElement.addNumber( numberToAdd );
		
		int newNumber = m_toElement.getNumber();
		
		AndGateActivation andGateActivation = new AndGateActivation(
				m_toElement
			,	prevNumber
			,	numberToAdd
			,	newNumber
			,	m_toElement.doesOverflow()
		);
		
		logger.addEvent( andGateActivation );
	}
	
	private IElement m_fromElement;
	
	private Adder m_toElement;
	
	//private IElement m_impetusProvider;
	
	private bool m_inverting;
	
	private int m_modifier;
}
*/

public class YReceiver
	:	MemoryElementWithStep
{
	public YReceiver( string _name )
		:	base( _name, 0, 1 )
	{
	}
}

/*
public class YReceiver
	:	ElementBase
{
	public YReceiver(
			string _name
	//	,	IElement _impetusProvider
	)
		:	base( _name )
	{
		m_impetusNumber = 0;
	//	m_impetusProvider = _impetusProvider;
	}

	public override int getNumber()
	{
		return m_impetusNumber;
	}
	
	public override void addNumber( int _n )
	{
		throw new Exception();
	}
	
	public override bool hasImpetus()
	{
		throw new Exception();
	}
	
	public override void resetImpetus()
	{
		throw new Exception();
	}
	
	public override void tryActivate( Environment _environment )
	{
		//if ( !m_impetusProvider.hasImpetus() )
		//	return;
	
		++m_impetusNumber;
	}
	
	private int m_impetusNumber;
	
	//private IElement m_impetusProvider;
}
*/


public class Scheme
{
	public Scheme( Environment _environment )
	{
		m_environment = _environment;
		//m_elementsToActivate = new List< IElement >();
		m_signalGenerators = new List< ISignalGenerator >();
		m_elements = new List< IElement >();
		m_elementsToActivateStack = new Stack< IActiveElement >();
	}
	
	public void addElement( IElement _element )
	{
		m_elements.Add( _element );
	}
	
	public void addSignalGenerator( ISignalGenerator _signalGenerator )
	{
		m_signalGenerators.Add( _signalGenerator );
	}
	
	public Environment getEnvironment()
	{
		return m_environment;
	}
	
	public void executeNImpetuses( int _number )
	{
		for ( int i = 0; i < _number; ++i )
		{
			nextTurn();
			execute();
		}
	}
	
	private void execute()
	{
		//int currentIndex = -1;
		
		while ( true )
		{
			int signalGeneratorToExecuteIndex = findSignalGeneratorToExecuteIndex( /*currentIndex*/ );
			if ( signalGeneratorToExecuteIndex != -1 )
			{
				ISignalGenerator signalGenerator = m_signalGenerators[ signalGeneratorToExecuteIndex ];
				List< IActiveElement > temp = new List< IActiveElement >();
				temp.AddRange( signalGenerator.getDrivenElementsIterable() );

				int count = temp.Count;
				for ( int i = count - 1; i >= 0; --i )
				{
					m_elementsToActivateStack.Push( temp[ i ] );
				}

				signalGenerator.resetImpetus();
				//++currentIndex;
			}
			if ( m_elementsToActivateStack.Count == 0 )
				break;
			
			IActiveElement activeElement = m_elementsToActivateStack.Pop();
			activeElement.tryActivate( getEnvironment() );
		}
		
		/*
		while ( true )
		{
			ISignalGenerator signalGenerator = findSignalGeneratorToExecute();
			if ( (object)signalGenerator == null )
				return;
			
			execute( signalGenerator );
		}
		*/
		/*
		foreach ( IElement element in m_elementsToActivate )
		{
			execute( element );
		}
		*/
	}
	
	private ISignalGenerator findSignalGeneratorToExecute()
	{
		int count = m_signalGenerators.Count;
		for ( int i = count - 1; i >= 0; --i )
		{
			ISignalGenerator signalGenerator = m_signalGenerators[ i ];
			if ( signalGenerator.hasImpetus() )
				return signalGenerator;
		}
		return null;
	}
	
	private int findSignalGeneratorToExecuteIndex()
	{
		int count = m_signalGenerators.Count;
		for ( int i = count - 1; i >= 0; --i )
		{
			ISignalGenerator signalGenerator = m_signalGenerators[ i ];
			if ( signalGenerator.hasImpetus() )
				return i;
		}
		return -1;
	}
	
	private void execute( ISignalGenerator _signalGenerator )
	{
		/*
		while ( _element.hasImpetus() )
		{
			_element.resetImpetus();
			_element.tryActivate( getEnvironment() );
		}
		*/
		
		if ( !_signalGenerator.hasImpetus() )
			throw new Exception();
		
		_signalGenerator.resetImpetus();
		_signalGenerator.tryActivateDrivenElements( getEnvironment() );
	}
	
	private void nextTurn()
	{
		foreach ( ISignalGenerator signalGenerator in m_signalGenerators )
		{
			signalGenerator.nextTurn();
		}
	}
	
	private Environment m_environment;
	//private List< IElement > m_elementsToActivate;
	private List< ISignalGenerator > m_signalGenerators;
	private List< IElement > m_elements;
	private Stack< IActiveElement > m_elementsToActivateStack;
}



public class ReportPrinter
{
	public ReportPrinter( int _height, int _length )
	{
		m_length = _length;
		m_height = _height;
		
		m_data = new string[ m_height, m_length ];
		init();
	}
	
	public void normalize()
	{
		for ( int i = 0; i < m_length; ++i )
		{
			int maxColumnElementLength = getMaxElementLength( i );
			normalizeColumn( i, maxColumnElementLength );
		}
	}
	
	public int getMaxElementLength( int _columnIndex )
	{
		int maxLength = 0;
		for ( int i = 0; i < m_height; ++i )
		{
			int elementLength = m_data[ i, _columnIndex ].Length;
			if ( maxLength < elementLength )
				maxLength = elementLength;
		}
		return maxLength;
	}
	
	public void normalizeColumn( int _columnIndex, int _maxColumnElementLength )
	{
		for ( int i = 0; i < m_height; ++i )
		{
			string element = m_data[ i, _columnIndex ];
			int elementLength = element.Length;
			int lengthDifference = _maxColumnElementLength - elementLength;
			if ( lengthDifference == 0 )
				continue;
			
			string spaces =  new String( ' ', lengthDifference );
			StringBuilder sb = new StringBuilder();
			sb.AppendFormat( "{0}{1}", element, spaces );
			m_data[ i, _columnIndex ] = sb.ToString();
		}
	}
	
	public void print()
	{
		normalize();
		for ( int i = 0; i < m_height; ++i )
		{
			Console.Write( "\n" );
			for ( int j = 0; j < m_length; ++j )
			{
				Console.Write( "{0}\t", m_data[ i, j ] );
			}
		}
	}
	
	private void init()
	{
		for ( int i = 0; i < m_height; ++i )
		{
			for ( int j = 0; j < m_length; ++j )
			{
				m_data[ i, j ] = "";
			}
		}
	}
	
	private int m_height;
	private int m_length;
	
	public string[,] m_data;
}


/*
public class Lab2Printer
{
	public Lab2Printer( Logger _logger )
	{
		m_logger = _logger;
		initEventsByMemoryElement();
		initColumnIndexesByMemoryElement();
	}
	
	public void printModelling()
	{
		int length = 7;
		int height = getHeight();
		
		ReportPrinter reportPrinter = new ReportPrinter( height, length );
		
		// header
		reportPrinter.m_data[ 0, 0 ] = "x";
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] = Constants.Sum1Name;
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum2Name ] ] = Constants.Sum2Name;
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum2Name ] + 1 ] = Constants.Sum2Name + " overflow";
		
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.CNTSqrtName ] ] = Constants.CNTSqrtName;
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.CNTSqrtName ] + 1 ] = Constants.CNTSqrtName + " overflow";
		
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.CNTResName ] ] = Constants.CNTResName;
		
		int lineIndex = 0;
		int x = 1;
		
		reportPrinter.m_data[ lineIndex + 1, 0 ] = x.ToString();
		reportPrinter.m_data[ lineIndex + 1, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
			toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
		
		bool cntSqrtOverflow = false;
		
		List< IEvent > events = m_logger.getEvents();
		foreach ( IEvent currentEvent in events )
		{
			string memoryElementName = currentEvent.getMemoryElement().getName();
			
			if
				(
					( memoryElementName != Constants.Sum2Name )
				&&	( memoryElementName != Constants.CNTSqrtName )
				&&	( memoryElementName != Constants.CNTResName )
			)
				continue;

			if ( memoryElementName == Constants.Sum2Name )
			{
				++lineIndex;
				
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
					toText( currentEvent );
				
				if ( currentEvent.isOverflow() )
					reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] + 1 ] = "1";
				else
				{
					++x;
					if ( x - 1 < m_eventsByMemoryElement[ Constants.Sum1Name ].Count )
					{
						reportPrinter.m_data[ lineIndex + 1, 0 ] = x.ToString();
						reportPrinter.m_data[ lineIndex + 1, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
							toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
					}
				}
			}
			else if ( memoryElementName == Constants.CNTSqrtName )
			{
				if ( cntSqrtOverflow )
					++lineIndex;
				
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
					toText( currentEvent );
				
				if ( currentEvent.isOverflow() )
				{
					cntSqrtOverflow = true;
					reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] + 1 ] = "1";
				}
				else
				{
					cntSqrtOverflow = false;
				}
			}
			else if ( memoryElementName == Constants.CNTResName )
			{
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
					toText( currentEvent );
			}
			else
				throw new Exception();
		}
		
		reportPrinter.print();
	}
	
	public void print()
	{
		printModelling();
	}
	
	private int getHeight()
	{
		int height = 1;
		
		height += m_eventsByMemoryElement[ Constants.Sum2Name ].Count;
		
		int cntSqrtOverflow = 0;
		foreach ( IEvent currentEvent in m_eventsByMemoryElement[ Constants.CNTSqrtName ] )
		{
			if ( currentEvent.isOverflow() )
				++cntSqrtOverflow;
		}
		height += cntSqrtOverflow;
		return height;
	}
	
	private void initEventsByMemoryElement()
	{
		m_eventsByMemoryElement = new Dictionary< string, List< IEvent > >();
		
		m_eventsByMemoryElement.Add( Constants.Sum1Name, new List< IEvent >() );
		m_eventsByMemoryElement.Add( Constants.Sum2Name, new List< IEvent >() );
		m_eventsByMemoryElement.Add( Constants.CNTSqrtName, new List< IEvent >() );
		m_eventsByMemoryElement.Add( Constants.CNTResName, new List< IEvent >() );
		m_eventsByMemoryElement.Add( Constants.yName, new List< IEvent >() );
		
		List< IEvent > events = m_logger.getEvents();
		foreach ( IEvent currentEvent in events )
		{
			m_eventsByMemoryElement[ currentEvent.getMemoryElement().getName() ].Add( currentEvent );
		}
	}
	
	public void initColumnIndexesByMemoryElement()
	{
		m_columnIndexByMemoryElement = new Dictionary< string, int >();
		
		m_columnIndexByMemoryElement.Add( Constants.Sum1Name, 3 );
		m_columnIndexByMemoryElement.Add( Constants.Sum2Name, 1 );
		m_columnIndexByMemoryElement.Add( Constants.CNTSqrtName, 4 );
		m_columnIndexByMemoryElement.Add( Constants.CNTResName, 6 );
	}
	
	public string toText( IEvent _event )
	{
		StringBuilder sb = new StringBuilder();
		
		if ( _event.getMemoryElement().getName() == Constants.CNTResName )
		{
			return _event.getNewNumber().ToString();
		}
		
		sb.AppendFormat(
				"{0} + {1} = {2}"
			,	_event.getPrevNumber()
			,	_event.getNumberToAdd()
			,	_event.getNewNumber()
		);
		
		return sb.ToString();
	}
	
	private Logger m_logger;
	
	private Dictionary< string, List< IEvent > > m_eventsByMemoryElement;
	
	private Dictionary< string, int > m_columnIndexByMemoryElement;
}
*/

public class Lab1Printer
{
	public Lab1Printer( Logger _logger )
	{
		m_logger = _logger;
		initEventsByMemoryElement();
		initColumnIndexesByMemoryElement();
	}
	
	public void printModelling()
	{
		int length = 7;
		int height = getHeight();
		
		ReportPrinter reportPrinter = new ReportPrinter( height, length );
		
		// header
		reportPrinter.m_data[ 0, 0 ] = "x";
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.SumResName ] ] = Constants.SumResName;
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.SumResName ] + 1 ] = Constants.SumResName + " overflow";
		
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] = Constants.Sum1Name;
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum2Name ] ] = Constants.Sum2Name;
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum3Name ] ] = Constants.Sum3Name;
		
		reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.yName ] ] = Constants.yName;
		
		int lineIndex = 0;
		int overflowIndex = 0;
		int x = 0;
		
		reportPrinter.m_data[ lineIndex + 1, 0 ] = x.ToString();
		//reportPrinter.m_data[ lineIndex + 1, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
		//	toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
		
		List< IEvent > events = m_logger.getEvents();
		
		bool prevSumResIsOverflow = false;
		
		
		foreach ( IEvent sumResEvent in m_eventsByMemoryElement[ Constants.SumResName ] )
		{
			++lineIndex;
			
			reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.SumResName ] ] =
				toText( sumResEvent );
			
			if ( !prevSumResIsOverflow )
			{
				++x;
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.xName ] ] =
					x.ToString();
				
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
					toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
			}
			
			if ( sumResEvent.isOverflow() )
			{
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.SumResName ] + 1 ] =
					"1";
				
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.Sum2Name ] ] =
					toText( m_eventsByMemoryElement[ Constants.Sum2Name ][ overflowIndex ] );
				
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.Sum3Name ] ] =
					toText( m_eventsByMemoryElement[ Constants.Sum3Name ][ overflowIndex ] );
				
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.yName ] ] =
					toText( m_eventsByMemoryElement[ Constants.yName ][ overflowIndex ] );
				
				++overflowIndex;
				prevSumResIsOverflow = true;
			}
			else
				prevSumResIsOverflow = false;
		}
		
		foreach ( IEvent currentEvent in events )
		{
			/*
			string memoryElementName = currentEvent.getMemoryElement().getName();
			
			if
				(
					( memoryElementName != Constants.Sum2Name )
				&&	( memoryElementName != Constants.CNTSqrtName )
				&&	( memoryElementName != Constants.CNTResName )
			)
				continue;

			if ( memoryElementName == Constants.Sum2Name )
			{
				++lineIndex;
				
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
					toText( currentEvent );
				
				if ( currentEvent.isOverflow() )
					reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] + 1 ] = "1";
				else
				{
					++x;
					if ( x - 1 < m_eventsByMemoryElement[ Constants.Sum1Name ].Count )
					{
						reportPrinter.m_data[ lineIndex + 1, 0 ] = x.ToString();
						reportPrinter.m_data[ lineIndex + 1, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
							toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
					}
				}
			}
			else if ( memoryElementName == Constants.CNTSqrtName )
			{
				if ( cntSqrtOverflow )
					++lineIndex;
				
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
					toText( currentEvent );
				
				if ( currentEvent.isOverflow() )
				{
					cntSqrtOverflow = true;
					reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] + 1 ] = "1";
				}
				else
				{
					cntSqrtOverflow = false;
				}
			}
			else if ( memoryElementName == Constants.CNTResName )
			{
				reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
					toText( currentEvent );
			}
			else
				throw new Exception();
		*/
		}
		reportPrinter.print();
	}
	
	public void print()
	{
		printModelling();
	}
	
	private int getHeight()
	{
		int height = 1;
		
		height += m_eventsByMemoryElement[ Constants.SumResName ].Count;
		
		return height;
	}
	
	private void initEventsByMemoryElement()
	{
		m_eventsByMemoryElement = new Dictionary< string, List< IEvent > >();
		
		m_eventsByMemoryElement.Add( Constants.Sum1Name, new List< IEvent >() );
		m_eventsByMemoryElement.Add( Constants.Sum2Name, new List< IEvent >() );
		m_eventsByMemoryElement.Add( Constants.Sum3Name, new List< IEvent >() );
		m_eventsByMemoryElement.Add( Constants.SumResName, new List< IEvent >() );
		m_eventsByMemoryElement.Add( Constants.yName, new List< IEvent >() );
		
		List< IEvent > events = m_logger.getEvents();
		foreach ( IEvent currentEvent in events )
		{
			m_eventsByMemoryElement[ currentEvent.getMemoryElement().getName() ].Add( currentEvent );
		}
	}
	
	public void initColumnIndexesByMemoryElement()
	{
		m_columnIndexByMemoryElement = new Dictionary< string, int >();
		
		m_columnIndexByMemoryElement.Add( Constants.xName, 0 );
		m_columnIndexByMemoryElement.Add( Constants.SumResName, 1 );
		m_columnIndexByMemoryElement.Add( Constants.Sum1Name, 3 );
		m_columnIndexByMemoryElement.Add( Constants.Sum2Name, 4 );
		m_columnIndexByMemoryElement.Add( Constants.Sum3Name, 5 );
		m_columnIndexByMemoryElement.Add( Constants.yName, 6 );
	}
	
	public string toText( IEvent _event )
	{
		StringBuilder sb = new StringBuilder();
		
		if ( _event.getMemoryElement().getName() == Constants.yName )
		{
			return _event.getNewNumber().ToString();
		}
		
		sb.AppendFormat(
				"{0} + {1} = {2}"
			,	_event.getPrevNumber()
			,	_event.getNumberToAdd()
			,	_event.getNewNumber()
		);
		
		return sb.ToString();
	}
	
	private Logger m_logger;
	
	private Dictionary< string, List< IEvent > > m_eventsByMemoryElement;
	
	private Dictionary< string, int > m_columnIndexByMemoryElement;
}






public class Program
{
	public static void Main()
	{
		XGenerator xGenerator = new XGenerator( Constants.xName );
		
		int init0 = 8;
		int step0 = 16;
		
		int init1 = -1;
		int init2 = 26;
		
		int init3 = 72;
		int step3 = 48;
		
		int xMax = Initialization.xMax;
		/*
		int a = 4;
		int b = 5;
		int c = -15;
		int m = 13;
		*/
		/*
		int init0 = 23;
		int step0 = 16;
		
		int init1 = -17;
		int init2 = 12;
		int init3 = 1;
		
		int init4 = -1;
		
		int init5 = 2;
		int step5 = 2;
		*/
		/*
		int rgInit1 = 2 * a;
		
		int init0 = a + b;
		
		int init1 = 2 * c - m;
		int init2 = m;
		int init3 = 1;
		
		int init4 = -1;
		
		int init5 = 0;
		int step5 = 1;
		*/
		/*
		Console.WriteLine( "{0} = {1}", Constants.Sum1Name, init0 );
		Console.WriteLine( "{0} = {1}", Constants.Sum2Name, init1 );
		
		Console.WriteLine( "{0} = {1}", Constants.RG1Name, rgInit1 );
		Console.WriteLine( "{0} = {1}", Constants.RG2Name, init2 );
		
		Console.WriteLine( "{0} = {1}", Constants.CNTSqrtName, init4 );
		Console.WriteLine( "{0} = {1}", Constants.CNTResName, init5 );
		
		Register rg1 = new Register( Constants.RG1Name, rgInit1 );
		Adder sum1 = new Adder( Constants.Sum1Name, init0 );
		AdderWithOverflow sum2 = new AdderWithOverflow( Constants.Sum2Name, init1, 0 );
		Register rg2 = new Register( Constants.RG2Name, init2 );
		AdderWithOverflow cntSqrt = new AdderWithOverflow( Constants.CNTSqrtName, init4, 1 );
		CounterWithStep cntRes = new CounterWithStep( Constants.CNTResName, init5, step5 );
		
		
		AndGate andBetweenRG1_Sum1 = new AndGate( "&", rg1, sum1 );
		AndGate andBetweenSum1_Sum2 = new AndGate( "&", sum1, sum2, false, 1 );
		AndGate andBetweenRG2_Sum2 = new AndGate( "&", rg2, sum2, true, 1 );
		AndGate andBetweenCntRes_CntSqrt = new AndGate( "&", cntRes, cntSqrt, true, 1 );
		
		YReceiver yReceiver = new YReceiver( Constants.yName );
		
		xGenerator.addDrivenElement( andBetweenSum1_Sum2 );
		xGenerator.addDrivenElement( andBetweenRG1_Sum1 );
		
		sum2.addDrivenElement( cntSqrt );
		sum2.addDrivenElement( andBetweenRG2_Sum2 );
		
		cntSqrt.addDrivenElement( yReceiver );
		cntSqrt.addDrivenElement( cntRes );
		cntSqrt.addDrivenElement( andBetweenCntRes_CntSqrt );
		
		Environment environment = new Environment();
		
		Scheme scheme = new Scheme( environment );
		scheme.addElement( rg1 );
		scheme.addElement( sum1 );
		scheme.addElement( sum2 );
		scheme.addElement( rg2 );
		scheme.addElement( cntSqrt );
		scheme.addElement( cntRes );
		
		scheme.addElement( andBetweenRG1_Sum1 );
		scheme.addElement( andBetweenSum1_Sum2 );
		scheme.addElement( andBetweenRG2_Sum2 );
		scheme.addElement( andBetweenCntRes_CntSqrt );
		
		scheme.addElement( yReceiver );
		
		scheme.addSignalGenerator( xGenerator );
		scheme.addSignalGenerator( sum2 );
		scheme.addSignalGenerator( cntSqrt );
		*/
		
		Register rg1 = new Register( Constants.RG1Name, step0 );
		Adder sum1 = new Adder( Constants.Sum1Name, init0 );
		AdderWithOverflow sumRes = new AdderWithOverflow( Constants.SumResName, init1, 0 );
		Adder sum2 = new Adder( Constants.Sum2Name, init2 );
		Adder sum3 = new Adder( Constants.Sum3Name, init3 );
		Register rg2 = new Register( Constants.RG2Name, step3 );
		
		AndGate andBetweenRG1_Sum1 = new AndGate( "&1", rg1, sum1, false );
		AndGate andBetweenSum1_SumRes = new AndGate( "&2", sum1, sumRes, false );
		AndGate andBetweenSum2_SumRes = new AndGate( "&3", sum2, sumRes, true );
		AndGate andBetweenSum3_Sum2 = new AndGate( "&4", sum3, sum2, false );
		AndGate andBetweenRG2_Sum3 = new AndGate( "&4", rg2, sum3, false );
		
		YReceiver yReceiver = new YReceiver( Constants.yName );
		
		xGenerator.addDrivenElement( andBetweenSum1_SumRes );
		xGenerator.addDrivenElement( andBetweenRG1_Sum1 );
		
		sumRes.addDrivenElement( yReceiver );
		sumRes.addDrivenElement( andBetweenSum2_SumRes );
		sumRes.addDrivenElement( andBetweenSum3_Sum2 );
		sumRes.addDrivenElement( andBetweenRG2_Sum3 );
		
		
		Environment environment = new Environment();
		
		Scheme scheme = new Scheme( environment );
		scheme.addElement( rg1 );
		scheme.addElement( sumRes );
		scheme.addElement( sum1 );
		scheme.addElement( sum2 );
		scheme.addElement( sum3 );
		scheme.addElement( rg2 );
		
		scheme.addElement( andBetweenRG1_Sum1 );
		scheme.addElement( andBetweenSum1_SumRes );
		scheme.addElement( andBetweenSum2_SumRes );
		scheme.addElement( andBetweenSum3_Sum2 );
		scheme.addElement( andBetweenRG2_Sum3 );
		
		scheme.addElement( yReceiver );
		
		scheme.addSignalGenerator( xGenerator );
		scheme.addSignalGenerator( sumRes );
		
		/*
		Adder rg1 = new Adder( "RG1", rgInit1 );
		Adder sum1 = new Adder( "Sum1", init0 );
		AdderWithOverflow sum2 = new AdderWithOverflow( "Sum2", init1 );
		Adder rg2 = new Adder( "RG2", init2 );
		Adder rg_hidden = new Adder( "RG_Hidden", init3 );
		AdderWithOverflow cntSqrt = new AdderWithOverflow( "Cnt_sqrt", init4 );
		SteppingAdder cntRes = new SteppingAdder( "Cnt_res", init5, step5 );
		
		AndGate andBetweenRG1_Sum1 = new AndGate( "&", rg1, sum1 );
		AndGate andBetweenSum1_Sum2 = new AndGate( "&", sum1, sum2, false, 2 );
		AndGate andBetweenRG2_Sum2 = new AndGate( "&", rg2, sum2, true, 2 );
		AndGate andBetweenRGHidden_CntSqrt = new AndGate( "&", rg_hidden, cntSqrt );
		AndGate andBetweenCntRes_CntSqrt = new AndGate( "&", cntRes, cntSqrt, true, 2 );
		
		YReceiver yReceiver = new YReceiver( "y" );
		
		xGenerator.addDrivenElement( andBetweenSum1_Sum2 );
		xGenerator.addDrivenElement( andBetweenRG1_Sum1 );
		
		sum2.addDrivenElement( andBetweenRGHidden_CntSqrt );
		sum2.addDrivenElement( andBetweenRG2_Sum2 );
		
		cntSqrt.addDrivenElement( yReceiver );
		cntSqrt.addDrivenElement( cntRes );
		cntSqrt.addDrivenElement( andBetweenCntRes_CntSqrt );
		
		
		
		Environment environment = new Environment();
		
		Scheme scheme = new Scheme( environment );
		scheme.addElement( rg1 );
		scheme.addElement( sum1 );
		scheme.addElement( sum2 );
		scheme.addElement( rg2 );
		scheme.addElement( rg_hidden );
		scheme.addElement( cntSqrt );
		scheme.addElement( cntRes );
		
		scheme.addElement( andBetweenRG1_Sum1 );
		scheme.addElement( andBetweenSum1_Sum2 );
		scheme.addElement( andBetweenRG2_Sum2 );
		scheme.addElement( andBetweenRGHidden_CntSqrt );
		scheme.addElement( andBetweenCntRes_CntSqrt );
		
		scheme.addElement( yReceiver );
		
		scheme.addElementToActivate( xGenerator );
		scheme.addElementToActivate( sum2 );
		scheme.addElementToActivate( cntSqrt );
		
		*/
		
		scheme.executeNImpetuses( xMax );
		
		int y = yReceiver.getNumber();
		
	
		
		//scheme.getEnvironment().getLogger().print();
		
		Lab1Printer lab1Printer = new Lab1Printer( scheme.getEnvironment().getLogger() );
		lab1Printer.print();
	}
}

​x
 
using System;
using System.Collections.Generic;
using System.Text;
​
public static class Initialization
{
​
/*****************************************/
​
    public const string RG1Name = "RG1";
    public const string RG2Name = "RG2";
    public const string Sum1Name = "Sum1";
    public const string SumResName = "Sum res";
    public const string Sum2Name = "Sum2";
    public const string Sum3Name = "Sum3";
    
    public const string yName = "y";
    public const string xName = "x";
    
    public const int xMax = 50;
​
/*****************************************/
​
}
​
​
public static class Constants
{
    public const string RG1Name = Initialization.RG1Name;
    
    public const string RG2Name = Initialization.RG2Name;
    
    public const string Sum1Name = Initialization.Sum1Name;
    
    public const string SumResName = Initialization.SumResName;
    
    public const string Sum2Name = Initialization.Sum2Name;
    
    public const string Sum3Name = Initialization.Sum3Name;
    
    public const string yName = Initialization.yName;
    
    public const string xName = Initialization.xName;
    
    public const int xMax = Initialization.xMax;
​
}
​
public interface IEvent
{
    MutableMemoryElement getMemoryElement();
    
    bool isOverflow();
    
    int getPrevNumber();
    
    int getNumberToAdd();
    
    int getNewNumber();
}
​
public class MemoryElementWithStepActivation
    :   IEvent
{
    public MemoryElementWithStepActivation(
            MemoryElementWithStep _memoryElementWithStep
        ,   int _prevNumber
        ,   int _step
        ,   int _newNumber
        ,   bool _overflow
    )
    {
        m_memoryElementWithStep = _memoryElementWithStep;
        m_prevNumber = _prevNumber;
        m_step = _step;
        m_newNumber = _newNumber;
        m_overflow = _overflow;
    }
    
    public MutableMemoryElement getMemoryElement()
    {
        return m_memoryElementWithStep;
    }
    
    public bool isOverflow()
    {
        return m_overflow;
    }
    
    public int getPrevNumber()
    {
        return m_prevNumber;
    }
    
    public int getNumberToAdd()
    {
        return m_step;
    }
    
    public int getNewNumber()
    {
        return m_newNumber;
    }
    
    public MemoryElementWithStep m_memoryElementWithStep;
    public int m_prevNumber;
    public int m_step;
    public int m_newNumber;
    public bool m_overflow;
}
​
​
/*
public class SteppingAdderActivation
    :   IEvent
{
    public SteppingAdderActivation(
            SteppingAdder _adder
        ,   int _prevNumber
        ,   int _step
        ,   int _newNumber
    )
    {
        m_adder = _adder;
        m_prevNumber = _prevNumber;
        m_step = _step;
        m_newNumber = _newNumber;
    }
    
    public SteppingAdder m_adder;
    public int m_prevNumber;
    public int m_step;
    public int m_newNumber;
}
*/
​
​
​
public class AndGateActivation
    :   IEvent
{
    public AndGateActivation(
            MutableMemoryElement _mutableElement
        ,   int _prevNumber
        ,   int _numberToAdd
        ,   int _newNumber
        ,   bool _overflow
    )
    {
        m_mutableElement = _mutableElement;
        m_prevNumber = _prevNumber;
        m_numberToAdd = _numberToAdd;
        m_newNumber = _newNumber;
        m_overflow = _overflow;
    }
    
    public MutableMemoryElement getMemoryElement()
    {
        return m_mutableElement;
    }
    
    public bool isOverflow()
    {
        return m_overflow;
    }
    
    public int getPrevNumber()
    {
        return m_prevNumber;
    }
    
    public int getNumberToAdd()
    {
        return m_numberToAdd;
    }
    
    public int getNewNumber()
    {
        return m_newNumber;
    }
​
    public MutableMemoryElement m_mutableElement;
    public int m_prevNumber;
    public int m_numberToAdd;
    public int m_newNumber;
    public bool m_overflow;
}
​
public class Logger
{
    public Logger()
    {
        m_events = new List< IEvent >();
    }
    
    public void addEvent( IEvent _event )
    {
        m_events.Add( _event );
    }
    
    public void print()
    {
        foreach ( IEvent currentEvent in m_events )
        {
            MemoryElementWithStepActivation memoryElementWithStepActivation =
                currentEvent as MemoryElementWithStepActivation;
            
            AndGateActivation andGateActivation =
                currentEvent as AndGateActivation;
​
            if ( (object)memoryElementWithStepActivation != null )
            {
                print( memoryElementWithStepActivation );
            }
            else if ( (object)andGateActivation != null )
            {
                print( andGateActivation );
            }
        }
    }
    
    private void print( MemoryElementWithStepActivation _memoryElementWithStepActivation )
    {
        StringBuilder sb = new StringBuilder();
        
        bool overflow = _memoryElementWithStepActivation.m_overflow;
        
        sb.AppendFormat(
                "{0} : {1} + {2} = {3}"
            ,   _memoryElementWithStepActivation.m_memoryElementWithStep.getName()
            ,   _memoryElementWithStepActivation.m_prevNumber
            ,   _memoryElementWithStepActivation.m_step
            ,   _memoryElementWithStepActivation.m_newNumber
            ,   _memoryElementWithStepActivation.m_overflow
        );
        
        if ( overflow )
            sb.Append( " - overflow" );
        
        Console.WriteLine( sb.ToString() );
    }
    
    private void print( AndGateActivation _andGateActivation )
    {
        StringBuilder sb = new StringBuilder();
        
        bool overflow = _andGateActivation.m_overflow;
        
        sb.AppendFormat(
                "{0} : {1} + {2} = {3}"
            ,   _andGateActivation.m_mutableElement.getName()
            ,   _andGateActivation.m_prevNumber
            ,   _andGateActivation.m_numberToAdd
            ,   _andGateActivation.m_newNumber
        );
        
        if ( overflow )
            sb.Append( " - overflow" );
        
        Console.WriteLine( sb.ToString() );
    }
    
    public List< IEvent > getEvents()
    {
        return m_events;
    }
    
    private List< IEvent > m_events;
}
​
public class Environment
{
    public Environment()
    {
        m_logger = new Logger();
    }
    
    public Logger getLogger()
    {
        return m_logger;
    }
    
    private Logger m_logger;
}
​
public interface IElement
{
    string getName();
}
​
public interface IActiveElement
{
    void tryActivate( Environment _environment );
}
​
public interface ISignalGenerator
{
    void addDrivenElement( IActiveElement _element );
    
    bool hasImpetus();
    
    void resetImpetus();
    
    void tryActivateDrivenElements( Environment _environment );
    
    void nextTurn();
    
    IEnumerable< IActiveElement > getDrivenElementsIterable();
}
​
​
public abstract class ElementBase
    :   IElement
{
    public ElementBase( string _name )
    {
        m_name = _name;
    }
    
    public string getName()
    {
        return m_name;
    }
    
    private string m_name;
}
​
​
public class XGenerator
    :   ElementBase
    ,   ISignalGenerator
{
    public XGenerator( string _name )
        :   base( _name )
    {
        m_impetus = false;
        m_drivenElements = new List< IActiveElement >();
    }
    
    public bool hasImpetus()
    {
        return m_impetus;
    }
    
    public void resetImpetus()
    {
        m_impetus = false;
    }
    
    public void tryActivateDrivenElements( Environment _environment )
    {
        foreach ( IActiveElement element in m_drivenElements )
        {
            element.tryActivate( _environment );
        }
    }
    
    public IEnumerable< IActiveElement > getDrivenElementsIterable()
    {
        foreach( IActiveElement element in m_drivenElements )
        {
            yield return element;
        }
    }
    
    public void nextTurn()
    {
        m_impetus = true;
    }
    
    public void addDrivenElement( IActiveElement _element )
    {
        m_drivenElements.Add( _element );
    }
    
    private bool m_impetus;
    
    private List< IActiveElement > m_drivenElements;
}
​
​
​
public class MemoryElement
    :   ElementBase
{
    public MemoryElement(
            string _name
        ,   int _data
    )
        :   base( _name )
    {
        m_data = _data;
    }
​
    public int getNumber()
    {
        return m_data;
    }
    
    public virtual bool doesOverflow()
    {
        return false;
    }
    
    protected void setNumber( int _newData )
    {
        m_data = _newData;
    }
    /*
    protected void addNumber( int _n )
    {
        m_data += _n;
    }
    */
    
    private int m_data;
}
​
​
public class Register
    :   MemoryElement
{
    public Register(
            string _name
        ,   int _data
    )
        :   base( _name, _data )
    {
    }
}
​
public class MutableMemoryElement
    :   MemoryElement
{
    public MutableMemoryElement(
            string _name
        ,   int _data
    )
        :   base( _name, _data )
    {
        //m_data = _data;
    }
    
    public virtual void addNumber( int _n )
    {
        setNumber( getNumber() + _n );
    }
}
​
​
​
​
public class MemoryElementWithStep
    :   MutableMemoryElement
    ,   IActiveElement
{
    public MemoryElementWithStep(
            string _name
        ,   int _data
        ,   int _step
    )
        :   base( _name, _data )
    {
        m_step = _step;
    }
    
    public void tryActivate( Environment _environment )
    {
    /*
        if ( !m_impetusProvider.hasImpetus() )
            return;
    */
        Logger logger = _environment.getLogger();
        
        int prevNumber = getNumber();
        int step = m_step;
        
        addNumber( m_step );
        
        int newNumber = getNumber();
        
        MemoryElementWithStepActivation activationEvent = new MemoryElementWithStepActivation(
                this
            ,   prevNumber
            ,   step
            ,   newNumber
            ,   doesOverflow()
        );
        
        logger.addEvent(  activationEvent );
    }
    
    private int m_step;
}
​
​
public class MemoryElementWithOverflow
    :   MemoryElementWithStep
    ,   ISignalGenerator
{
    public MemoryElementWithOverflow(
            string _name
        ,   int _data
        ,   int _step
    )
        :   base( _name, _data, _step )
    {
        m_drivenElements = new List< IActiveElement >();
    }
    
    public void addDrivenElement( IActiveElement _element )
    {
        m_drivenElements.Add( _element );
    }
    
    public void tryActivateDrivenElements( Environment _environment )
    {
        foreach ( IActiveElement element in m_drivenElements )
        {
            element.tryActivate( _environment );
        }
    }
    
    public IEnumerable< IActiveElement > getDrivenElementsIterable()
    {
        foreach( IActiveElement element in m_drivenElements )
        {
            yield return element;
        }
    }
    
    public bool hasImpetus()
    {
        return m_impetus;
    }
    
    public void resetImpetus()
    {
        m_impetus = false;
    }
    
    public void nextTurn()
    {
        //
    }
    
    public override bool doesOverflow()
    {
        return getNumber() >= 0;
    }
    
    public override void addNumber( int _n )
    {
        base.addNumber( _n );
        if ( doesOverflow() )
            m_impetus = true;
    }
    
    private bool m_impetus;
    
    private List< IActiveElement > m_drivenElements;
}
​
​
public class AndGate
    :   ElementBase
    ,   IActiveElement
{
    public AndGate(
            string _name
        ,   MemoryElement _fromElement
        ,   MutableMemoryElement _toElement
    //  ,   IElement _impetusProvider
        ,   bool _inverting = false
        ,   int _modifierPow = 0
    )
        :   base( _name )
    {
        m_fromElement = _fromElement;
        m_toElement = _toElement;
    //  m_impetusProvider = _impetusProvider;
        m_inverting = _inverting;
        m_modifierPow = _modifierPow;
    }
    
    public void tryActivate( Environment _environment )
    {
        //if ( !m_impetusProvider.hasImpetus() )
        //  return;
    
        Logger logger = _environment.getLogger();
        
        int numberToAdd = m_fromElement.getNumber();
        if ( m_inverting )
            numberToAdd *= -1;
            
        int modifier = ( int ) ( Math.Pow( 2.0, m_modifierPow ) + 0.1 );
            
        numberToAdd *= modifier;
        
        int prevNumber = m_toElement.getNumber();
        
        m_toElement.addNumber( numberToAdd );
        
        int newNumber = m_toElement.getNumber();
        
        AndGateActivation andGateActivation = new AndGateActivation(
                m_toElement
            ,   prevNumber
            ,   numberToAdd
            ,   newNumber
            ,   m_toElement.doesOverflow()
        );
        
        logger.addEvent( andGateActivation );
    }
    
    private MemoryElement m_fromElement;
    
    private MutableMemoryElement m_toElement;
    
    //private IElement m_impetusProvider;
    
    private bool m_inverting;
    
    private int m_modifierPow;
}
​
​
/*
public interface IElement
{
    string getName();
    
    int getNumber();
    
    void addNumber( int _n );
    
    bool hasImpetus();
    
    void resetImpetus();
    
    void tryActivate( Environment _environment );
    
    void nextTurn();
}
*/
/*
​
public abstract class ElementBase
    :   IElement
{
    public ElementBase( string _name )
    {
        m_name = _name;
    }
    
    public string getName()
    {
        return m_name;
    }
    
    public abstract int getNumber();
    
    public abstract void addNumber( int _n );
    
    public abstract bool hasImpetus();
    
    public abstract void resetImpetus();
    
    public abstract void tryActivate( Environment _environment );
    
    public virtual void nextTurn()
    {
    }
    
    private string m_name;
}
*/
​
/*
public class XGenerator
    :   ElementBase
{
    public XGenerator( string _name )
        :   base( _name )
    {
        m_impetus = false;
        m_drivenElements = new List< IElement >();
    }
​
    public override int getNumber()
    {
        return 0;
    }
    
    public override void addNumber( int _n )
    {
        throw new Exception();
    }
    
    public override bool hasImpetus()
    {
        return m_impetus;
    }
    
    public override void resetImpetus()
    {
        m_impetus = false;
    }
    
    public override void tryActivate( Environment _environment )
    {
        foreach ( IElement element in m_drivenElements )
        {
            element.tryActivate( _environment );
        }
    }
    
    public override void nextTurn()
    {
        m_impetus = true;
    }
    
    public void addDrivenElement( IElement _element )
    {
        m_drivenElements.Add( _element );
    }
    
    private bool m_impetus;
    
    private List< IElement > m_drivenElements;
}
*/
​
public class Adder
    :   MutableMemoryElement
{
    public Adder( string _name, int _data )
        :   base( _name, _data )
    {
    }
}
​
public class Counter
    :   MutableMemoryElement
{
    public Counter( string _name, int _data )
        :   base( _name, _data )
    {
    }
}
​
​
public class AdderWithStep
    :   MemoryElementWithStep
{
    public AdderWithStep( string _name, int _data, int _step )
        :   base( _name, _data, _step )
    {
    }
}
​
public class CounterWithStep
    :   MemoryElementWithStep
{
    public CounterWithStep( string _name, int _data, int _step )
        :   base( _name, _data, _step )
    {
    }
}
​
​
public class AdderWithOverflow
    :   MemoryElementWithOverflow
{
    public AdderWithOverflow( string _name, int _data, int _step )
        :   base( _name, _data, _step )
    {
    }
}
​
public class CounterWithOverflow
    :   MemoryElementWithOverflow
{
    public CounterWithOverflow( string _name, int _data, int _step )
        :   base( _name, _data, _step )
    {
    }
}
​
​
/*
public class Adder
    :   ElementBase
{
    public Adder(
            string _name
        ,   int _data
    )
        :   base( _name )
    {
        m_data = _data;
    }
​
    public override int getNumber()
    {
        return m_data;
    }
    
    public override void addNumber( int _n )
    {
        m_data += _n;
    }
    
    public override bool hasImpetus()
    {
        return false;
    }
    
    public override void resetImpetus()
    {
        throw new Exception();
    }
    
    public override void tryActivate( Environment _environment )
    {
        //throw new Exception();
    }
    
    public override void nextTurn()
    {
    }
    
    public virtual bool doesOverflow()
    {
        return false;
    }
    
    private int m_data;
}
*/
​
​
​
​
/*
public class AdderWithOverflow
    :   Adder
{
    public AdderWithOverflow(
            string _name
        ,   int _data
    )
        :   base( _name, _data )
    {
        m_overflow = false;
        m_drivenElements = new List< IElement >();
    }
    
    public override void addNumber( int _n )
    {
        base.addNumber( _n );
        if ( doesOverflow() )
            m_overflow = true;
    }
    
    public override bool hasImpetus()
    {
        return m_overflow;
    }
    
    public override void resetImpetus()
    {
        m_overflow = false;
    }
    
    public override void nextTurn()
    {
        m_overflow = false;
    }
    
    public override bool doesOverflow()
    {
        if ( getNumber() >= 0 )
            return true;
        else
            return false;
    }
    
    public override void tryActivate( Environment _environment )
    {
        foreach ( IElement element in m_drivenElements )
        {
            element.tryActivate( _environment );
        }
        //throw new Exception();
    }
    
    public void addDrivenElement( IElement _element )
    {
        m_drivenElements.Add( _element );
    }
    
    private bool m_overflow;
    
    private List< IElement > m_drivenElements;
}
*/
​
/*
public class SteppingAdder
    :   Adder
{
    public SteppingAdder(
            string _name
        ,   int _data
        ,   int _step
        //, IElement _impetusProvider
    )
        :   base( _name, _data )
    {
        m_step = _step;
        //m_impetusProvider = _impetusProvider;
    }
​
    public override void tryActivate( Environment _environment )
    {
    /*
        if ( !m_impetusProvider.hasImpetus() )
            return;
    */
​
/*
        Logger logger = _environment.getLogger();
        
        int prevNumber = getNumber();
        int step = m_step;
    
        addNumber( m_step );
        
        int newNumber = getNumber();
        
        SteppingAdderActivation steppingAdderActivation = new SteppingAdderActivation(
                this
            ,   prevNumber
            ,   step
            ,   newNumber
        );
        
        logger.addEvent(  steppingAdderActivation );
    }
    
    
    private int m_step;
    
    //private IElement m_impetusProvider;
}
*/
/*
public class AndGate
    :   ElementBase
{
    public AndGate(
            string _name
        ,   IElement _fromElement
        ,   Adder _toElement
    //  ,   IElement _impetusProvider
        ,   bool _inverting = false
        ,   int _modifier = 1
    )
        :   base( _name )
    {
        m_fromElement = _fromElement;
        m_toElement = _toElement;
    //  m_impetusProvider = _impetusProvider;
        m_inverting = _inverting;
        m_modifier = _modifier;
    }
​
    public override int getNumber()
    {
        return 0;
    }
    
    public override void addNumber( int _n )
    {
        throw new Exception();
    }
    
    public override bool hasImpetus()
    {
        throw new Exception();
    }
    
    public override void resetImpetus()
    {
        throw new Exception();
    }
    
    public override void tryActivate( Environment _environment )
    {
        //if ( !m_impetusProvider.hasImpetus() )
        //  return;
    
        Logger logger = _environment.getLogger();
        
        int numberToAdd = m_fromElement.getNumber();
        if ( m_inverting )
            numberToAdd *= -1;
            
        numberToAdd *= m_modifier;
        
        int prevNumber = m_toElement.getNumber();
        
        m_toElement.addNumber( numberToAdd );
        
        int newNumber = m_toElement.getNumber();
        
        AndGateActivation andGateActivation = new AndGateActivation(
                m_toElement
            ,   prevNumber
            ,   numberToAdd
            ,   newNumber
            ,   m_toElement.doesOverflow()
        );
        
        logger.addEvent( andGateActivation );
    }
    
    private IElement m_fromElement;
    
    private Adder m_toElement;
    
    //private IElement m_impetusProvider;
    
    private bool m_inverting;
    
    private int m_modifier;
}
*/
​
public class YReceiver
    :   MemoryElementWithStep
{
    public YReceiver( string _name )
        :   base( _name, 0, 1 )
    {
    }
}
​
/*
public class YReceiver
    :   ElementBase
{
    public YReceiver(
            string _name
    //  ,   IElement _impetusProvider
    )
        :   base( _name )
    {
        m_impetusNumber = 0;
    //  m_impetusProvider = _impetusProvider;
    }
​
    public override int getNumber()
    {
        return m_impetusNumber;
    }
    
    public override void addNumber( int _n )
    {
        throw new Exception();
    }
    
    public override bool hasImpetus()
    {
        throw new Exception();
    }
    
    public override void resetImpetus()
    {
        throw new Exception();
    }
    
    public override void tryActivate( Environment _environment )
    {
        //if ( !m_impetusProvider.hasImpetus() )
        //  return;
    
        ++m_impetusNumber;
    }
    
    private int m_impetusNumber;
    
    //private IElement m_impetusProvider;
}
*/
​
​
public class Scheme
{
    public Scheme( Environment _environment )
    {
        m_environment = _environment;
        //m_elementsToActivate = new List< IElement >();
        m_signalGenerators = new List< ISignalGenerator >();
        m_elements = new List< IElement >();
        m_elementsToActivateStack = new Stack< IActiveElement >();
    }
    
    public void addElement( IElement _element )
    {
        m_elements.Add( _element );
    }
    
    public void addSignalGenerator( ISignalGenerator _signalGenerator )
    {
        m_signalGenerators.Add( _signalGenerator );
    }
    
    public Environment getEnvironment()
    {
        return m_environment;
    }
    
    public void executeNImpetuses( int _number )
    {
        for ( int i = 0; i < _number; ++i )
        {
            nextTurn();
            execute();
        }
    }
    
    private void execute()
    {
        //int currentIndex = -1;
        
        while ( true )
        {
            int signalGeneratorToExecuteIndex = findSignalGeneratorToExecuteIndex( /*currentIndex*/ );
            if ( signalGeneratorToExecuteIndex != -1 )
            {
                ISignalGenerator signalGenerator = m_signalGenerators[ signalGeneratorToExecuteIndex ];
                List< IActiveElement > temp = new List< IActiveElement >();
                temp.AddRange( signalGenerator.getDrivenElementsIterable() );
​
                int count = temp.Count;
                for ( int i = count - 1; i >= 0; --i )
                {
                    m_elementsToActivateStack.Push( temp[ i ] );
                }
​
                signalGenerator.resetImpetus();
                //++currentIndex;
            }
            if ( m_elementsToActivateStack.Count == 0 )
                break;
            
            IActiveElement activeElement = m_elementsToActivateStack.Pop();
            activeElement.tryActivate( getEnvironment() );
        }
        
        /*
        while ( true )
        {
            ISignalGenerator signalGenerator = findSignalGeneratorToExecute();
            if ( (object)signalGenerator == null )
                return;
            
            execute( signalGenerator );
        }
        */
        /*
        foreach ( IElement element in m_elementsToActivate )
        {
            execute( element );
        }
        */
    }
    
    private ISignalGenerator findSignalGeneratorToExecute()
    {
        int count = m_signalGenerators.Count;
        for ( int i = count - 1; i >= 0; --i )
        {
            ISignalGenerator signalGenerator = m_signalGenerators[ i ];
            if ( signalGenerator.hasImpetus() )
                return signalGenerator;
        }
        return null;
    }
    
    private int findSignalGeneratorToExecuteIndex()
    {
        int count = m_signalGenerators.Count;
        for ( int i = count - 1; i >= 0; --i )
        {
            ISignalGenerator signalGenerator = m_signalGenerators[ i ];
            if ( signalGenerator.hasImpetus() )
                return i;
        }
        return -1;
    }
    
    private void execute( ISignalGenerator _signalGenerator )
    {
        /*
        while ( _element.hasImpetus() )
        {
            _element.resetImpetus();
            _element.tryActivate( getEnvironment() );
        }
        */
        
        if ( !_signalGenerator.hasImpetus() )
            throw new Exception();
        
        _signalGenerator.resetImpetus();
        _signalGenerator.tryActivateDrivenElements( getEnvironment() );
    }
    
    private void nextTurn()
    {
        foreach ( ISignalGenerator signalGenerator in m_signalGenerators )
        {
            signalGenerator.nextTurn();
        }
    }
    
    private Environment m_environment;
    //private List< IElement > m_elementsToActivate;
    private List< ISignalGenerator > m_signalGenerators;
    private List< IElement > m_elements;
    private Stack< IActiveElement > m_elementsToActivateStack;
}
​
​
​
public class ReportPrinter
{
    public ReportPrinter( int _height, int _length )
    {
        m_length = _length;
        m_height = _height;
        
        m_data = new string[ m_height, m_length ];
        init();
    }
    
    public void normalize()
    {
        for ( int i = 0; i < m_length; ++i )
        {
            int maxColumnElementLength = getMaxElementLength( i );
            normalizeColumn( i, maxColumnElementLength );
        }
    }
    
    public int getMaxElementLength( int _columnIndex )
    {
        int maxLength = 0;
        for ( int i = 0; i < m_height; ++i )
        {
            int elementLength = m_data[ i, _columnIndex ].Length;
            if ( maxLength < elementLength )
                maxLength = elementLength;
        }
        return maxLength;
    }
    
    public void normalizeColumn( int _columnIndex, int _maxColumnElementLength )
    {
        for ( int i = 0; i < m_height; ++i )
        {
            string element = m_data[ i, _columnIndex ];
            int elementLength = element.Length;
            int lengthDifference = _maxColumnElementLength - elementLength;
            if ( lengthDifference == 0 )
                continue;
            
            string spaces =  new String( ' ', lengthDifference );
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat( "{0}{1}", element, spaces );
            m_data[ i, _columnIndex ] = sb.ToString();
        }
    }
    
    public void print()
    {
        normalize();
        for ( int i = 0; i < m_height; ++i )
        {
            Console.Write( "\n" );
            for ( int j = 0; j < m_length; ++j )
            {
                Console.Write( "{0}\t", m_data[ i, j ] );
            }
        }
    }
    
    private void init()
    {
        for ( int i = 0; i < m_height; ++i )
        {
            for ( int j = 0; j < m_length; ++j )
            {
                m_data[ i, j ] = "";
            }
        }
    }
    
    private int m_height;
    private int m_length;
    
    public string[,] m_data;
}
​
​
/*
public class Lab2Printer
{
    public Lab2Printer( Logger _logger )
    {
        m_logger = _logger;
        initEventsByMemoryElement();
        initColumnIndexesByMemoryElement();
    }
    
    public void printModelling()
    {
        int length = 7;
        int height = getHeight();
        
        ReportPrinter reportPrinter = new ReportPrinter( height, length );
        
        // header
        reportPrinter.m_data[ 0, 0 ] = "x";
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] = Constants.Sum1Name;
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum2Name ] ] = Constants.Sum2Name;
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum2Name ] + 1 ] = Constants.Sum2Name + " overflow";
        
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.CNTSqrtName ] ] = Constants.CNTSqrtName;
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.CNTSqrtName ] + 1 ] = Constants.CNTSqrtName + " overflow";
        
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.CNTResName ] ] = Constants.CNTResName;
        
        int lineIndex = 0;
        int x = 1;
        
        reportPrinter.m_data[ lineIndex + 1, 0 ] = x.ToString();
        reportPrinter.m_data[ lineIndex + 1, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
            toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
        
        bool cntSqrtOverflow = false;
        
        List< IEvent > events = m_logger.getEvents();
        foreach ( IEvent currentEvent in events )
        {
            string memoryElementName = currentEvent.getMemoryElement().getName();
            
            if
                (
                    ( memoryElementName != Constants.Sum2Name )
                &&  ( memoryElementName != Constants.CNTSqrtName )
                &&  ( memoryElementName != Constants.CNTResName )
            )
                continue;
​
            if ( memoryElementName == Constants.Sum2Name )
            {
                ++lineIndex;
                
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
                    toText( currentEvent );
                
                if ( currentEvent.isOverflow() )
                    reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] + 1 ] = "1";
                else
                {
                    ++x;
                    if ( x - 1 < m_eventsByMemoryElement[ Constants.Sum1Name ].Count )
                    {
                        reportPrinter.m_data[ lineIndex + 1, 0 ] = x.ToString();
                        reportPrinter.m_data[ lineIndex + 1, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
                            toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
                    }
                }
            }
            else if ( memoryElementName == Constants.CNTSqrtName )
            {
                if ( cntSqrtOverflow )
                    ++lineIndex;
                
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
                    toText( currentEvent );
                
                if ( currentEvent.isOverflow() )
                {
                    cntSqrtOverflow = true;
                    reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] + 1 ] = "1";
                }
                else
                {
                    cntSqrtOverflow = false;
                }
            }
            else if ( memoryElementName == Constants.CNTResName )
            {
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
                    toText( currentEvent );
            }
            else
                throw new Exception();
        }
        
        reportPrinter.print();
    }
    
    public void print()
    {
        printModelling();
    }
    
    private int getHeight()
    {
        int height = 1;
        
        height += m_eventsByMemoryElement[ Constants.Sum2Name ].Count;
        
        int cntSqrtOverflow = 0;
        foreach ( IEvent currentEvent in m_eventsByMemoryElement[ Constants.CNTSqrtName ] )
        {
            if ( currentEvent.isOverflow() )
                ++cntSqrtOverflow;
        }
        height += cntSqrtOverflow;
        return height;
    }
    
    private void initEventsByMemoryElement()
    {
        m_eventsByMemoryElement = new Dictionary< string, List< IEvent > >();
        
        m_eventsByMemoryElement.Add( Constants.Sum1Name, new List< IEvent >() );
        m_eventsByMemoryElement.Add( Constants.Sum2Name, new List< IEvent >() );
        m_eventsByMemoryElement.Add( Constants.CNTSqrtName, new List< IEvent >() );
        m_eventsByMemoryElement.Add( Constants.CNTResName, new List< IEvent >() );
        m_eventsByMemoryElement.Add( Constants.yName, new List< IEvent >() );
        
        List< IEvent > events = m_logger.getEvents();
        foreach ( IEvent currentEvent in events )
        {
            m_eventsByMemoryElement[ currentEvent.getMemoryElement().getName() ].Add( currentEvent );
        }
    }
    
    public void initColumnIndexesByMemoryElement()
    {
        m_columnIndexByMemoryElement = new Dictionary< string, int >();
        
        m_columnIndexByMemoryElement.Add( Constants.Sum1Name, 3 );
        m_columnIndexByMemoryElement.Add( Constants.Sum2Name, 1 );
        m_columnIndexByMemoryElement.Add( Constants.CNTSqrtName, 4 );
        m_columnIndexByMemoryElement.Add( Constants.CNTResName, 6 );
    }
    
    public string toText( IEvent _event )
    {
        StringBuilder sb = new StringBuilder();
        
        if ( _event.getMemoryElement().getName() == Constants.CNTResName )
        {
            return _event.getNewNumber().ToString();
        }
        
        sb.AppendFormat(
                "{0} + {1} = {2}"
            ,   _event.getPrevNumber()
            ,   _event.getNumberToAdd()
            ,   _event.getNewNumber()
        );
        
        return sb.ToString();
    }
    
    private Logger m_logger;
    
    private Dictionary< string, List< IEvent > > m_eventsByMemoryElement;
    
    private Dictionary< string, int > m_columnIndexByMemoryElement;
}
*/
​
public class Lab1Printer
{
    public Lab1Printer( Logger _logger )
    {
        m_logger = _logger;
        initEventsByMemoryElement();
        initColumnIndexesByMemoryElement();
    }
    
    public void printModelling()
    {
        int length = 7;
        int height = getHeight();
        
        ReportPrinter reportPrinter = new ReportPrinter( height, length );
        
        // header
        reportPrinter.m_data[ 0, 0 ] = "x";
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.SumResName ] ] = Constants.SumResName;
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.SumResName ] + 1 ] = Constants.SumResName + " overflow";
        
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] = Constants.Sum1Name;
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum2Name ] ] = Constants.Sum2Name;
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.Sum3Name ] ] = Constants.Sum3Name;
        
        reportPrinter.m_data[ 0, m_columnIndexByMemoryElement[ Constants.yName ] ] = Constants.yName;
        
        int lineIndex = 0;
        int overflowIndex = 0;
        int x = 0;
        
        reportPrinter.m_data[ lineIndex + 1, 0 ] = x.ToString();
        //reportPrinter.m_data[ lineIndex + 1, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
        //  toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
        
        List< IEvent > events = m_logger.getEvents();
        
        bool prevSumResIsOverflow = false;
        
        
        foreach ( IEvent sumResEvent in m_eventsByMemoryElement[ Constants.SumResName ] )
        {
            ++lineIndex;
            
            reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.SumResName ] ] =
                toText( sumResEvent );
            
            if ( !prevSumResIsOverflow )
            {
                ++x;
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.xName ] ] =
                    x.ToString();
                
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
                    toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
            }
            
            if ( sumResEvent.isOverflow() )
            {
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.SumResName ] + 1 ] =
                    "1";
                
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.Sum2Name ] ] =
                    toText( m_eventsByMemoryElement[ Constants.Sum2Name ][ overflowIndex ] );
                
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.Sum3Name ] ] =
                    toText( m_eventsByMemoryElement[ Constants.Sum3Name ][ overflowIndex ] );
                
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ Constants.yName ] ] =
                    toText( m_eventsByMemoryElement[ Constants.yName ][ overflowIndex ] );
                
                ++overflowIndex;
                prevSumResIsOverflow = true;
            }
            else
                prevSumResIsOverflow = false;
        }
        
        foreach ( IEvent currentEvent in events )
        {
            /*
            string memoryElementName = currentEvent.getMemoryElement().getName();
            
            if
                (
                    ( memoryElementName != Constants.Sum2Name )
                &&  ( memoryElementName != Constants.CNTSqrtName )
                &&  ( memoryElementName != Constants.CNTResName )
            )
                continue;
​
            if ( memoryElementName == Constants.Sum2Name )
            {
                ++lineIndex;
                
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
                    toText( currentEvent );
                
                if ( currentEvent.isOverflow() )
                    reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] + 1 ] = "1";
                else
                {
                    ++x;
                    if ( x - 1 < m_eventsByMemoryElement[ Constants.Sum1Name ].Count )
                    {
                        reportPrinter.m_data[ lineIndex + 1, 0 ] = x.ToString();
                        reportPrinter.m_data[ lineIndex + 1, m_columnIndexByMemoryElement[ Constants.Sum1Name ] ] =
                            toText( m_eventsByMemoryElement[ Constants.Sum1Name ][ x - 1 ] );
                    }
                }
            }
            else if ( memoryElementName == Constants.CNTSqrtName )
            {
                if ( cntSqrtOverflow )
                    ++lineIndex;
                
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
                    toText( currentEvent );
                
                if ( currentEvent.isOverflow() )
                {
                    cntSqrtOverflow = true;
                    reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] + 1 ] = "1";
                }
                else
                {
                    cntSqrtOverflow = false;
                }
            }
            else if ( memoryElementName == Constants.CNTResName )
            {
                reportPrinter.m_data[ lineIndex, m_columnIndexByMemoryElement[ memoryElementName ] ] =
                    toText( currentEvent );
            }
            else
                throw new Exception();
        */
        }
        reportPrinter.print();
    }
    
    public void print()
    {
        printModelling();
    }
    
    private int getHeight()
    {
        int height = 1;
        
        height += m_eventsByMemoryElement[ Constants.SumResName ].Count;
        
        return height;
    }
    
    private void initEventsByMemoryElement()
    {
        m_eventsByMemoryElement = new Dictionary< string, List< IEvent > >();
        
        m_eventsByMemoryElement.Add( Constants.Sum1Name, new List< IEvent >() );
        m_eventsByMemoryElement.Add( Constants.Sum2Name, new List< IEvent >() );
        m_eventsByMemoryElement.Add( Constants.Sum3Name, new List< IEvent >() );
        m_eventsByMemoryElement.Add( Constants.SumResName, new List< IEvent >() );
        m_eventsByMemoryElement.Add( Constants.yName, new List< IEvent >() );
        
        List< IEvent > events = m_logger.getEvents();
        foreach ( IEvent currentEvent in events )
        {
            m_eventsByMemoryElement[ currentEvent.getMemoryElement().getName() ].Add( currentEvent );
        }
    }
    
    public void initColumnIndexesByMemoryElement()
    {
        m_columnIndexByMemoryElement = new Dictionary< string, int >();
        
        m_columnIndexByMemoryElement.Add( Constants.xName, 0 );
        m_columnIndexByMemoryElement.Add( Constants.SumResName, 1 );
        m_columnIndexByMemoryElement.Add( Constants.Sum1Name, 3 );
        m_columnIndexByMemoryElement.Add( Constants.Sum2Name, 4 );
        m_columnIndexByMemoryElement.Add( Constants.Sum3Name, 5 );
        m_columnIndexByMemoryElement.Add( Constants.yName, 6 );
    }
    
    public string toText( IEvent _event )
    {
        StringBuilder sb = new StringBuilder();
        
        if ( _event.getMemoryElement().getName() == Constants.yName )
        {
            return _event.getNewNumber().ToString();
        }
        
        sb.AppendFormat(
                "{0} + {1} = {2}"
            ,   _event.getPrevNumber()
            ,   _event.getNumberToAdd()
            ,   _event.getNewNumber()
        );
        
        return sb.ToString();
    }
    
    private Logger m_logger;
    
    private Dictionary< string, List< IEvent > > m_eventsByMemoryElement;
    
    private Dictionary< string, int > m_columnIndexByMemoryElement;
}
​
​
​
​
​
​
public class Program
{
    public static void Main()
    {
        XGenerator xGenerator = new XGenerator( Constants.xName );
        
        int init0 = 8;
        int step0 = 16;
        
        int init1 = -1;
        int init2 = 26;
        
        int init3 = 72;
        int step3 = 48;
        
        int xMax = Initialization.xMax;
        /*
        int a = 4;
        int b = 5;
        int c = -15;
        int m = 13;
        */
        /*
        int init0 = 23;
        int step0 = 16;
        
        int init1 = -17;
        int init2 = 12;
        int init3 = 1;
        
        int init4 = -1;
        
        int init5 = 2;
        int step5 = 2;
        */
        /*
        int rgInit1 = 2 * a;
        
        int init0 = a + b;
        
        int init1 = 2 * c - m;
        int init2 = m;
        int init3 = 1;
        
        int init4 = -1;
        
        int init5 = 0;
        int step5 = 1;
        */
        /*
        Console.WriteLine( "{0} = {1}", Constants.Sum1Name, init0 );
        Console.WriteLine( "{0} = {1}", Constants.Sum2Name, init1 );
        
        Console.WriteLine( "{0} = {1}", Constants.RG1Name, rgInit1 );
        Console.WriteLine( "{0} = {1}", Constants.RG2Name, init2 );
        
        Console.WriteLine( "{0} = {1}", Constants.CNTSqrtName, init4 );
        Console.WriteLine( "{0} = {1}", Constants.CNTResName, init5 );
        
        Register rg1 = new Register( Constants.RG1Name, rgInit1 );
        Adder sum1 = new Adder( Constants.Sum1Name, init0 );
        AdderWithOverflow sum2 = new AdderWithOverflow( Constants.Sum2Name, init1, 0 );
        Register rg2 = new Register( Constants.RG2Name, init2 );
        AdderWithOverflow cntSqrt = new AdderWithOverflow( Constants.CNTSqrtName, init4, 1 );
        CounterWithStep cntRes = new CounterWithStep( Constants.CNTResName, init5, step5 );
        
        
        AndGate andBetweenRG1_Sum1 = new AndGate( "&", rg1, sum1 );
        AndGate andBetweenSum1_Sum2 = new AndGate( "&", sum1, sum2, false, 1 );
        AndGate andBetweenRG2_Sum2 = new AndGate( "&", rg2, sum2, true, 1 );
        AndGate andBetweenCntRes_CntSqrt = new AndGate( "&", cntRes, cntSqrt, true, 1 );
        
        YReceiver yReceiver = new YReceiver( Constants.yName );
        
        xGenerator.addDrivenElement( andBetweenSum1_Sum2 );
        xGenerator.addDrivenElement( andBetweenRG1_Sum1 );
        
        sum2.addDrivenElement( cntSqrt );
        sum2.addDrivenElement( andBetweenRG2_Sum2 );
        
        cntSqrt.addDrivenElement( yReceiver );
        cntSqrt.addDrivenElement( cntRes );
        cntSqrt.addDrivenElement( andBetweenCntRes_CntSqrt );
        
        Environment environment = new Environment();
        
        Scheme scheme = new Scheme( environment );
        scheme.addElement( rg1 );
        scheme.addElement( sum1 );
        scheme.addElement( sum2 );
        scheme.addElement( rg2 );
        scheme.addElement( cntSqrt );
        scheme.addElement( cntRes );
        
        scheme.addElement( andBetweenRG1_Sum1 );
        scheme.addElement( andBetweenSum1_Sum2 );
        scheme.addElement( andBetweenRG2_Sum2 );
        scheme.addElement( andBetweenCntRes_CntSqrt );
        
        scheme.addElement( yReceiver );
        
        scheme.addSignalGenerator( xGenerator );
        scheme.addSignalGenerator( sum2 );
        scheme.addSignalGenerator( cntSqrt );
        */
        
        Register rg1 = new Register( Constants.RG1Name, step0 );
        Adder sum1 = new Adder( Constants.Sum1Name, init0 );
        AdderWithOverflow sumRes = new AdderWithOverflow( Constants.SumResName, init1, 0 );
        Adder sum2 = new Adder( Constants.Sum2Name, init2 );
        Adder sum3 = new Adder( Constants.Sum3Name, init3 );
        Register rg2 = new Register( Constants.RG2Name, step3 );
        
        AndGate andBetweenRG1_Sum1 = new AndGate( "&1", rg1, sum1, false );
        AndGate andBetweenSum1_SumRes = new AndGate( "&2", sum1, sumRes, false );
        AndGate andBetweenSum2_SumRes = new AndGate( "&3", sum2, sumRes, true );
        AndGate andBetweenSum3_Sum2 = new AndGate( "&4", sum3, sum2, false );
        AndGate andBetweenRG2_Sum3 = new AndGate( "&4", rg2, sum3, false );
        
        YReceiver yReceiver = new YReceiver( Constants.yName );
        
        xGenerator.addDrivenElement( andBetweenSum1_SumRes );
        xGenerator.addDrivenElement( andBetweenRG1_Sum1 );
        
        sumRes.addDrivenElement( yReceiver );
        sumRes.addDrivenElement( andBetweenSum2_SumRes );
        sumRes.addDrivenElement( andBetweenSum3_Sum2 );
        sumRes.addDrivenElement( andBetweenRG2_Sum3 );
        
        
        Environment environment = new Environment();
        
        Scheme scheme = new Scheme( environment );
        scheme.addElement( rg1 );
        scheme.addElement( sumRes );
        scheme.addElement( sum1 );
        scheme.addElement( sum2 );
        scheme.addElement( sum3 );
        scheme.addElement( rg2 );
        
        scheme.addElement( andBetweenRG1_Sum1 );
        scheme.addElement( andBetweenSum1_SumRes );
        scheme.addElement( andBetweenSum2_SumRes );
        scheme.addElement( andBetweenSum3_Sum2 );
        scheme.addElement( andBetweenRG2_Sum3 );
        
        scheme.addElement( yReceiver );
        
        scheme.addSignalGenerator( xGenerator );
        scheme.addSignalGenerator( sumRes );
        
        /*
        Adder rg1 = new Adder( "RG1", rgInit1 );
        Adder sum1 = new Adder( "Sum1", init0 );
        AdderWithOverflow sum2 = new AdderWithOverflow( "Sum2", init1 );
        Adder rg2 = new Adder( "RG2", init2 );
        Adder rg_hidden = new Adder( "RG_Hidden", init3 );
        AdderWithOverflow cntSqrt = new AdderWithOverflow( "Cnt_sqrt", init4 );
        SteppingAdder cntRes = new SteppingAdder( "Cnt_res", init5, step5 );
        
        AndGate andBetweenRG1_Sum1 = new AndGate( "&", rg1, sum1 );
        AndGate andBetweenSum1_Sum2 = new AndGate( "&", sum1, sum2, false, 2 );
        AndGate andBetweenRG2_Sum2 = new AndGate( "&", rg2, sum2, true, 2 );
        AndGate andBetweenRGHidden_CntSqrt = new AndGate( "&", rg_hidden, cntSqrt );
        AndGate andBetweenCntRes_CntSqrt = new AndGate( "&", cntRes, cntSqrt, true, 2 );
        
        YReceiver yReceiver = new YReceiver( "y" );
        
        xGenerator.addDrivenElement( andBetweenSum1_Sum2 );
        xGenerator.addDrivenElement( andBetweenRG1_Sum1 );
        
        sum2.addDrivenElement( andBetweenRGHidden_CntSqrt );
        sum2.addDrivenElement( andBetweenRG2_Sum2 );
        
        cntSqrt.addDrivenElement( yReceiver );
        cntSqrt.addDrivenElement( cntRes );
        cntSqrt.addDrivenElement( andBetweenCntRes_CntSqrt );
        
        
        
        Environment environment = new Environment();
        
        Scheme scheme = new Scheme( environment );
        scheme.addElement( rg1 );
        scheme.addElement( sum1 );
        scheme.addElement( sum2 );
        scheme.addElement( rg2 );
        scheme.addElement( rg_hidden );
        scheme.addElement( cntSqrt );
        scheme.addElement( cntRes );
        
        scheme.addElement( andBetweenRG1_Sum1 );
        scheme.addElement( andBetweenSum1_Sum2 );
        scheme.addElement( andBetweenRG2_Sum2 );
        scheme.addElement( andBetweenRGHidden_CntSqrt );
        scheme.addElement( andBetweenCntRes_CntSqrt );
        
        scheme.addElement( yReceiver );
        
        scheme.addElementToActivate( xGenerator );
        scheme.addElementToActivate( sum2 );
        scheme.addElementToActivate( cntSqrt );
        
        */
        
        scheme.executeNImpetuses( xMax );
        
        int y = yReceiver.getNumber();
        
    
        
        //scheme.getEnvironment().getLogger().print();
        
        Lab1Printer lab1Printer = new Lab1Printer( scheme.getEnvironment().getLogger() );
        lab1Printer.print();
    }
}

View IL Code