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 = 6;
	
	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.8,    0.6,    0.1,    0.3,    0.4,    0.8 };

		for ( int i = 1; i < ANumber_p; ++i )
		{
			m_R[ i ] = temp[ i ];
		}
	}
	
	private void initW()
	{
		double [] temp1 = new double[] { 0.0,    0.4,    0.7,    0.6,    0.3,    0.6,    0.5,    0.3,    0.3,    0.6,    0.1,    0.7,    0.4,    0.2,    0.4,    0.1,    0.8 };
double [] temp2 = new double[] { 0.0,    0.1,    0.2,    0.1,    0.6,    0.3,    0.1,    0.5,    0.7,    0.3,    0.6,    0.8,    0.4,    0.8,    0.6,    0.1,    0.7 };
double [] temp3 = new double[] { 0.0,    0.3,    0.4,    0.3,    0.3,    0.1,    0.5,    0.5,    0.6,    0.1,    0.3,    0.6,    0.1,    0.3,    0.6,    0.6,    0.8 };
double [] temp4 = new double[] { 0.0,    0.5,    0.4,    0.4,    0.6,    0.8,    0.7,    0.5,    0.4,    0.2,    0.7,    0.1,    0.8,    0.5,    0.7,    0.4,    0.8 };
double [] temp5 = new double[] { 0.0,    0.8,    0.8,    0.2,    0.6,    0.2,    0.7,    0.8,    0.5,    0.5,    0.3,    0.6,    0.8,    0.3,    0.5,    0.4,    0.5 };
double [] temp6 = new double[] { 0.0,    0.1,    0.1,    0.8,    0.4,    0.3,    0.4,    0.7,    0.4,    0.8,    0.8,    0.1,    0.2,    0.4,    0.6,    0.2,    0.2 };
		
		
		
		
		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 );
		
	}
	
	private void initOA()
	{
		//AOChooser aoChooser = new AOChooser( this );
		//aoChooser.execute();
		m_OA = 4.05;
	}
	
	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[ 4 ] = true;
		m_letter1[ 5 ] = true;
		m_letter1[ 7 ] = true;
		m_letter1[ 8 ] = true;
		m_letter1[ 9 ] = true;
		m_letter1[ 10 ] = true;
		m_letter1[ 12 ] = true;
		m_letter1[ 13 ] = true;
		m_letter1[ 16 ] = true;
		
		
		m_letter2[ 1 ] = true;
		m_letter2[ 3 ] = true;
		m_letter2[ 4 ] = true;
		m_letter2[ 5 ] = true;
		m_letter2[ 6 ] = true;
		m_letter2[ 9 ] = true;
		m_letter2[ 11 ] = 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 = 6;
    
    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.8,    0.6,    0.1,    0.3,    0.4,    0.8 };
​
        for ( int i = 1; i < ANumber_p; ++i )
        {
            m_R[ i ] = temp[ i ];
        }
    }
    
    private void initW()
    {
        double [] temp1 = new double[] { 0.0,    0.4,    0.7,    0.6,    0.3,    0.6,    0.5,    0.3,    0.3,    0.6,    0.1,    0.7,    0.4,    0.2,    0.4,    0.1,    0.8 };
double [] temp2 = new double[] { 0.0,    0.1,    0.2,    0.1,    0.6,    0.3,    0.1,    0.5,    0.7,    0.3,    0.6,    0.8,    0.4,    0.8,    0.6,    0.1,    0.7 };
double [] temp3 = new double[] { 0.0,    0.3,    0.4,    0.3,    0.3,    0.1,    0.5,    0.5,    0.6,    0.1,    0.3,    0.6,    0.1,    0.3,    0.6,    0.6,    0.8 };
double [] temp4 = new double[] { 0.0,    0.5,    0.4,    0.4,    0.6,    0.8,    0.7,    0.5,    0.4,    0.2,    0.7,    0.1,    0.8,    0.5,    0.7,    0.4,    0.8 };
double [] temp5 = new double[] { 0.0,    0.8,    0.8,    0.2,    0.6,    0.2,    0.7,    0.8,    0.5,    0.5,    0.3,    0.6,    0.8,    0.3,    0.5,    0.4,    0.5 };
double [] temp6 = new double[] { 0.0,    0.1,    0.1,    0.8,    0.4,    0.3,    0.4,    0.7,    0.4,    0.8,    0.8,    0.1,    0.2,    0.4,    0.6,    0.2,    0.2 };
        
        
        
        
        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 );
        
    }
    
    private void initOA()
    {
        //AOChooser aoChooser = new AOChooser( this );
        //aoChooser.execute();
        m_OA = 4.05;
    }
    
    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[ 4 ] = true;
        m_letter1[ 5 ] = true;
        m_letter1[ 7 ] = true;
        m_letter1[ 8 ] = true;
        m_letter1[ 9 ] = true;
        m_letter1[ 10 ] = true;
        m_letter1[ 12 ] = true;
        m_letter1[ 13 ] = true;
        m_letter1[ 16 ] = true;
        
        
        m_letter2[ 1 ] = true;
        m_letter2[ 3 ] = true;
        m_letter2[ 4 ] = true;
        m_letter2[ 5 ] = true;
        m_letter2[ 6 ] = true;
        m_letter2[ 9 ] = true;
        m_letter2[ 11 ] = 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");
    }
}

      S1     S2     S3     S4     S5     S6     S7     S8     S9     S10    S11    S12    S13    S14    S15    S16
A1    0.4    0.7    0.6    0.3    0.6    0.5    0.3    0.3    0.6    0.1    0.7    0.4    0.2    0.4    0.1    0.8
A2    0.1    0.2    0.1    0.6    0.3    0.1    0.5    0.7    0.3    0.6    0.8    0.4    0.8    0.6    0.1    0.7
A3    0.3    0.4    0.3    0.3    0.1    0.5    0.5    0.6    0.1    0.3    0.6    0.1    0.3    0.6    0.6    0.8
A4    0.5    0.4    0.4    0.6    0.8    0.7    0.5    0.4    0.2    0.7    0.1    0.8    0.5    0.7    0.4    0.8
A5    0.8    0.8    0.2    0.6    0.2    0.7    0.8    0.5    0.5    0.3    0.6    0.8    0.3    0.5    0.4    0.5
A6    0.1    0.1    0.8    0.4    0.3    0.4    0.7    0.4    0.8    0.8    0.1    0.2    0.4    0.6    0.2    0.2

           A1     A2     A3     A4     A5     A6
letter1    4      5      3.4    5.8    5.3    4.3
letter2    4.7    3.8    3.3    4.6    4.4    3.5
AO = 4.05
OR = 1.8

              t0     t1f    t2s    t3f    t4s    t5s    t6f    t7s
w1            0.8    -      0.9    -      1      1      -      1
w2            0.6    0.5    -      0.4    -      -      0.3    -
w3            0.1    -      -      -      -      -      -      -
w4            0.3    0.2    0.3    0.2    0.3    0.4    0.3    0.4
w5            0.4    0.3    0.4    0.3    0.4    0.5    0.4    0.5
w6            0.8    0.7    -      0.6    -      -      0.5    -
UR letter1    2.1    1.7    1.9    1.5    1.7    1.9    1.5    1.7
UR letter2    1.5    1.3    1.6    1.4    1.7    1.9    1.7    1.9
Hello World

Cached Result
Last Run:	3:18:55 pm
Compile:	0.121s
Execute:	0s
Memory:	40kb
CPU:	0.016s

View IL Code