Example #1
0
        static void Main(string[] args)
        {
            Console.WriteLine("task 1");

            Console.WriteLine("Введите x: ");
            double x = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine("Введите N: ");
            int n = Convert.ToInt32(Console.ReadLine());


            SequenceCalculator MyCalc = new SequenceCalculator(x, n);


            Console.WriteLine("Частичная сумма = {0}", MyCalc.GetPartialSum());
            Console.WriteLine("Погрешность = {0}", MyCalc.Fault);
            Console.WriteLine("Разница между погрешностью и N-го слагаемого = {0}", MyCalc.CompareFaultAndLast());
            Console.WriteLine("Значение e^(-{0}) = {1}", x, Math.Pow(Math.E, -x));


            Console.WriteLine(new String('-', 65));


            Console.WriteLine("task 2");

            Console.WriteLine("Введите E: ");
            MyCalc.E = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine("Введите x: ");
            MyCalc.X = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine("Cумма слагаемых больше E = {0}", MyCalc.GetSumLimitedE(1));
            Console.WriteLine("Количество таких слагаемых = {0}", MyCalc.NLimited);
            Console.WriteLine("Сумма слагаемых больше E*10 = {0}", MyCalc.GetSumLimitedE(10));
        }
Example #2
0
        static void Main(string[] args)
        {
            #region Initialize logger

            var logRepository = LogManager.GetRepository(System.Reflection.Assembly.GetEntryAssembly());
            XmlConfigurator.Configure(logRepository, new System.IO.FileInfo("Log4Net.config"));
            log.Info("Application [FileParser] Start");

            #endregion

            SequenceType sequenceType;
            int          sequenceTypeString;
            IntRange     range;

            #region Check input data

            sequenceTypeString = Parser.TryGetInt(args, SequenceTypeInputIndex, out ErrorCode errorCode);
            if (errorCode != ErrorCode.Void)
            {
                ConsoleShowError(errorCode);
                return;
            }

            if (!Enum.IsDefined(typeof(SequenceType), sequenceTypeString))
            {
                log.Error(ErrorCode.InvalidParameter.ToString());
                ConsoleShowError(ErrorCode.InvalidParameter, "SequenceType");

                return;
            }
            else
            {
                sequenceType = (SequenceType)sequenceTypeString;
            }

            range = Parser.TryGetRange(args, out errorCode);
            if (errorCode != ErrorCode.Void)
            {
                ConsoleShowError(errorCode);
                return;
            }

            if (!Validator.IsNaturalNumber(range.Start) || !Validator.IsNaturalNumber(range.End) ||
                !Validator.IsNaturalNumber(range.Count()) ||
                !Validator.IsNumberInRange(range.End, 0, (sequenceType == SequenceType.Fibonacci) ? MaxForFibonacci : Int32.MaxValue))
            {
                ConsoleShowError(ErrorCode.OverflowRange);
                return;
            }

            #endregion

            SequenceCalculator sequenceCalculator = new SequenceCalculator(SequenceFactory.Build(sequenceType));

            sequenceCalculator.PrintGeneratedString(range, ',');
            Console.ReadKey();

            log.Info("Application [FileParser] End");
        }
        public void TestSequenceHalfWayCalculation(string sequence, int expected)
        {
            var sut = new SequenceCalculator();

            var actual = sut.CalculateHalfway(sequence);

            Assert.That(actual, Is.EqualTo(expected));
        }
        public void SetSequence_Negative()
        {
            //arrange

            //act
            ISequence          sequence = null;
            SequenceCalculator sequenceCalculator;

            //assert
            Assert.Throws <ArgumentNullException>(() => sequenceCalculator = new SequenceCalculator(sequence));
        }
        public void Generate_SquareNaturalNumbers_Empty_Positive()
        {
            //arrange
            IList expected = new List <long>(0);

            //act
            ISequence          sequence           = new SquareNaturalNumbers();
            SequenceCalculator sequenceCalculator = new SequenceCalculator(sequence);
            var actual = sequenceCalculator.Generate(new IntRange(0, 0));

            //assert
            Assert.Equal(expected, actual.ToList());
        }
        public void Generate_SquareNaturalNumbers_FromMinusOneToFive_Negative()
        {
            //arrange
            IList expected = new List <long>()
            {
                -1, 0, 1, 2
            };

            //act
            ISequence          sequence           = new SquareNaturalNumbers();
            SequenceCalculator sequenceCalculator = new SequenceCalculator(sequence);
            var actual = sequenceCalculator.Generate(new IntRange(-1, 5));

            //assert
            Assert.Equal(expected, actual.ToList());
        }