tpsks lab4, new soft | C# Online Compiler

tpsks lab4, new soft by Anonymous

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

public class Percentron
{
	public const int SNumber = 16;
	
	public const int SNumber_p = SNumber + 1;
	
	public const int ANumber = 10;
	
	public const int ANumber_p = ANumber + 1;
	
	public const int letterNumber = 2;
	
	public const int letterNumber_p = letterNumber + 1;
	
	public const double step = 0.1;
	
	public Percentron()
	{
		//m_S = new int[ SNumber_p ];
		m_R = new double [ ANumber_p ];
		m_w = new double [ ANumber_p, SNumber_p ];
		m_letter1 = new bool [ SNumber_p ];
		m_letter2 = new bool [ SNumber_p ];
		
		initLetters();
		initS();
		initW();
		
		m_letterToA_Input = new double[ letterNumber_p, ANumber_p ];
		initLetterToA_Input();
		
		initOA();
		initOR();
		
		//m_OA = 3.5;
		//m_OR = 1.7;
		
		m_tempWToT = new List< double[] >();
	
		m_UInLetter1ToT = new List< double >();
		m_UInLetter2ToT = new List< double >();
		
		m_isFirsts = new List< bool >();
		
		initUInLetterToT();
	}
	
	private void initS()
	{
		double[] temp = new double[] { 0.0,    0.2,    0.3,    0.8,    0.4,    0.3,    0.1,    0.4,    0.8,    0.3,    0.7 };

		for ( int i = 1; i < ANumber_p; ++i )
		{
			m_R[ i ] = temp[ i ];
		}
	}
	
	private void initW()
	{
		double [] temp1 = new double[] { 0.0,    0.8,    0.2,    0.7,    0.7,    0.3,    0.5,    0.5,    0.5,    0.3,    0.3,    0.3,    0.1,    0.7,    0.7,    0.5,    0.7 };
double [] temp2 = new double[] { 0.0,    0.6,    0.7,    0.1,    0.4,    0.4,    0.7,    0.8,    0.6,    0.3,    0.1,    0.3,    0.8,    0.4,    0.5,    0.1,    0.1 };
double [] temp3 = new double[] { 0.0,    0.1,    0.3,    0.7,    0.4,    0.7,    0.7,    0.2,    0.4,    0.2,    0.5,    0.1,    0.4,    0.7,    0.5,    0.4,    0.3 };
double [] temp4 = new double[] { 0.0,    0.2,    0.6,    0.6,    0.7,    0.8,    0.3,    0.3,    0.2,    0.2,    0.2,    0.5,    0.2,    0.3,    0.6,    0.2,    0.6 };
double [] temp5 = new double[] { 0.0,    0.2,    0.2,    0.8,    0.4,    0.8,    0.1,    0.8,    0.8,    0.6,    0.5,    0.2,    0.7,    0.7,    0.5,    0.8,    0.7 };
double [] temp6 = new double[] { 0.0,    0.6,    0.1,    0.7,    0.6,    0.8,    0.3,    0.2,    0.7,    0.8,    0.6,    0.2,    0.5,    0.3,    0.8,    0.2,    0.5 };
double [] temp7 = new double[] { 0.0,    0.4,    0.4,    0.3,    0.5,    0.5,    0.1,    0.3,    0.1,    0.6,    0.6,    0.1,    0.3,    0.1,    0.5,    0.4,    0.6 };
double [] temp8 = new double[] { 0.0,    0.3,    0.6,    0.4,    0.3,    0.7,    0.4,    0.6,    0.8,    0.1,    0.2,    0.4,    0.3,    0.7,    0.3,    0.5,    0.7 };
double [] temp9 = new double[] { 0.0,    0.4,    0.6,    0.3,    0.3,    0.2,    0.3,    0.3,    0.6,    0.6,    0.6,    0.8,    0.2,    0.2,    0.7,    0.6,    0.3 };
double [] temp10 = new double[] { 0.0,    0.3,    0.5,    0.3,    0.6,    0.4,    0.8,    0.6,    0.8,    0.6,    0.4,    0.4,    0.3,    0.5,    0.1,    0.2,    0.4 };


		copy( temp1, m_w, 1 );
		copy( temp2, m_w, 2 );
		copy( temp3, m_w, 3 );
		copy( temp4, m_w, 4 );
		copy( temp5, m_w, 5 );
		copy( temp6, m_w, 6 );
		copy( temp7, m_w, 7 );
		copy( temp8, m_w, 8 );
		copy( temp9, m_w, 9 );
		copy( temp10, m_w, 10 );
	}
	
	private void initOA()
	{
		AOChooser aoChooser = new AOChooser( this );
		aoChooser.execute();
	}
	
	private void initOR()
	{
		double[] temp = new double[ ANumber_p ];
		for ( int i = 1; i < ANumber_p; ++i )
		{
			temp[ i ] = m_R[ i ];
		}
		
		KeyValuePair< double, double > inRs = calculateInR( temp );
		
		double sum = inRs.Key + inRs.Value;
		m_OR = sum / 2.0;
	}
	
	private void copy( double[] _a, double[,] _target, int _line )
	{
		int length = _a.Length;
		for ( int i = 1; i < length; ++i )
		{
			_target[ _line, i ] = _a[ i ]; 
		}
	}
	
	private void initLetters()
	{
		/*
		m_letter1[ 1 ] = true;
		m_letter1[ 5 ] = true;
		m_letter1[ 6 ] = true;
		m_letter1[ 7 ] = true;
		m_letter1[ 8 ] = true;
		m_letter1[ 9 ] = true;
		m_letter1[ 10 ] = true;
		m_letter1[ 11 ] = true;
		m_letter1[ 15 ] = true;
		
		
		m_letter2[ 1 ] = true;
		m_letter2[ 5 ] = true;
		m_letter2[ 6 ] = true;
		m_letter2[ 7 ] = true;
		m_letter2[ 9 ] = true;
		m_letter2[ 10 ] = true;
		m_letter2[ 11 ] = true;
		m_letter2[ 13 ] = true;
		m_letter2[ 15 ] = true;
		*/
		
		m_letter1[ 1 ] = true;
		m_letter1[ 3 ] = true;
		m_letter1[ 4 ] = true;
		m_letter1[ 5 ] = true;
		m_letter1[ 6 ] = true;
		m_letter1[ 9 ] = true;
		m_letter1[ 10 ] = true;
		m_letter1[ 13 ] = true;
		m_letter1[ 15 ] = true;
		m_letter1[ 16 ] = true;
		
		
		m_letter2[ 1 ] = true;
		m_letter2[ 4 ] = true;
		m_letter2[ 5 ] = true;
		m_letter2[ 8 ] = true;
		m_letter2[ 9 ] = true;
		m_letter2[ 10 ] = true;
		m_letter2[ 11 ] = true;
		m_letter2[ 12 ] = true;
		m_letter2[ 13 ] = true;
		m_letter2[ 16 ] = true;
		
	}
	
	private void initLetterToA_Input()
	{
		int letter;
		
		letter = 1;
		for ( int i = 1; i < ANumber_p; ++i )
		{
			double Sum = 0.0;
			for ( int j = 1; j < SNumber_p; ++j )
			{
				Sum += toDouble( m_letter1[ j ] ) * m_w[ i, j ] ;
			}
			m_letterToA_Input[ letter, i ] = Sum;
		}
		
		letter = 2;
		for ( int i = 1; i < ANumber_p; ++i )
		{
			double Sum = 0.0;
			for ( int j = 1; j < SNumber_p; ++j )
			{
				Sum += toDouble( m_letter2[ j ] ) * m_w[ i, j ] ;
			}
			m_letterToA_Input[ letter, i ] = Sum;
		}
	}
	
	private void initUInLetterToT()
	{
		UtoTExecutor executor = new UtoTExecutor( this );
		executor.execute();
		/*
		int iterations = 30;
		
		double[] temp = new double[ ANumber_p ];
		for ( int i = 1; i < ANumber_p; ++i )
		{
			temp[ i ] = m_R[ i ];
		}
		
		KeyValuePair< double, double > inRs = calculateInR( temp );
		
		m_tempWToT.Add( temp );
		m_UInLetter1ToT.Add( inRs.Key );
		m_UInLetter2ToT.Add( inRs.Value );
		
		m_isFirsts.Add( true );
		
		
		for ( int i = 0; i < iterations; ++i )
		{
			if (
					isSufficientR( m_UInLetter1ToT[ m_UInLetter1ToT.Count - 1 ], true )
				&&	isSufficientR( m_UInLetter2ToT[ m_UInLetter1ToT.Count - 1 ], false )
			)
				return;
			
			double[] temp2 = new double[ ANumber_p ];
			for ( int j = 1; j < ANumber_p; ++j )
			{
				temp2[ j ] = m_tempWToT[ i ][ j ];
			}
			
			bool calculateFirstLetter = i % 2 == 0;
			calculateFirstLetter |= isSufficientR( m_UInLetter2ToT[ m_UInLetter2ToT.Count - 1 ], false );
			calculateFirstLetter &= !isSufficientR( m_UInLetter1ToT[ m_UInLetter1ToT.Count - 1 ], true );
			
			m_isFirsts.Add( calculateFirstLetter );
			
			if ( calculateFirstLetter )
			{
			if ( !isSufficientR( m_UInLetter1ToT[ m_UInLetter1ToT.Count - 1 ], true ) )
			{
				for ( int j = 1; j < ANumber_p; ++j )
				{
					if ( isOpenA( m_letterToA_Input[ 1, j ] ) )
						temp2[ j ] = changeWithRange( temp2[ j ], step, true );
				}
			}
			}
			else
			{
			if ( !isSufficientR( m_UInLetter2ToT[ m_UInLetter2ToT.Count - 1 ], false ) )
			{
				for ( int j = 1; j < ANumber_p; ++j )
				{
					if ( isOpenA( m_letterToA_Input[ 2, j ] ) )
						temp2[ j ] = changeWithRange( temp2[ j ], step, false );
				}
			}
			}
			
			inRs = calculateInR( temp2 );
		
			m_tempWToT.Add( temp2 );
			m_UInLetter1ToT.Add( inRs.Key );
			m_UInLetter2ToT.Add( inRs.Value );
		}
		*/
	}
	
	
	
	
	public static double toDouble( bool _v )
	{
		return ( _v ) ?
				1.0
			:	0.0
		;
	}
	
	public KeyValuePair< double, double > calculateInR( double [] _w )
	{
		double inR1 = 0.0;
		double inR2 = 0.0;
		for ( int i = 1; i < ANumber_p; ++i )
		{
			inR1 += toDouble( isOpenA( m_letterToA_Input[ 1, i ] ) ) * _w[ i ];
		}
		for ( int i = 1; i < ANumber_p; ++i )
		{
			inR2 += toDouble( isOpenA( m_letterToA_Input[ 2, i ] ) ) * _w[ i ];
		}
		return new KeyValuePair< double, double >( inR1, inR2 );
	}
	
	public bool isOpenA( double _v )
	{
		return _v >= m_OA;
	}
	
	public bool isSufficientR( double _r, bool _isFirstLetter )
	{
		if ( _isFirstLetter )
			return _r < m_OR;
		else
			return _r >= m_OR;
	}
	public double[] m_R;
	
	//private int[] m_S;
	
	public double [,] m_w;
	
	public bool[] m_letter1, m_letter2;
	
	public double [,] m_letterToA_Input;
	
	public double m_OA;
	
	public double m_OR;
	
	public List< double[] > m_tempWToT;
	
	public List< double > m_UInLetter1ToT;
	public List< double > m_UInLetter2ToT;
	
	public List< bool > m_isFirsts;
}

public class Printer
{
	public Printer( Percentron _percentron )
	{
		m_percentron = _percentron;
	}
	
	public void printW()
	{
		
		ReportPrinter reportPrinter = new ReportPrinter( Percentron.ANumber_p, Percentron.SNumber_p );
		for ( int i = 1; i < Percentron.SNumber_p; ++i )
		{
			StringBuilder sb = new StringBuilder();
			sb.AppendFormat( "S{0}", i );
			reportPrinter.m_data[ 0, i ] = sb.ToString();
		}
		
		for ( int i = 1; i < Percentron.ANumber_p; ++i )
		{
			reportPrinter.m_data[ i, 0 ] = "A" + i.ToString();
			for ( int j = 1; j < Percentron.SNumber_p; ++j )
			{
				reportPrinter.m_data[ i, j ] = m_percentron.m_w[ i, j ].ToString();
			}
		}
		reportPrinter.print();
		Console.Write( "\n" );
	}
	
	public void printLetterToA_Input()
	{
		ReportPrinter reportPrinter = new ReportPrinter( Percentron.letterNumber_p, Percentron.ANumber_p );
		for ( int i = 1; i < Percentron.ANumber_p; ++i )
		{
			reportPrinter.m_data[ 0, i ] = "A" + i;
		}
		
		for ( int i = 1; i < Percentron.letterNumber_p; ++i )
		{
			reportPrinter.m_data[ i, 0 ] = "letter" + i.ToString();
			for ( int j = 1; j < Percentron.ANumber_p; ++j )
			{
				reportPrinter.m_data[ i, j ] = m_percentron.m_letterToA_Input[ i, j ].ToString();
			}
		}
		reportPrinter.print();
		Console.Write( "\n" );
	}
	
	public void printUInLetterToT()
	{
		ReportPrinter reportPrinter = new ReportPrinter( Percentron.ANumber_p + 2, m_percentron.m_tempWToT.Count + 1 );
		for ( int i = 0; i < m_percentron.m_tempWToT.Count; ++i )
		{
			string letter = "";
			if ( i != 0 )
			{
				bool firstLetter = m_percentron.m_isFirsts[ i ];//isFirstLetter( i );
				letter = ( firstLetter ) ? "f" : "s" ;
			}
			
			int reportIndex = i + 1;
			reportPrinter.m_data[ 0, reportIndex ] = "t" + i.ToString() + letter;
		}
		
		for ( int i = 1; i < Percentron.ANumber_p; ++i )
		{
			reportPrinter.m_data[ i, 0 ] = "w" + i.ToString();
		}
		reportPrinter.m_data[ Percentron.ANumber_p + 0, 0 ] = "UR letter1";
		reportPrinter.m_data[ Percentron.ANumber_p + 1, 0 ] = "UR letter2";
		
		for ( int i = 0; i < m_percentron.m_tempWToT.Count; ++i )
		{
			int reportIndex = i + 1;
			for ( int j = 1; j < Percentron.ANumber_p; ++j )
			{
				bool minusSymbol = false;
				if ( i != 0 )
				{
					bool isFirstLetterV = m_percentron.m_isFirsts[ i ];//isFirstLetter( i );
					int letter = ( isFirstLetterV )
						?	1
						:	2
					;
					if ( !m_percentron.isOpenA( m_percentron.m_letterToA_Input[ letter, j ] ) )
						minusSymbol = true;
					
				}
					
				if ( minusSymbol )
					reportPrinter.m_data[ j, reportIndex ] = "-";
				else
					reportPrinter.m_data[ j, reportIndex ] = m_percentron.m_tempWToT[ i ][ j ].ToString();
			}
		}
		
		for ( int i = 0; i < m_percentron.m_tempWToT.Count; ++i )
		{
			int reportIndex = i + 1;
			reportPrinter.m_data[ Percentron.ANumber_p + 0, reportIndex ] = m_percentron.m_UInLetter1ToT[ i ].ToString();
			reportPrinter.m_data[ Percentron.ANumber_p + 1, reportIndex ] = m_percentron.m_UInLetter2ToT[ i ].ToString();
		}
		
		reportPrinter.print();
		Console.Write( "\n" );
	}
	/*
	public bool isFirstLetter( int _i )
	{
		return _i % 2 == 1;
	}
	*/
	public void printOA()
	{
		Console.WriteLine( "AO = {0}", m_percentron.m_OA );
	}
	
	public void printOR()
	{
		Console.WriteLine( "OR = {0}", m_percentron.m_OR );
	}
	
	private Percentron m_percentron;
}

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 AOChooser
{
	public AOChooser( Percentron _percentron )
	{
		m_percentron = _percentron;
	}
	
	public void execute()
	{
		HashSet< double > variants = new HashSet< double >();
		
		int allNeuronsA = Percentron.letterNumber * Percentron.ANumber;
		for ( int i = 1; i < Percentron.letterNumber_p; ++i )
		{
			for ( int j = 1; j < Percentron.ANumber_p; ++j )
			{
				variants.Add( m_percentron.m_letterToA_Input[ i, j ] );
			}
		}
		
		int optimalNeuronsA = allNeuronsA * 7 / 10;
		
		//Console.WriteLine( "allNeuronsA = {0}", allNeuronsA );
		//Console.WriteLine( "optimalNeuronsA = {0}", optimalNeuronsA );
		
		double min = 0.1 / 2.0;
		
		int maxGoodActiveNeuronsA = 0;
		int minDiff = allNeuronsA;
		//int maxActiveNeuronsA = 0;
		//double currentVariant = 0.0;
		double currentVariant = 0.0 ;
		
		foreach ( double variant in variants )
		{
			double variant_p = variant + min;
			//int letter1Count = 0;
			//int letter2Count = 0;
			
			
			int activeNeuronsCount = 0;
			int goodActiveNeuronsCount = 0;
			
			int tempGoodActiveNeuronsCount1 = 0;
			int tempGoodActiveNeuronsCount2 = 0;
			
			for ( int i = 1; i < Percentron.ANumber_p; ++i )
			{
				int letter;
				letter = 1;
				
				bool active1 = m_percentron.m_letterToA_Input[ letter, i ] >= variant_p;
				
				letter = 2;
				
				bool active2 = m_percentron.m_letterToA_Input[ letter, i ] >= variant_p;
				
				if ( active1 )
					++activeNeuronsCount;
				if ( active2 )
					++activeNeuronsCount;
				
				if ( active1 && ( !active2 ) )
					++tempGoodActiveNeuronsCount1;
				
				if ( ( !active1 ) && active2 )
					++tempGoodActiveNeuronsCount2;
				
				//if ( active1 ^ active2 )
				//	++goodActiveNeuronsCount;
			}
			
			
			goodActiveNeuronsCount =
				Math.Min( tempGoodActiveNeuronsCount1, tempGoodActiveNeuronsCount2 );
				
			int diff = (int)Math.Abs( (double)optimalNeuronsA - activeNeuronsCount );
			//Console.WriteLine( "diff = {0}", diff );
			
			//int letter;
			//letter = 1;
			/*
			for ( int i = 1; i < Percentron.ANumber_p; ++i )
			{
				if ( m_percentron.m_letterToA_Input[ letter, i ] >= variant_p )
					++letter1Count;
			}
			
			letter = 2;
			
			for ( int i = 1; i < Percentron.ANumber_p; ++i )
			{
				if ( m_percentron.m_letterToA_Input[ letter, i ] >= variant_p )
					++letter2Count;
			}
			*/
			if ( goodActiveNeuronsCount > maxGoodActiveNeuronsA )
			{
				maxGoodActiveNeuronsA = goodActiveNeuronsCount;
				minDiff = diff;
				//maxActiveNeuronsA = activeNeuronsCount;
				currentVariant = variant_p;
			}
			
			else if ( goodActiveNeuronsCount == 0 )
			{
				if ( minDiff > diff  )
				{
					maxGoodActiveNeuronsA = goodActiveNeuronsCount;
					minDiff = diff;
					currentVariant = variant_p;
				}
			}
		}
		
		if ( currentVariant == 0.0 )
			throw new Exception();
		
		Console.WriteLine( "maxGoodActiveNeuronsA = {0}", maxGoodActiveNeuronsA );
		m_percentron.m_OA = currentVariant;
	}
	
	Percentron m_percentron;
}

public class UtoTExecutor
{
	public UtoTExecutor( Percentron _percentron )
	{
		m_percentron = _percentron;
	}
	
	public void execute()
	{
		init();
		
		int iters = 30;
		for ( int i = 0; i < iters; ++i )
		{
			if ( shouldStop() )
				return;
			
			adjustLetter();
			makeIteration();
			switchLetter();
		}
	}
	
	public void init()
	{
		double[] temp = new double[ Percentron.ANumber_p ];
		for ( int i = 1; i < Percentron.ANumber_p; ++i )
		{
			temp[ i ] = m_percentron.m_R[ i ];
		}
		
		KeyValuePair< double, double > inRs = m_percentron.calculateInR( temp );
		
		m_percentron.m_tempWToT.Add( temp );
		m_percentron.m_UInLetter1ToT.Add( inRs.Key );
		m_percentron.m_UInLetter2ToT.Add( inRs.Value );
		
		m_firstLetter = true;
		m_percentron.m_isFirsts.Add( m_firstLetter );
	}
	
	public bool shouldStop()
	{
		return isSufficientR( false ) && isSufficientR( true );
	}
	
	public void makeIteration()
	{
		double[] temp = new double[ Percentron.ANumber_p ];
		for ( int i = 1; i < Percentron.ANumber_p; ++i )
		{
			temp[ i ] = m_percentron.m_tempWToT[ m_percentron.m_tempWToT.Count - 1 ][ i ];
		}
		
		m_percentron.m_isFirsts.Add( m_firstLetter );
		for ( int j = 1; j < Percentron.ANumber_p; ++j )
		{
			if ( m_percentron.isOpenA( m_percentron.m_letterToA_Input[ getLetter(), j ] ) )
				temp[ j ] = changeWithRange( temp[ j ], Percentron.step, m_firstLetter );
		}
		
		KeyValuePair< double, double > inRs = m_percentron.calculateInR( temp );
		
		m_percentron.m_tempWToT.Add( temp );
		m_percentron.m_UInLetter1ToT.Add( inRs.Key );
		m_percentron.m_UInLetter2ToT.Add( inRs.Value );
	}
	
	public void adjustLetter()
	{
		if ( isSufficientR() )
			switchLetter();
	}
	
	public void switchLetter()
	{
		m_firstLetter = !m_firstLetter;
	}
	
	
	private double changeWithRange( double _n, double _step, bool _isFirstLetter )
	{
		double difference = m_percentron.m_OR - getUR();
		
		bool shouldIncrease = difference > 0.0;
			
		
		if ( shouldIncrease )
			_n += _step;
		else
			_n -= _step;
		
		if ( _n < 0.0 )
			return 0.0;
		else if ( _n > 1.0 )
			return 1.0;
		
		return _n;
	}
	
	public bool isSufficientR( bool _isFirstLetter )
	{
		return _isFirstLetter
			?	m_percentron.isSufficientR( m_percentron.m_UInLetter1ToT[ m_percentron.m_UInLetter1ToT.Count - 1 ], _isFirstLetter )
			:	m_percentron.isSufficientR( m_percentron.m_UInLetter2ToT[ m_percentron.m_UInLetter2ToT.Count - 1 ], _isFirstLetter )
		;
	}
	
	public bool isSufficientR()
	{
		return isSufficientR( m_firstLetter );
	}
	
	public int getLetter()
	{
		return m_firstLetter
			?	1
			:	2
		;
	}
	
	public double getUR()
	{
		return m_firstLetter
			?	m_percentron.m_UInLetter1ToT[ m_percentron.m_UInLetter1ToT.Count - 1 ]
			:	m_percentron.m_UInLetter2ToT[ m_percentron.m_UInLetter2ToT.Count - 1 ]
		;
	}
		
	private Percentron m_percentron;
	
	private bool m_firstLetter;
}


public class Program
{
	public static void Main()
	{
		Percentron percentron = new Percentron();
		Printer printer = new Printer( percentron );
		printer.printW();
		printer.printLetterToA_Input();
		printer.printOA();
		printer.printOR();
		printer.printUInLetterToT();
		//printer.printUInLetterToT_y();
		
		Console.WriteLine("Hello World");
	}
}

​x
 
using System;
using System.Collections.Generic;
using System.Text;
​
public class Percentron
{
    public const int SNumber = 16;
    
    public const int SNumber_p = SNumber + 1;
    
    public const int ANumber = 10;
    
    public const int ANumber_p = ANumber + 1;
    
    public const int letterNumber = 2;
    
    public const int letterNumber_p = letterNumber + 1;
    
    public const double step = 0.1;
    
    public Percentron()
    {
        //m_S = new int[ SNumber_p ];
        m_R = new double [ ANumber_p ];
        m_w = new double [ ANumber_p, SNumber_p ];
        m_letter1 = new bool [ SNumber_p ];
        m_letter2 = new bool [ SNumber_p ];
        
        initLetters();
        initS();
        initW();
        
        m_letterToA_Input = new double[ letterNumber_p, ANumber_p ];
        initLetterToA_Input();
        
        initOA();
        initOR();
        
        //m_OA = 3.5;
        //m_OR = 1.7;
        
        m_tempWToT = new List< double[] >();
    
        m_UInLetter1ToT = new List< double >();
        m_UInLetter2ToT = new List< double >();
        
        m_isFirsts = new List< bool >();
        
        initUInLetterToT();
    }
    
    private void initS()
    {
        double[] temp = new double[] { 0.0,    0.2,    0.3,    0.8,    0.4,    0.3,    0.1,    0.4,    0.8,    0.3,    0.7 };
​
        for ( int i = 1; i < ANumber_p; ++i )
        {
            m_R[ i ] = temp[ i ];
        }
    }
    
    private void initW()
    {
        double [] temp1 = new double[] { 0.0,    0.8,    0.2,    0.7,    0.7,    0.3,    0.5,    0.5,    0.5,    0.3,    0.3,    0.3,    0.1,    0.7,    0.7,    0.5,    0.7 };
double [] temp2 = new double[] { 0.0,    0.6,    0.7,    0.1,    0.4,    0.4,    0.7,    0.8,    0.6,    0.3,    0.1,    0.3,    0.8,    0.4,    0.5,    0.1,    0.1 };
double [] temp3 = new double[] { 0.0,    0.1,    0.3,    0.7,    0.4,    0.7,    0.7,    0.2,    0.4,    0.2,    0.5,    0.1,    0.4,    0.7,    0.5,    0.4,    0.3 };
double [] temp4 = new double[] { 0.0,    0.2,    0.6,    0.6,    0.7,    0.8,    0.3,    0.3,    0.2,    0.2,    0.2,    0.5,    0.2,    0.3,    0.6,    0.2,    0.6 };
double [] temp5 = new double[] { 0.0,    0.2,    0.2,    0.8,    0.4,    0.8,    0.1,    0.8,    0.8,    0.6,    0.5,    0.2,    0.7,    0.7,    0.5,    0.8,    0.7 };
double [] temp6 = new double[] { 0.0,    0.6,    0.1,    0.7,    0.6,    0.8,    0.3,    0.2,    0.7,    0.8,    0.6,    0.2,    0.5,    0.3,    0.8,    0.2,    0.5 };
double [] temp7 = new double[] { 0.0,    0.4,    0.4,    0.3,    0.5,    0.5,    0.1,    0.3,    0.1,    0.6,    0.6,    0.1,    0.3,    0.1,    0.5,    0.4,    0.6 };
double [] temp8 = new double[] { 0.0,    0.3,    0.6,    0.4,    0.3,    0.7,    0.4,    0.6,    0.8,    0.1,    0.2,    0.4,    0.3,    0.7,    0.3,    0.5,    0.7 };
double [] temp9 = new double[] { 0.0,    0.4,    0.6,    0.3,    0.3,    0.2,    0.3,    0.3,    0.6,    0.6,    0.6,    0.8,    0.2,    0.2,    0.7,    0.6,    0.3 };
double [] temp10 = new double[] { 0.0,    0.3,    0.5,    0.3,    0.6,    0.4,    0.8,    0.6,    0.8,    0.6,    0.4,    0.4,    0.3,    0.5,    0.1,    0.2,    0.4 };
​
​
        copy( temp1, m_w, 1 );
        copy( temp2, m_w, 2 );
        copy( temp3, m_w, 3 );
        copy( temp4, m_w, 4 );
        copy( temp5, m_w, 5 );
        copy( temp6, m_w, 6 );
        copy( temp7, m_w, 7 );
        copy( temp8, m_w, 8 );
        copy( temp9, m_w, 9 );
        copy( temp10, m_w, 10 );
    }
    
    private void initOA()
    {
        AOChooser aoChooser = new AOChooser( this );
        aoChooser.execute();
    }
    
    private void initOR()
    {
        double[] temp = new double[ ANumber_p ];
        for ( int i = 1; i < ANumber_p; ++i )
        {
            temp[ i ] = m_R[ i ];
        }
        
        KeyValuePair< double, double > inRs = calculateInR( temp );
        
        double sum = inRs.Key + inRs.Value;
        m_OR = sum / 2.0;
    }
    
    private void copy( double[] _a, double[,] _target, int _line )
    {
        int length = _a.Length;
        for ( int i = 1; i < length; ++i )
        {
            _target[ _line, i ] = _a[ i ]; 
        }
    }
    
    private void initLetters()
    {
        /*
        m_letter1[ 1 ] = true;
        m_letter1[ 5 ] = true;
        m_letter1[ 6 ] = true;
        m_letter1[ 7 ] = true;
        m_letter1[ 8 ] = true;
        m_letter1[ 9 ] = true;
        m_letter1[ 10 ] = true;
        m_letter1[ 11 ] = true;
        m_letter1[ 15 ] = true;
        
        
        m_letter2[ 1 ] = true;
        m_letter2[ 5 ] = true;
        m_letter2[ 6 ] = true;
        m_letter2[ 7 ] = true;
        m_letter2[ 9 ] = true;
        m_letter2[ 10 ] = true;
        m_letter2[ 11 ] = true;
        m_letter2[ 13 ] = true;
        m_letter2[ 15 ] = true;
        */
        
        m_letter1[ 1 ] = true;
        m_letter1[ 3 ] = true;
        m_letter1[ 4 ] = true;
        m_letter1[ 5 ] = true;
        m_letter1[ 6 ] = true;
        m_letter1[ 9 ] = true;
        m_letter1[ 10 ] = true;
        m_letter1[ 13 ] = true;
        m_letter1[ 15 ] = true;
        m_letter1[ 16 ] = true;
        
        
        m_letter2[ 1 ] = true;
        m_letter2[ 4 ] = true;
        m_letter2[ 5 ] = true;
        m_letter2[ 8 ] = true;
        m_letter2[ 9 ] = true;
        m_letter2[ 10 ] = true;
        m_letter2[ 11 ] = true;
        m_letter2[ 12 ] = true;
        m_letter2[ 13 ] = true;
        m_letter2[ 16 ] = true;
        
    }
    
    private void initLetterToA_Input()
    {
        int letter;
        
        letter = 1;
        for ( int i = 1; i < ANumber_p; ++i )
        {
            double Sum = 0.0;
            for ( int j = 1; j < SNumber_p; ++j )
            {
                Sum += toDouble( m_letter1[ j ] ) * m_w[ i, j ] ;
            }
            m_letterToA_Input[ letter, i ] = Sum;
        }
        
        letter = 2;
        for ( int i = 1; i < ANumber_p; ++i )
        {
            double Sum = 0.0;
            for ( int j = 1; j < SNumber_p; ++j )
            {
                Sum += toDouble( m_letter2[ j ] ) * m_w[ i, j ] ;
            }
            m_letterToA_Input[ letter, i ] = Sum;
        }
    }
    
    private void initUInLetterToT()
    {
        UtoTExecutor executor = new UtoTExecutor( this );
        executor.execute();
        /*
        int iterations = 30;
        
        double[] temp = new double[ ANumber_p ];
        for ( int i = 1; i < ANumber_p; ++i )
        {
            temp[ i ] = m_R[ i ];
        }
        
        KeyValuePair< double, double > inRs = calculateInR( temp );
        
        m_tempWToT.Add( temp );
        m_UInLetter1ToT.Add( inRs.Key );
        m_UInLetter2ToT.Add( inRs.Value );
        
        m_isFirsts.Add( true );
        
        
        for ( int i = 0; i < iterations; ++i )
        {
            if (
                    isSufficientR( m_UInLetter1ToT[ m_UInLetter1ToT.Count - 1 ], true )
                &&  isSufficientR( m_UInLetter2ToT[ m_UInLetter1ToT.Count - 1 ], false )
            )
                return;
            
            double[] temp2 = new double[ ANumber_p ];
            for ( int j = 1; j < ANumber_p; ++j )
            {
                temp2[ j ] = m_tempWToT[ i ][ j ];
            }
            
            bool calculateFirstLetter = i % 2 == 0;
            calculateFirstLetter |= isSufficientR( m_UInLetter2ToT[ m_UInLetter2ToT.Count - 1 ], false );
            calculateFirstLetter &= !isSufficientR( m_UInLetter1ToT[ m_UInLetter1ToT.Count - 1 ], true );
            
            m_isFirsts.Add( calculateFirstLetter );
            
            if ( calculateFirstLetter )
            {
            if ( !isSufficientR( m_UInLetter1ToT[ m_UInLetter1ToT.Count - 1 ], true ) )
            {
                for ( int j = 1; j < ANumber_p; ++j )
                {
                    if ( isOpenA( m_letterToA_Input[ 1, j ] ) )
                        temp2[ j ] = changeWithRange( temp2[ j ], step, true );
                }
            }
            }
            else
            {
            if ( !isSufficientR( m_UInLetter2ToT[ m_UInLetter2ToT.Count - 1 ], false ) )
            {
                for ( int j = 1; j < ANumber_p; ++j )
                {
                    if ( isOpenA( m_letterToA_Input[ 2, j ] ) )
                        temp2[ j ] = changeWithRange( temp2[ j ], step, false );
                }
            }
            }
            
            inRs = calculateInR( temp2 );
        
            m_tempWToT.Add( temp2 );
            m_UInLetter1ToT.Add( inRs.Key );
            m_UInLetter2ToT.Add( inRs.Value );
        }
        */
    }
    
    
    
    
    public static double toDouble( bool _v )
    {
        return ( _v ) ?
                1.0
            :   0.0
        ;
    }
    
    public KeyValuePair< double, double > calculateInR( double [] _w )
    {
        double inR1 = 0.0;
        double inR2 = 0.0;
        for ( int i = 1; i < ANumber_p; ++i )
        {
            inR1 += toDouble( isOpenA( m_letterToA_Input[ 1, i ] ) ) * _w[ i ];
        }
        for ( int i = 1; i < ANumber_p; ++i )
        {
            inR2 += toDouble( isOpenA( m_letterToA_Input[ 2, i ] ) ) * _w[ i ];
        }
        return new KeyValuePair< double, double >( inR1, inR2 );
    }
    
    public bool isOpenA( double _v )
    {
        return _v >= m_OA;
    }
    
    public bool isSufficientR( double _r, bool _isFirstLetter )
    {
        if ( _isFirstLetter )
            return _r < m_OR;
        else
            return _r >= m_OR;
    }
    public double[] m_R;
    
    //private int[] m_S;
    
    public double [,] m_w;
    
    public bool[] m_letter1, m_letter2;
    
    public double [,] m_letterToA_Input;
    
    public double m_OA;
    
    public double m_OR;
    
    public List< double[] > m_tempWToT;
    
    public List< double > m_UInLetter1ToT;
    public List< double > m_UInLetter2ToT;
    
    public List< bool > m_isFirsts;
}
​
public class Printer
{
    public Printer( Percentron _percentron )
    {
        m_percentron = _percentron;
    }
    
    public void printW()
    {
        
        ReportPrinter reportPrinter = new ReportPrinter( Percentron.ANumber_p, Percentron.SNumber_p );
        for ( int i = 1; i < Percentron.SNumber_p; ++i )
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat( "S{0}", i );
            reportPrinter.m_data[ 0, i ] = sb.ToString();
        }
        
        for ( int i = 1; i < Percentron.ANumber_p; ++i )
        {
            reportPrinter.m_data[ i, 0 ] = "A" + i.ToString();
            for ( int j = 1; j < Percentron.SNumber_p; ++j )
            {
                reportPrinter.m_data[ i, j ] = m_percentron.m_w[ i, j ].ToString();
            }
        }
        reportPrinter.print();
        Console.Write( "\n" );
    }
    
    public void printLetterToA_Input()
    {
        ReportPrinter reportPrinter = new ReportPrinter( Percentron.letterNumber_p, Percentron.ANumber_p );
        for ( int i = 1; i < Percentron.ANumber_p; ++i )
        {
            reportPrinter.m_data[ 0, i ] = "A" + i;
        }
        
        for ( int i = 1; i < Percentron.letterNumber_p; ++i )
        {
            reportPrinter.m_data[ i, 0 ] = "letter" + i.ToString();
            for ( int j = 1; j < Percentron.ANumber_p; ++j )
            {
                reportPrinter.m_data[ i, j ] = m_percentron.m_letterToA_Input[ i, j ].ToString();
            }
        }
        reportPrinter.print();
        Console.Write( "\n" );
    }
    
    public void printUInLetterToT()
    {
        ReportPrinter reportPrinter = new ReportPrinter( Percentron.ANumber_p + 2, m_percentron.m_tempWToT.Count + 1 );
        for ( int i = 0; i < m_percentron.m_tempWToT.Count; ++i )
        {
            string letter = "";
            if ( i != 0 )
            {
                bool firstLetter = m_percentron.m_isFirsts[ i ];//isFirstLetter( i );
                letter = ( firstLetter ) ? "f" : "s" ;
            }
            
            int reportIndex = i + 1;
            reportPrinter.m_data[ 0, reportIndex ] = "t" + i.ToString() + letter;
        }
        
        for ( int i = 1; i < Percentron.ANumber_p; ++i )
        {
            reportPrinter.m_data[ i, 0 ] = "w" + i.ToString();
        }
        reportPrinter.m_data[ Percentron.ANumber_p + 0, 0 ] = "UR letter1";
        reportPrinter.m_data[ Percentron.ANumber_p + 1, 0 ] = "UR letter2";
        
        for ( int i = 0; i < m_percentron.m_tempWToT.Count; ++i )
        {
            int reportIndex = i + 1;
            for ( int j = 1; j < Percentron.ANumber_p; ++j )
            {
                bool minusSymbol = false;
                if ( i != 0 )
                {
                    bool isFirstLetterV = m_percentron.m_isFirsts[ i ];//isFirstLetter( i );
                    int letter = ( isFirstLetterV )
                        ?   1
                        :   2
                    ;
                    if ( !m_percentron.isOpenA( m_percentron.m_letterToA_Input[ letter, j ] ) )
                        minusSymbol = true;
                    
                }
                    
                if ( minusSymbol )
                    reportPrinter.m_data[ j, reportIndex ] = "-";
                else
                    reportPrinter.m_data[ j, reportIndex ] = m_percentron.m_tempWToT[ i ][ j ].ToString();
            }
        }
        
        for ( int i = 0; i < m_percentron.m_tempWToT.Count; ++i )
        {
            int reportIndex = i + 1;
            reportPrinter.m_data[ Percentron.ANumber_p + 0, reportIndex ] = m_percentron.m_UInLetter1ToT[ i ].ToString();
            reportPrinter.m_data[ Percentron.ANumber_p + 1, reportIndex ] = m_percentron.m_UInLetter2ToT[ i ].ToString();
        }
        
        reportPrinter.print();
        Console.Write( "\n" );
    }
    /*
    public bool isFirstLetter( int _i )
    {
        return _i % 2 == 1;
    }
    */
    public void printOA()
    {
        Console.WriteLine( "AO = {0}", m_percentron.m_OA );
    }
    
    public void printOR()
    {
        Console.WriteLine( "OR = {0}", m_percentron.m_OR );
    }
    
    private Percentron m_percentron;
}
​
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 AOChooser
{
    public AOChooser( Percentron _percentron )
    {
        m_percentron = _percentron;
    }
    
    public void execute()
    {
        HashSet< double > variants = new HashSet< double >();
        
        int allNeuronsA = Percentron.letterNumber * Percentron.ANumber;
        for ( int i = 1; i < Percentron.letterNumber_p; ++i )
        {
            for ( int j = 1; j < Percentron.ANumber_p; ++j )
            {
                variants.Add( m_percentron.m_letterToA_Input[ i, j ] );
            }
        }
        
        int optimalNeuronsA = allNeuronsA * 7 / 10;
        
        //Console.WriteLine( "allNeuronsA = {0}", allNeuronsA );
        //Console.WriteLine( "optimalNeuronsA = {0}", optimalNeuronsA );
        
        double min = 0.1 / 2.0;
        
        int maxGoodActiveNeuronsA = 0;
        int minDiff = allNeuronsA;
        //int maxActiveNeuronsA = 0;
        //double currentVariant = 0.0;
        double currentVariant = 0.0 ;
        
        foreach ( double variant in variants )
        {
            double variant_p = variant + min;
            //int letter1Count = 0;
            //int letter2Count = 0;
            
            
            int activeNeuronsCount = 0;
            int goodActiveNeuronsCount = 0;
            
            int tempGoodActiveNeuronsCount1 = 0;
            int tempGoodActiveNeuronsCount2 = 0;
            
            for ( int i = 1; i < Percentron.ANumber_p; ++i )
            {
                int letter;
                letter = 1;
                
                bool active1 = m_percentron.m_letterToA_Input[ letter, i ] >= variant_p;
                
                letter = 2;
                
                bool active2 = m_percentron.m_letterToA_Input[ letter, i ] >= variant_p;
                
                if ( active1 )
                    ++activeNeuronsCount;
                if ( active2 )
                    ++activeNeuronsCount;
                
                if ( active1 && ( !active2 ) )
                    ++tempGoodActiveNeuronsCount1;
                
                if ( ( !active1 ) && active2 )
                    ++tempGoodActiveNeuronsCount2;
                
                //if ( active1 ^ active2 )
                //  ++goodActiveNeuronsCount;
            }
            
            
            goodActiveNeuronsCount =
                Math.Min( tempGoodActiveNeuronsCount1, tempGoodActiveNeuronsCount2 );
                
            int diff = (int)Math.Abs( (double)optimalNeuronsA - activeNeuronsCount );
            //Console.WriteLine( "diff = {0}", diff );
            
            //int letter;
            //letter = 1;
            /*
            for ( int i = 1; i < Percentron.ANumber_p; ++i )
            {
                if ( m_percentron.m_letterToA_Input[ letter, i ] >= variant_p )
                    ++letter1Count;
            }
            
            letter = 2;
            
            for ( int i = 1; i < Percentron.ANumber_p; ++i )
            {
                if ( m_percentron.m_letterToA_Input[ letter, i ] >= variant_p )
                    ++letter2Count;
            }
            */
            if ( goodActiveNeuronsCount > maxGoodActiveNeuronsA )
            {
                maxGoodActiveNeuronsA = goodActiveNeuronsCount;
                minDiff = diff;
                //maxActiveNeuronsA = activeNeuronsCount;
                currentVariant = variant_p;
            }
            
            else if ( goodActiveNeuronsCount == 0 )
            {
                if ( minDiff > diff  )
                {
                    maxGoodActiveNeuronsA = goodActiveNeuronsCount;
                    minDiff = diff;
                    currentVariant = variant_p;
                }
            }
        }
        
        if ( currentVariant == 0.0 )
            throw new Exception();
        
        Console.WriteLine( "maxGoodActiveNeuronsA = {0}", maxGoodActiveNeuronsA );
        m_percentron.m_OA = currentVariant;
    }
    
    Percentron m_percentron;
}
​
public class UtoTExecutor
{
    public UtoTExecutor( Percentron _percentron )
    {
        m_percentron = _percentron;
    }
    
    public void execute()
    {
        init();
        
        int iters = 30;
        for ( int i = 0; i < iters; ++i )
        {
            if ( shouldStop() )
                return;
            
            adjustLetter();
            makeIteration();
            switchLetter();
        }
    }
    
    public void init()
    {
        double[] temp = new double[ Percentron.ANumber_p ];
        for ( int i = 1; i < Percentron.ANumber_p; ++i )
        {
            temp[ i ] = m_percentron.m_R[ i ];
        }
        
        KeyValuePair< double, double > inRs = m_percentron.calculateInR( temp );
        
        m_percentron.m_tempWToT.Add( temp );
        m_percentron.m_UInLetter1ToT.Add( inRs.Key );
        m_percentron.m_UInLetter2ToT.Add( inRs.Value );
        
        m_firstLetter = true;
        m_percentron.m_isFirsts.Add( m_firstLetter );
    }
    
    public bool shouldStop()
    {
        return isSufficientR( false ) && isSufficientR( true );
    }
    
    public void makeIteration()
    {
        double[] temp = new double[ Percentron.ANumber_p ];
        for ( int i = 1; i < Percentron.ANumber_p; ++i )
        {
            temp[ i ] = m_percentron.m_tempWToT[ m_percentron.m_tempWToT.Count - 1 ][ i ];
        }
        
        m_percentron.m_isFirsts.Add( m_firstLetter );
        for ( int j = 1; j < Percentron.ANumber_p; ++j )
        {
            if ( m_percentron.isOpenA( m_percentron.m_letterToA_Input[ getLetter(), j ] ) )
                temp[ j ] = changeWithRange( temp[ j ], Percentron.step, m_firstLetter );
        }
        
        KeyValuePair< double, double > inRs = m_percentron.calculateInR( temp );
        
        m_percentron.m_tempWToT.Add( temp );
        m_percentron.m_UInLetter1ToT.Add( inRs.Key );
        m_percentron.m_UInLetter2ToT.Add( inRs.Value );
    }
    
    public void adjustLetter()
    {
        if ( isSufficientR() )
            switchLetter();
    }
    
    public void switchLetter()
    {
        m_firstLetter = !m_firstLetter;
    }
    
    
    private double changeWithRange( double _n, double _step, bool _isFirstLetter )
    {
        double difference = m_percentron.m_OR - getUR();
        
        bool shouldIncrease = difference > 0.0;
            
        
        if ( shouldIncrease )
            _n += _step;
        else
            _n -= _step;
        
        if ( _n < 0.0 )
            return 0.0;
        else if ( _n > 1.0 )
            return 1.0;
        
        return _n;
    }
    
    public bool isSufficientR( bool _isFirstLetter )
    {
        return _isFirstLetter
            ?   m_percentron.isSufficientR( m_percentron.m_UInLetter1ToT[ m_percentron.m_UInLetter1ToT.Count - 1 ], _isFirstLetter )
            :   m_percentron.isSufficientR( m_percentron.m_UInLetter2ToT[ m_percentron.m_UInLetter2ToT.Count - 1 ], _isFirstLetter )
        ;
    }
    
    public bool isSufficientR()
    {
        return isSufficientR( m_firstLetter );
    }
    
    public int getLetter()
    {
        return m_firstLetter
            ?   1
            :   2
        ;
    }
    
    public double getUR()
    {
        return m_firstLetter
            ?   m_percentron.m_UInLetter1ToT[ m_percentron.m_UInLetter1ToT.Count - 1 ]
            :   m_percentron.m_UInLetter2ToT[ m_percentron.m_UInLetter2ToT.Count - 1 ]
        ;
    }
        
    private Percentron m_percentron;
    
    private bool m_firstLetter;
}
​
​
public class Program
{
    public static void Main()
    {
        Percentron percentron = new Percentron();
        Printer printer = new Printer( percentron );
        printer.printW();
        printer.printLetterToA_Input();
        printer.printOA();
        printer.printOR();
        printer.printUInLetterToT();
        //printer.printUInLetterToT_y();
        
        Console.WriteLine("Hello World");
    }
}

*** startingOffset: 0, pageSize: 10, totalRecords: 100 ***

Item: 1, Item: 2, Item: 3, Item: 4, Item: 5, Item: 6, Item: 7, Item: 8, Item: 9, Item: 10

First Page Uri: ?limit=10
Last Page Uri: ?offset=90
Next Page Uri: ?offset=10&limit=10

*********************************************

*** startingOffset: 0, pageSize: 50, totalRecords: 68 ***

Item: 1, Item: 2, Item: 3, Item: 4, Item: 5, Item: 6, Item: 7, Item: 8, Item: 9, Item: 10, Item: 11, Item: 12, Item: 13, Item: 14, Item: 15, Item: 16, Item: 17, Item: 18, Item: 19, Item: 20, Item: 21, Item: 22, Item: 23, Item: 24, Item: 25, Item: 26, Item: 27, Item: 28, Item: 29, Item: 30, Item: 31, Item: 32, Item: 33, Item: 34, Item: 35, Item: 36, Item: 37, Item: 38, Item: 39, Item: 40, Item: 41, Item: 42, Item: 43, Item: 44, Item: 45, Item: 46, Item: 47, Item: 48, Item: 49, Item: 50

First Page Uri: ?limit=50
Last Page Uri: ?offset=50
Next Page Uri: ?offset=50&limit=50

*********************************************

*** startingOffset: 89, pageSize: 10, totalRecords: 100 ***

Item: 90, Item: 91, Item: 92, Item: 93, Item: 94, Item: 95, Item: 96, Item: 97, Item: 98, Item: 99

First Page Uri: ?limit=10
Last Page Uri: ?offset=90
Previous Page Uri: ?offset=79&limit=10
Next Page Uri: ?offset=99&limit=10

*********************************************

*** startingOffset: 99, pageSize: 10, totalRecords: 100 ***

Item: 100

First Page Uri: ?limit=10
Last Page Uri: ?offset=90
Previous Page Uri: ?offset=89&limit=10

*********************************************

*** startingOffset: 110, pageSize: 10, totalRecords: 121 ***

Item: 111, Item: 112, Item: 113, Item: 114, Item: 115, Item: 116, Item: 117, Item: 118, Item: 119, Item: 120

First Page Uri: ?limit=10
Last Page Uri: ?offset=120
Previous Page Uri: ?offset=100&limit=10
Next Page Uri: ?offset=120&limit=10

*********************************************

Last Run:	10:27:24 pm
Compile:	0.152s
Execute:	0.016s
Memory:	80kb
CPU:	0.016s

View IL Code