psak, lab2, v3 | C# Online Compiler

psak, lab2, v3 by Anonymous

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

public interface IEvent
{
}

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(
			Adder _adder
		,	int _prevNumber
		,	int _numberToAdd
		,	int _newNumber
		,	bool _overflow
	)
	{
		m_adder = _adder;
		m_prevNumber = _prevNumber;
		m_numberToAdd = _numberToAdd;
		m_newNumber = _newNumber;
		m_overflow = _overflow;
	}

	public Adder m_adder;
	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 )
		{
			SteppingAdderActivation steppingAdderActivation =
				currentEvent as SteppingAdderActivation;
			
			AndGateActivation andGateActivation =
				currentEvent as AndGateActivation;

			if ( (object)steppingAdderActivation != null )
			{
				print( steppingAdderActivation );
			}
			else if ( (object)andGateActivation != null )
			{
				print( andGateActivation );
			}
		}
	}
	
	private void print( SteppingAdderActivation _steppingAdderActivation )
	{
		StringBuilder sb = new StringBuilder();
		sb.AppendFormat(
				"{0} : {1} + {2} = {3}"
			,	_steppingAdderActivation.m_adder.getName()
			,	_steppingAdderActivation.m_prevNumber
			,	_steppingAdderActivation.m_step
			,	_steppingAdderActivation.m_newNumber
		);
		
		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_adder.getName()
			,	_andGateActivation.m_prevNumber
			,	_andGateActivation.m_numberToAdd
			,	_andGateActivation.m_newNumber
		);
		
		if ( overflow )
			sb.Append( " - overflow" );
		
		Console.WriteLine( sb.ToString() );
	}
	
	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();
	
	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
	:	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
	:	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_elements = new List< IElement >();
	}
	
	public void addElement( IElement _element )
	{
		m_elements.Add( _element );
	}
	
	public void addElementToActivate( IElement _element )
	{
		m_elementsToActivate.Add( _element );
	}
	
	public Environment getEnvironment()
	{
		return m_environment;
	}
	
	public void executeNImpetuses( int _number )
	{
		for ( int i = 0; i < _number; ++i )
		{
			nextTurn();
			execute();
		}
	}
	
	private void execute()
	{
		while ( true )
		{
			IElement element = findElementToExecute();
			if ( (object)element == null )
				return;
			
			execute( element );
		}
		/*
		foreach ( IElement element in m_elementsToActivate )
		{
			execute( element );
		}
		*/
	}
	
	private IElement findElementToExecute()
	{
		for ( int i = m_elementsToActivate.Count - 1; i >= 0; --i )
		{
			IElement element = m_elementsToActivate[ i ];
			if ( element.hasImpetus() )
				return element;
		}
		return null;
	}
	
	private void execute( IElement _element )
	{
		/*
		while ( _element.hasImpetus() )
		{
			_element.resetImpetus();
			_element.tryActivate( getEnvironment() );
		}
		*/
		
		if ( !_element.hasImpetus() )
			throw new Exception();
		
		_element.resetImpetus();
		_element.tryActivate( getEnvironment() );
	}
	
	private void nextTurn()
	{
		foreach ( IElement element in m_elementsToActivate )
		{
			element.nextTurn();
		}
	}
	
	private Environment m_environment;
	private List< IElement > m_elementsToActivate;
	private List< IElement > m_elements;
}

public class Program
{
	public static void Main()
	{
		XGenerator xGenerator = new XGenerator( "x" );
		
		int a = 4;
		int b = 5;
		int c = -15;
		int m = 13;
		
		int xMax = 10;
		/*
		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;
		
		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/*invertred*/, 2 );
		AndGate andBetweenRGHidden_CntSqrt = new AndGate( "&", rg_hidden, cntSqrt );
		AndGate andBetweenCntRes_CntSqrt = new AndGate( "&", cntRes, cntSqrt, true/*inverted*/, 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();
		Console.WriteLine( "y = {0}", y );
		
		scheme.getEnvironment().getLogger().print();
		
		Console.WriteLine("Hello World");
	}
}

​x
 
using System;
using System.Collections.Generic;
using System.Text;
​
public interface IEvent
{
}
​
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(
            Adder _adder
        ,   int _prevNumber
        ,   int _numberToAdd
        ,   int _newNumber
        ,   bool _overflow
    )
    {
        m_adder = _adder;
        m_prevNumber = _prevNumber;
        m_numberToAdd = _numberToAdd;
        m_newNumber = _newNumber;
        m_overflow = _overflow;
    }
​
    public Adder m_adder;
    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 )
        {
            SteppingAdderActivation steppingAdderActivation =
                currentEvent as SteppingAdderActivation;
            
            AndGateActivation andGateActivation =
                currentEvent as AndGateActivation;
​
            if ( (object)steppingAdderActivation != null )
            {
                print( steppingAdderActivation );
            }
            else if ( (object)andGateActivation != null )
            {
                print( andGateActivation );
            }
        }
    }
    
    private void print( SteppingAdderActivation _steppingAdderActivation )
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendFormat(
                "{0} : {1} + {2} = {3}"
            ,   _steppingAdderActivation.m_adder.getName()
            ,   _steppingAdderActivation.m_prevNumber
            ,   _steppingAdderActivation.m_step
            ,   _steppingAdderActivation.m_newNumber
        );
        
        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_adder.getName()
            ,   _andGateActivation.m_prevNumber
            ,   _andGateActivation.m_numberToAdd
            ,   _andGateActivation.m_newNumber
        );
        
        if ( overflow )
            sb.Append( " - overflow" );
        
        Console.WriteLine( sb.ToString() );
    }
    
    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();
    
    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
    :   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
    :   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_elements = new List< IElement >();
    }
    
    public void addElement( IElement _element )
    {
        m_elements.Add( _element );
    }
    
    public void addElementToActivate( IElement _element )
    {
        m_elementsToActivate.Add( _element );
    }
    
    public Environment getEnvironment()
    {
        return m_environment;
    }
    
    public void executeNImpetuses( int _number )
    {
        for ( int i = 0; i < _number; ++i )
        {
            nextTurn();
            execute();
        }
    }
    
    private void execute()
    {
        while ( true )
        {
            IElement element = findElementToExecute();
            if ( (object)element == null )
                return;
            
            execute( element );
        }
        /*
        foreach ( IElement element in m_elementsToActivate )
        {
            execute( element );
        }
        */
    }
    
    private IElement findElementToExecute()
    {
        for ( int i = m_elementsToActivate.Count - 1; i >= 0; --i )
        {
            IElement element = m_elementsToActivate[ i ];
            if ( element.hasImpetus() )
                return element;
        }
        return null;
    }
    
    private void execute( IElement _element )
    {
        /*
        while ( _element.hasImpetus() )
        {
            _element.resetImpetus();
            _element.tryActivate( getEnvironment() );
        }
        */
        
        if ( !_element.hasImpetus() )
            throw new Exception();
        
        _element.resetImpetus();
        _element.tryActivate( getEnvironment() );
    }
    
    private void nextTurn()
    {
        foreach ( IElement element in m_elementsToActivate )
        {
            element.nextTurn();
        }
    }
    
    private Environment m_environment;
    private List< IElement > m_elementsToActivate;
    private List< IElement > m_elements;
}
​
public class Program
{
    public static void Main()
    {
        XGenerator xGenerator = new XGenerator( "x" );
        
        int a = 4;
        int b = 5;
        int c = -15;
        int m = 13;
        
        int xMax = 10;
        /*
        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;
        
        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/*invertred*/, 2 );
        AndGate andBetweenRGHidden_CntSqrt = new AndGate( "&", rg_hidden, cntSqrt );
        AndGate andBetweenCntRes_CntSqrt = new AndGate( "&", cntRes, cntSqrt, true/*inverted*/, 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();
        Console.WriteLine( "y = {0}", y );
        
        scheme.getEnvironment().getLogger().print();
        
        Console.WriteLine("Hello World");
    }
}

View IL Code