Esempio n. 1
0
        static long DifferenceCalculation(string inputFile)
        {
            var parser  = new LongParser();
            var numbers = parser.ReadData(inputFile).ToList();

            return(DifferenceCalculation(numbers));
        }
 public static Either <TLeft, long> ParseToLong <TLeft>(
     this Either <TLeft, string> source,
     IFormatProvider provider,
     TLeft left)
 {
     return(source.FlatMap(x => LongParser.Parse <TLeft>(x, provider, left)));
 }
Esempio n. 3
0
        static int MagicCalculation(string inputFile)
        {
            var parser  = new LongParser();
            var numbers = parser.ReadData(inputFile).ToList();

            return(MagicCalculation(numbers));
        }
            protected internal override object CreateValue(IndexReader reader, object entryKey)
            {
                Entry entry = (Entry)entryKey;

                System.String field  = entry.field;
                LongParser    parser = (LongParser)entry.custom;

                long[]   retArray = new long[reader.MaxDoc()];
                TermDocs termDocs = reader.TermDocs();
                TermEnum termEnum = reader.Terms(new Term(field));

                try
                {
                    do
                    {
                        Term term = termEnum.Term();
                        if (term == null || (object)term.Field() != (object)field)
                        {
                            break;
                        }
                        long termval = parser.ParseLong(term.Text());
                        termDocs.Seek(termEnum);
                        while (termDocs.Next())
                        {
                            retArray[termDocs.Doc()] = termval;
                        }
                    }while (termEnum.Next());
                }
                finally
                {
                    termDocs.Close();
                    termEnum.Close();
                }
                return(retArray);
            }
 public static Either <TLeft, long> ParseToLong <TLeft>(
     this Either <TLeft, string> source,
     NumberStyles style,
     TLeft left)
 {
     return(source.FlatMap(x => LongParser.Parse <TLeft>(x, style, left)));
 }
Esempio n. 6
0
        public static long FindEncryptionWeakness(string inputFile, long expectedSum)
        {
            var parser = new LongParser();
            var list   = parser.ReadData(inputFile).ToList();

            return(SumMinMax(FindContiniousSum(list, expectedSum)));
        }
 public static Either <TLeft, long> ParseToLong <TLeft>(
     this string source,
     NumberStyles style,
     IFormatProvider provider,
     TLeft left)
 {
     return(LongParser.Parse <TLeft>(source, style, provider, left));
 }
Esempio n. 8
0
        public static long FindFirstMismatch(string inputFile, int preambleLength)
        {
            var parser  = new LongParser();
            var numbers = parser.ReadData(inputFile).ToList();
            var result  = numbers.Select((x, i) => new Tuple <long, bool>(x, IsSumInList(FindSubList(numbers, i, preambleLength), x)));

            return(result.First(x => !x.Item2).Item1);
        }
Esempio n. 9
0
        static int Second(string inputFile)
        {
            var parser      = new LongParser();
            var numbers     = parser.ReadData(inputFile).ToList();
            var differences = numbers.Differences3();

            return(differences.Count(d => d > 0));
        }
        public static int?GuessAgeOrNull(string number, DateTime?overrideNow = null)
        {
            var today = overrideNow ?? DateTime.Today;
            var now   = LongParser.ParseOrNull(today.ToString("yyyyMMdd"));
            var then  = LongParser.ParseOrNull(GuessBirthDate(number, today)?.ToString("yyyyMMdd"));

            return(now.HasValue && then.HasValue
                                ? (int)Math.Floor(((decimal)now.Value - then.Value) / 10000m)
                                : (int?)null);
        }
Esempio n. 11
0
        public async Task <ClashDelayResponse> GetClashProxyDelay(string name, int timeout = 5000, string testUrl = "http://www.gstatic.com/generate_204")
        {
            string url = string.Format(API_PROXIES_DELAY, Uri.EscapeDataString(name));

            var dict = new Dictionary <string, dynamic>();

            dict.Add("timeout", Convert.ToString(timeout));
            dict.Add("url", testUrl);

            var result = await GetAsync <ClashDelayResponse>(url, dict);

            result.DelayLong = LongParser.Parse(result.Delay);
            return(result);
        }
Esempio n. 12
0
 static FieldCache_Fields()
 {
     DEFAULT                     = new FieldCacheImpl();
     DEFAULT_BYTE_PARSER         = new AnonymousClassByteParser();
     DEFAULT_SHORT_PARSER        = new AnonymousClassShortParser();
     DEFAULT_INT_PARSER          = new AnonymousClassIntParser();
     DEFAULT_FLOAT_PARSER        = new AnonymousClassFloatParser();
     DEFAULT_LONG_PARSER         = new AnonymousClassLongParser();
     DEFAULT_DOUBLE_PARSER       = new AnonymousClassDoubleParser();
     NUMERIC_UTILS_INT_PARSER    = new AnonymousClassIntParser1();
     NUMERIC_UTILS_FLOAT_PARSER  = new AnonymousClassFloatParser1();
     NUMERIC_UTILS_LONG_PARSER   = new AnonymousClassLongParser1();
     NUMERIC_UTILS_DOUBLE_PARSER = new AnonymousClassDoubleParser1();
 }
Esempio n. 13
0
 public static Maybe <long> ParseToLong(this Maybe <string> source, NumberStyles style)
 {
     return(source.FlatMap(x => LongParser.Parse(x, style)));
 }
Esempio n. 14
0
 public static Maybe <long> ParseToLong(this string source, NumberStyles style, IFormatProvider provider)
 {
     return(LongParser.Parse(source, style, provider));
 }
Esempio n. 15
0
 public static Maybe <long> ParseToLong(this string source, NumberStyles style)
 {
     return(LongParser.Parse(source, style));
 }
		static ExtendedFieldCacheImpl()
		{
			LONG_PARSER = new AnonymousClassLongParser();
			DOUBLE_PARSER = new AnonymousClassDoubleParser();
		}
		// inherit javadocs
		public virtual long[] GetLongs(IndexReader reader, System.String field, LongParser parser)
		{
			return (long[]) longsCache.Get(reader, new Entry(field, parser));
		}
Esempio n. 18
0
			internal LongComparator(int numHits, System.String field, Lucene.Net.Search.Parser parser)
			{
				values = new long[numHits];
				this.field = field;
				this.parser = (LongParser) parser;
			}
Esempio n. 19
0
        public void GetPolynomialDerivativeTest_IntegerFraction()
        {
            var polynomialText           = "1/2*x^5+3/4*x^4-2/7*x^3+5/3*x^2+1/5*x+9";
            var polynomialDerivativeText = "5/2*x^4+3*x^3-6/7*x^2+10/3*x+1/5";
            var variableName             = "x";

            var integerDomain    = new IntegerDomain();
            var longDomain       = new LongDomain();
            var bigIntegerDomain = new BigIntegerDomain();

            var integerParser    = new IntegerParser <string>();
            var longParser       = new LongParser <string>();
            var bigIntegerParser = new BigIntegerParser <string>();

            var longConversion       = new LongToIntegerConversion();
            var bigIntegerConversion = new BigIntegerToIntegerConversion();

            var integerFractionConversion    = new ElementFractionConversion <int>(integerDomain);
            var longfractionConversion       = new OuterElementFractionConversion <int, long>(longConversion, longDomain);
            var bigIntegerfractionConversion = new OuterElementFractionConversion <int, BigInteger>(bigIntegerConversion, bigIntegerDomain);

            var integerFractionField    = new FractionField <int>(integerDomain);
            var longFractionField       = new FractionField <long>(longDomain);
            var bigIntegerFractionField = new FractionField <BigInteger>(bigIntegerDomain);

            // Coeficientes inteiros
            var integerPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>(
                polynomialText,
                integerDomain,
                integerParser,
                integerFractionConversion,
                variableName);

            var integerPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <int, IntegerDomain>(
                polynomialDerivativeText,
                integerDomain,
                integerParser,
                integerFractionConversion,
                variableName);
            var integerActualPolDerivative = integerPolynomial.GetPolynomialDerivative(integerFractionField);

            Assert.AreEqual(integerPolynomialDerivative, integerActualPolDerivative);

            // Coeficientes longos
            var longPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <long, LongDomain>(
                polynomialText,
                longDomain,
                longParser,
                longfractionConversion,
                variableName);

            var longPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <long, LongDomain>(
                polynomialDerivativeText,
                longDomain,
                longParser,
                longfractionConversion,
                variableName);
            var longActualPolDerivative = longPolynomial.GetPolynomialDerivative(longFractionField);

            Assert.AreEqual(longPolynomialDerivative, longActualPolDerivative);

            var bigIntegerPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol <BigInteger, BigIntegerDomain>(
                polynomialText,
                bigIntegerDomain,
                bigIntegerParser,
                bigIntegerfractionConversion,
                variableName);

            var bigIntegerPolynomialDerivative = TestsHelper.ReadFractionalCoeffsUnivarPol <BigInteger, BigIntegerDomain>(
                polynomialDerivativeText,
                bigIntegerDomain,
                bigIntegerParser,
                bigIntegerfractionConversion,
                variableName);
            var bigIntegerActualPolDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerFractionField);

            Assert.AreEqual(bigIntegerPolynomialDerivative, bigIntegerActualPolDerivative);
        }
 // inherit javadocs
 public virtual long[] GetLongs(IndexReader reader, System.String field, LongParser parser)
 {
     return((long[])longsCache.Get(reader, new Entry(field, parser)));
 }
Esempio n. 21
0
        public void PowerTest_FractionPolynomial()
        {
            var integerDomain    = new IntegerDomain();
            var longDomain       = new LongDomain();
            var bigIntegerDomain = new BigIntegerDomain();

            var variableName           = "x";
            var integerPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <int> >(
                variableName,
                new FractionField <int>(integerDomain));
            var longPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <long> >(
                variableName,
                new FractionField <long>(longDomain));
            var bigIntegerPolynomialField = new UnivarPolynomEuclideanDomain <Fraction <BigInteger> >(
                variableName,
                new FractionField <BigInteger>(bigIntegerDomain));

            // Leitores
            var integerParser    = new IntegerParser <string>();
            var longParser       = new LongParser <string>();
            var bigIntegerParser = new BigIntegerParser <string>();

            var integerConversion             = new OuterElementFractionConversion <int, int>(new ElementToElementConversion <int>(), integerDomain);
            var longToIntegerConversion       = new OuterElementFractionConversion <int, long>(new LongToIntegerConversion(), longDomain);
            var bigIntegerToIntegerConversion = new OuterElementFractionConversion <int, BigInteger>(new BigIntegerToIntegerConversion(), bigIntegerDomain);

            var intPowers = new int[3] {
                2, 3, 4
            };
            var longPowers = new long[3] {
                2, 3, 4
            };
            var bigIntPowers = new BigInteger[3] {
                2, 3, 4
            };

            var polynomialsTexts = new string[3] {
                "1/3*x^3-2/3*x^2+3/2*x-1/2", "2*x^2+4/3*x+4/9", "7/5*x+1"
            };
            var expectedPolinomialsTexts = new string[3] {
                "1/9*x^6-4/9*x^5+13/9*x^4-7/3*x^3+35/12*x^2-3/2*x+1/4",
                "8*x^6+16*x^5+16*x^4+256/27*x^3+32/9*x^2+64/81*x+64/729",
                "2401/625*x^4+1372/125*x^3+294/25*x^2+28/5*x+1"
            };

            // Coeficientes inteiros.
            for (int i = 0; i < 3; ++i)
            {
                var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol(
                    polynomialsTexts[i],
                    integerDomain,
                    integerParser,
                    integerConversion,
                    variableName);

                var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol(
                    expectedPolinomialsTexts[i],
                    integerDomain,
                    integerParser,
                    integerConversion,
                    variableName);

                var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], integerPolynomialField);
                Assert.AreEqual(expectedPolynomial, actualPolynomial);
            }

            // Coeficientes longos.
            for (int i = 0; i < 3; ++i)
            {
                var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol(
                    polynomialsTexts[i],
                    longDomain,
                    longParser,
                    longToIntegerConversion,
                    variableName);

                var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol(
                    expectedPolinomialsTexts[i],
                    longDomain,
                    longParser,
                    longToIntegerConversion,
                    variableName);

                var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], longPolynomialField);
                Assert.AreEqual(expectedPolynomial, actualPolynomial);
            }

            // Coeficientes correspondentes a inteiros de precisão arbitrária.
            for (int i = 0; i < 3; ++i)
            {
                var polynomialValue = TestsHelper.ReadFractionalCoeffsUnivarPol(
                    polynomialsTexts[i],
                    bigIntegerDomain,
                    bigIntegerParser,
                    bigIntegerToIntegerConversion,
                    variableName);

                var expectedPolynomial = TestsHelper.ReadFractionalCoeffsUnivarPol(
                    expectedPolinomialsTexts[i],
                    bigIntegerDomain,
                    bigIntegerParser,
                    bigIntegerToIntegerConversion,
                    variableName);

                var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], bigIntegerPolynomialField);
                Assert.AreEqual(expectedPolynomial, actualPolynomial);
            }
        }
Esempio n. 22
0
		static FieldCache_Fields()
		{
			DEFAULT = new FieldCacheImpl();
			DEFAULT_BYTE_PARSER = new AnonymousClassByteParser();
			DEFAULT_SHORT_PARSER = new AnonymousClassShortParser();
			DEFAULT_INT_PARSER = new AnonymousClassIntParser();
			DEFAULT_FLOAT_PARSER = new AnonymousClassFloatParser();
			DEFAULT_LONG_PARSER = new AnonymousClassLongParser();
			DEFAULT_DOUBLE_PARSER = new AnonymousClassDoubleParser();
			NUMERIC_UTILS_INT_PARSER = new AnonymousClassIntParser1();
			NUMERIC_UTILS_FLOAT_PARSER = new AnonymousClassFloatParser1();
			NUMERIC_UTILS_LONG_PARSER = new AnonymousClassLongParser1();
			NUMERIC_UTILS_DOUBLE_PARSER = new AnonymousClassDoubleParser1();
		}
Esempio n. 23
0
        public void GetPolynomialDerivativeTest_SimpleInteger()
        {
            // Representação dos polinómios.
            var polynomText       = "x^1000-2*x^550+1000*x^10+50";
            var polDerivativeText = "1000*x^999-1100*x^549+10000*x^9";

            var variableName = "x";

            // Estabelece os domínios.
            var integerDomain    = new IntegerDomain();
            var longDomain       = new LongDomain();
            var bigIntegerDomain = new BigIntegerDomain();

            // Estabelece os conversores.
            var integerToIntegerConv           = new ElementToElementConversion <int>();
            var integerToLongConv              = new LongToIntegerConversion();
            var integerToBigIntegerConvsersion = new BigIntegerToIntegerConversion();

            // Estabelece os leitores individuais.
            var integerParser    = new IntegerParser <string>();
            var longParser       = new LongParser <string>();
            var bigIntegerParser = new BigIntegerParser <string>();

            // Estabelece os polinómios.
            var integerPolynomial = TestsHelper.ReadUnivarPolynomial(
                polynomText,
                integerDomain,
                integerParser,
                integerToIntegerConv,
                variableName);
            var integerExpectedPolynomial = TestsHelper.ReadUnivarPolynomial(
                polDerivativeText,
                integerDomain,
                integerParser,
                integerToIntegerConv,
                variableName);
            var integerActualDerivative = integerPolynomial.GetPolynomialDerivative(integerDomain);

            // Verifica se os polinómios são válidos.
            Assert.AreEqual(integerExpectedPolynomial, integerActualDerivative);

            // Estabelece os polinómios.
            var longPolynomial = TestsHelper.ReadUnivarPolynomial(
                polynomText,
                longDomain,
                longParser,
                integerToLongConv,
                variableName);
            var longExpectedPolynomial = TestsHelper.ReadUnivarPolynomial(
                polDerivativeText,
                longDomain,
                longParser,
                integerToLongConv,
                variableName);
            var longActualDerivative = longPolynomial.GetPolynomialDerivative(longDomain);

            // Verifica se os polinómios são válidos.
            Assert.AreEqual(longExpectedPolynomial, longActualDerivative);

            // Estabelece os polinómios.
            var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial(
                polynomText,
                bigIntegerDomain,
                bigIntegerParser,
                integerToBigIntegerConvsersion,
                variableName);
            var bigIntegerExpectedPolynomial = TestsHelper.ReadUnivarPolynomial(
                polDerivativeText,
                bigIntegerDomain,
                bigIntegerParser,
                integerToBigIntegerConvsersion,
                variableName);
            var bigIntegerActualDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerDomain);

            // Verifica se os polinómios são válidos.
            Assert.AreEqual(bigIntegerExpectedPolynomial, bigIntegerActualDerivative);
        }
Esempio n. 24
0
        public void GetPolynomialDerivativeTest_IntegerPolynomialAsCoefficients()
        {
            var polynomialText           = "(y^2+y+1)*x^3-2*x^2*y+x*(y^5-3)+4";
            var polynomialDerivativeText = "3*(y^2+y+1)*x^2-4*y*x+y^5-3";
            var variableName             = "x";
            var coeffsVariableName       = "y";

            // Os domínios responsáveis pelas operações sobre os inteiros.
            var integerDomain    = new IntegerDomain();
            var longDomain       = new LongDomain();
            var bigIntegerDomain = new BigIntegerDomain();

            // Os leitore sde inteiros
            var integerParser    = new IntegerParser <string>();
            var longParser       = new LongParser <string>();
            var bigIntegerParser = new BigIntegerParser <string>();

            // Definição das conversões.
            var integerConversion    = new ElementToElementConversion <int>();
            var longConversion       = new LongToIntegerConversion();
            var bigIntegerConversion = new BigIntegerToIntegerConversion();

            var integerPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <int>(
                coeffsVariableName,
                integerConversion,
                integerDomain);
            var longPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <long>(
                coeffsVariableName,
                longConversion,
                longDomain);
            var bigIntegerPolConvertion = new UnivarPolynomNormalFormToIntegerConversion <BigInteger>(
                coeffsVariableName,
                bigIntegerConversion,
                bigIntegerDomain);

            // Definição dos anéis polinomiais.
            var integerPolynomialRing    = new UnivarPolynomRing <int>(coeffsVariableName, integerDomain);
            var longPolynomialRing       = new UnivarPolynomRing <long>(coeffsVariableName, longDomain);
            var bigIntegerPolynomialRing = new UnivarPolynomRing <BigInteger>(coeffsVariableName, bigIntegerDomain);

            // Definição dos leitores polinomiais.
            var integerPolynomialParser = new UnivarPolNormalFormParser <int>(
                coeffsVariableName,
                integerConversion,
                integerParser,
                integerDomain);
            var longPolynomialParser = new UnivarPolNormalFormParser <long>(
                coeffsVariableName,
                longConversion,
                longParser,
                longDomain);
            var bigIntegerPolynomialParser = new UnivarPolNormalFormParser <BigInteger>(
                coeffsVariableName,
                bigIntegerConversion,
                bigIntegerParser,
                bigIntegerDomain);

            // Definição dos testes.
            var integerPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <int> >(
                polynomialText,
                integerPolynomialRing,
                integerPolynomialParser,
                integerPolConvertion,
                variableName);
            var integerExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <int> >(
                polynomialDerivativeText,
                integerPolynomialRing,
                integerPolynomialParser,
                integerPolConvertion,
                variableName);
            var integerActualPlynomial = integerPolynomial.GetPolynomialDerivative(integerPolynomialRing);

            Assert.AreEqual(integerExpectedPol, integerActualPlynomial);

            var longPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <long> >(
                polynomialText,
                longPolynomialRing,
                longPolynomialParser,
                longPolConvertion,
                variableName);
            var longExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <long> >(
                polynomialDerivativeText,
                longPolynomialRing,
                longPolynomialParser,
                longPolConvertion,
                variableName);
            var longActualPlynomial = longPolynomial.GetPolynomialDerivative(longPolynomialRing);

            Assert.AreEqual(longExpectedPol, longActualPlynomial);

            var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <BigInteger> >(
                polynomialText,
                bigIntegerPolynomialRing,
                bigIntegerPolynomialParser,
                bigIntegerPolConvertion,
                variableName);
            var bigIntegerExpectedPol = TestsHelper.ReadUnivarPolynomial <UnivariatePolynomialNormalForm <BigInteger> >(
                polynomialDerivativeText,
                bigIntegerPolynomialRing,
                bigIntegerPolynomialParser,
                bigIntegerPolConvertion,
                variableName);
            var bigIntegerActualPlynomial = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerPolynomialRing);

            Assert.AreEqual(bigIntegerExpectedPol, bigIntegerExpectedPol);
        }
Esempio n. 25
0
 public static Maybe <long> ParseToLong(this Maybe <string> source, NumberStyles style, IFormatProvider provider)
 {
     return(source.FlatMap(x => LongParser.Parse(x, style, provider)));
 }
Esempio n. 26
0
 public static Maybe <long> ParseToLong(this string source)
 {
     return(LongParser.Parse(source));
 }
 static ExtendedFieldCacheImpl()
 {
     LONG_PARSER   = new AnonymousClassLongParser();
     DOUBLE_PARSER = new AnonymousClassDoubleParser();
 }
Esempio n. 28
0
        public void GetPolynomialDerivativeTest_IntegerMatrix()
        {
            // Os valores a serem lidos
            var polynomialText           = "[[1,2],[3,4]]*x^2-[[1,0],[0,1]]*x+[[7,6],[9,8]]";
            var polynomialDerivativeText = "[[2,4],[6,8]]*x+[[-1,0],[0,-1]]";
            var variableName             = "x";

            var arrayDelimiters = new Dictionary <string, string>();

            arrayDelimiters.Add("left_bracket", "right_bracket");

            // Os domínios responsáveis sobre as operações sobre os inteiros.
            var integerDomain    = new IntegerDomain();
            var longDomain       = new LongDomain();
            var bigIntegerDomain = new BigIntegerDomain();

            // Os leitore sde inteiros
            var integerParser    = new IntegerParser <string>();
            var longParser       = new LongParser <string>();
            var bigIntegerParser = new BigIntegerParser <string>();

            // As fábricas responsáveis pela instanciação de matrizes
            var integerSquareArrayMatrixfactory    = new ArraySquareMatrixFactory <int>();
            var longSquareArrayMatrixFactory       = new ArraySquareMatrixFactory <long>();
            var bigIntegerSquareArrayMatrixfactory = new ArraySquareMatrixFactory <BigInteger>();

            // Os anéis de matrizes
            var integerGenericMatrixRing = new GeneralMatrixRing <int>(
                2,
                integerSquareArrayMatrixfactory,
                integerDomain);
            var longGenericMatrixRing = new GeneralMatrixRing <long>(
                2,
                longSquareArrayMatrixFactory,
                longDomain);
            var bigIntegerGenericMatrixRing = new GeneralMatrixRing <BigInteger>(
                2,
                bigIntegerSquareArrayMatrixfactory,
                bigIntegerDomain);

            // Os objectos responsáveis pela conversão entre os coeficientes e o grau (inteiro)
            var integerMatrixConversion    = new CantConvertConversion <int, IMatrix <int> >();
            var longMatrixConversion       = new CantConvertConversion <int, IMatrix <long> >();
            var bigIntegerMatrixConversion = new CantConvertConversion <int, IMatrix <BigInteger> >();

            var integerMatrixConfigParser = new ConfigMatrixParser <int, IMatrix <int> >(
                integerParser,
                2,
                2,
                (i, j) => integerSquareArrayMatrixfactory.CreateMatrix(i, j));

            integerMatrixConfigParser.SeparatorSymbType = "comma";
            integerMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket");
            integerMatrixConfigParser.AddBlanckSymbolType("blancks");

            var longMatrixConfigParser = new ConfigMatrixParser <long, IMatrix <long> >(
                longParser,
                2,
                2,
                (i, j) => longSquareArrayMatrixFactory.CreateMatrix(i, j));

            longMatrixConfigParser.SeparatorSymbType = "comma";
            longMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket");
            longMatrixConfigParser.AddBlanckSymbolType("blancks");

            var bigIntegerMatrixConfigParser = new ConfigMatrixParser <BigInteger, IMatrix <BigInteger> >(
                bigIntegerParser,
                2,
                2,
                (i, j) => bigIntegerSquareArrayMatrixfactory.CreateMatrix(i, j));

            bigIntegerMatrixConfigParser.SeparatorSymbType = "comma";
            bigIntegerMatrixConfigParser.MapInternalDelimiters("left_bracket", "right_bracket");
            bigIntegerMatrixConfigParser.AddBlanckSymbolType("blancks");

            // Leitura dos polinómios e subsequente teste.
            var integerPolynomial = TestsHelper.ReadUnivarPolynomial <IMatrix <int> >(
                polynomialText,
                integerGenericMatrixRing,
                integerMatrixConfigParser,
                integerMatrixConversion,
                variableName,
                arrayDelimiters);
            var integerExpectedDerivative = TestsHelper.ReadUnivarPolynomial(
                polynomialDerivativeText,
                integerGenericMatrixRing,
                integerMatrixConfigParser,
                integerMatrixConversion,
                variableName,
                arrayDelimiters,
                true);
            var integerActualDerivative = integerPolynomial.GetPolynomialDerivative(integerGenericMatrixRing);

            Assert.IsTrue(
                new UnivarPolynomNormalFormEqualityComparer <IMatrix <int> >(integerGenericMatrixRing).Equals(integerExpectedDerivative, integerActualDerivative),
                string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative));

            var longPolynomial = TestsHelper.ReadUnivarPolynomial(
                polynomialText,
                longGenericMatrixRing,
                longMatrixConfigParser,
                longMatrixConversion,
                variableName,
                arrayDelimiters);
            var longExpectedDerivative = TestsHelper.ReadUnivarPolynomial(
                polynomialDerivativeText,
                longGenericMatrixRing,
                longMatrixConfigParser,
                longMatrixConversion,
                variableName,
                arrayDelimiters,
                true);
            var longActualDerivative = longPolynomial.GetPolynomialDerivative(longGenericMatrixRing);

            Assert.IsTrue(
                new UnivarPolynomNormalFormEqualityComparer <IMatrix <long> >(longGenericMatrixRing).Equals(longExpectedDerivative, longActualDerivative),
                string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative));

            var bigIntegerPolynomial = TestsHelper.ReadUnivarPolynomial(
                polynomialText,
                bigIntegerGenericMatrixRing,
                bigIntegerMatrixConfigParser,
                bigIntegerMatrixConversion,
                variableName,
                arrayDelimiters);
            var bigIntegerExpectedDerivative = TestsHelper.ReadUnivarPolynomial(
                polynomialDerivativeText,
                bigIntegerGenericMatrixRing,
                bigIntegerMatrixConfigParser,
                bigIntegerMatrixConversion,
                variableName,
                arrayDelimiters,
                true);
            var bigIntegerActualDerivative = bigIntegerPolynomial.GetPolynomialDerivative(bigIntegerGenericMatrixRing);

            Assert.IsTrue(
                new UnivarPolynomNormalFormEqualityComparer <IMatrix <BigInteger> >(
                    bigIntegerGenericMatrixRing).Equals(bigIntegerExpectedDerivative,
                                                        bigIntegerActualDerivative),
                string.Format("Expected {0} isn't equal to actual {1}.", integerExpectedDerivative, integerActualDerivative));
        }
 public static Either <TLeft, long> ParseToLong <TLeft>(this string source, TLeft left)
 {
     return(LongParser.Parse(source, left));
 }
Esempio n. 30
0
 internal LongComparator(int numHits, System.String field, Lucene.Net.Search.Parser parser)
 {
     values      = new long[numHits];
     this.field  = field;
     this.parser = (LongParser)parser;
 }
Esempio n. 31
0
        public void PowerTest_IntegerPolynomial()
        {
            var integerDomain    = new IntegerDomain();
            var longDomain       = new LongDomain();
            var bigIntegerDomain = new BigIntegerDomain();

            var variableName        = "x";
            var intPolDomain        = new UnivarPolynomRing <int>(variableName, integerDomain);
            var longPolDomain       = new UnivarPolynomRing <long>(variableName, longDomain);
            var bigIntegerPolDomain = new UnivarPolynomRing <BigInteger>(variableName, bigIntegerDomain);

            // Leitores
            var integerParser    = new IntegerParser <string>();
            var longParser       = new LongParser <string>();
            var bigIntegerParser = new BigIntegerParser <string>();

            var integerConversion             = new ElementToElementConversion <int>();
            var longToIntegerConversion       = new LongToIntegerConversion();
            var bigIntegerToIntegerConversion = new BigIntegerToIntegerConversion();

            var intPowers = new int[3] {
                2, 3, 4
            };
            var longPowers = new long[3] {
                2, 3, 4
            };
            var bigIntPowers = new BigInteger[3] {
                2, 3, 4
            };

            var polynomialsTexts = new string[3] {
                "x^3-2*x^2+3*x-1", "2*x^2+4*x+4", "x+1"
            };
            var expectedPolinomialsTexts = new string[3] {
                "x^6-4*x^5+10*x^4-14*x^3+13*x^2-6*x+1",
                "8*x^6+48*x^5+144*x^4+256*x^3+288*x^2+192*x+64",
                "x^4+4*x^3+6*x^2+4*x+1"
            };

            // Coeficientes inteiros.
            for (int i = 0; i < 3; ++i)
            {
                var polynomialValue = TestsHelper.ReadUnivarPolynomial(
                    polynomialsTexts[i],
                    integerDomain,
                    integerParser,
                    integerConversion,
                    variableName);

                var expectedPolynomial = TestsHelper.ReadUnivarPolynomial(
                    expectedPolinomialsTexts[i],
                    integerDomain,
                    integerParser,
                    integerConversion,
                    variableName);

                var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], intPolDomain);
                Assert.AreEqual(expectedPolynomial, actualPolynomial);
            }

            // Coeficientes longos.
            for (int i = 0; i < 3; ++i)
            {
                var polynomialValue = TestsHelper.ReadUnivarPolynomial(
                    polynomialsTexts[i],
                    longDomain,
                    longParser,
                    longToIntegerConversion,
                    variableName);

                var expectedPolynomial = TestsHelper.ReadUnivarPolynomial(
                    expectedPolinomialsTexts[i],
                    longDomain,
                    longParser,
                    longToIntegerConversion,
                    variableName);

                var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], longPolDomain);
                Assert.AreEqual(expectedPolynomial, actualPolynomial);
            }

            // Coeficientes correspondentes a inteiros de precisão arbitrária.
            for (int i = 0; i < 3; ++i)
            {
                var polynomialValue = TestsHelper.ReadUnivarPolynomial(
                    polynomialsTexts[i],
                    bigIntegerDomain,
                    bigIntegerParser,
                    bigIntegerToIntegerConversion,
                    variableName);

                var expectedPolynomial = TestsHelper.ReadUnivarPolynomial(
                    expectedPolinomialsTexts[i],
                    bigIntegerDomain,
                    bigIntegerParser,
                    bigIntegerToIntegerConversion,
                    variableName);

                var actualPolynomial = MathFunctions.Power(polynomialValue, intPowers[i], bigIntegerPolDomain);
                Assert.AreEqual(expectedPolynomial, actualPolynomial);
            }
        }