Пример #1
0
        public virtual void TestOverlappedTokensLattice2()
        {
            TokenStream ts       = new CannedTokenStream(new Token[] { Token("abc", 1, 1), Token("xyz", 0, 3), Token("def", 1, 1), Token("ghi", 1, 1) });
            Automaton   actual   = (new TokenStreamToAutomaton()).ToAutomaton(ts);
            Automaton   a1       = BasicAutomata.MakeString("xyz");
            Automaton   a2       = Join("abc", "def", "ghi");
            Automaton   expected = BasicOperations.Union(a1, a2);

            //toDot(actual);
            Assert.IsTrue(BasicOperations.SameLanguage(expected, actual));
        }
Пример #2
0
        public virtual void TestOverlappedTokensSausage()
        {
            // Two tokens on top of each other (sausage):
            TokenStream ts       = new CannedTokenStream(new Token[] { Token("abc", 1, 1), Token("xyz", 0, 1) });
            Automaton   actual   = (new TokenStreamToAutomaton()).ToAutomaton(ts);
            Automaton   a1       = BasicAutomata.MakeString("abc");
            Automaton   a2       = BasicAutomata.MakeString("xyz");
            Automaton   expected = BasicOperations.Union(a1, a2);

            Assert.IsTrue(BasicOperations.SameLanguage(expected, actual));
        }
Пример #3
0
        public void Add_AddTwoIntegers_ResultIsCorrect(int firstNumber, int secondNumber, int expected)
        {
            //Arrange
            BasicOperations basicOperations = new BasicOperations();

            //Act
            var result = basicOperations.Add(firstNumber, secondNumber);

            //Assert
            Assert.Equal(expected, result);
        }
Пример #4
0
        public void Add_TwoPositiveNumbers_ResultIsEqualToSumOfNumbers(int firstNumber, int secondNumber, int sum)
        {
            //Arrange
            BasicOperations sut = new BasicOperations();

            //Act
            int result = sut.Add(firstNumber, secondNumber);

            //Assert
            Assert.Equal(sum, result);
        }
Пример #5
0
        private Automaton Join(params string[] strings)
        {
            IList <Automaton> @as = new List <Automaton>();

            foreach (string s in strings)
            {
                @as.Add(BasicAutomata.MakeString(s));
                @as.Add(SEP_A);
            }
            @as.RemoveAt(@as.Count - 1);
            return(BasicOperations.Concatenate(@as));
        }
        public override List <string> SplitTasks(List <string> rawData, List <int> taskSplits)
        {
            var taskList   = new List <string>();
            var tasklength = BasicOperations.TaskLength(taskSplits, rawData.Count);

            for (int split = 0; split < taskSplits.Count; split++)
            {
                string taskString = BasicOperations.Task2String(rawData, tasklength, taskSplits[split]);
                taskList.Add(taskString);
            }
            return(taskList);
        }
Пример #7
0
        public void TaskLengthTest()
        {
            var expected = 4;


            //act
            var actual = BasicOperations.TaskLength(TaskSplits, InputList.Count);


            //assert
            Assert.AreEqual(expected, actual);
        }
Пример #8
0
        public virtual void TestRewritePrefix()
        {
            Automaton pfx = BasicAutomata.MakeString("do");

            pfx.ExpandSingleton(); // expand singleton representation for testing
            Automaton      prefixAutomaton = BasicOperations.Concatenate(pfx, BasicAutomata.MakeAnyString());
            AutomatonQuery aq    = new AutomatonQuery(NewTerm("bogus"), prefixAutomaton);
            Terms          terms = MultiFields.GetTerms(Searcher.IndexReader, FN);

            Assert.IsTrue(aq.GetTermsEnum(terms) is PrefixTermsEnum);
            Assert.AreEqual(3, AutomatonQueryNrHits(aq));
        }
Пример #9
0
        public void AddTest()
        {
            BasicOperations target   = new BasicOperations(); // TODO: Initialize to an appropriate value
            int             numberA  = 0;                     // TODO: Initialize to an appropriate value
            int             numberB  = 0;                     // TODO: Initialize to an appropriate value
            int             expected = 0;                     // TODO: Initialize to an appropriate value
            int             actual;

            actual = target.Add(numberA, numberB);
            Assert.AreEqual(expected, actual);
            //Assert.Inconclusive("Verify the correctness of this test method.");
        }
Пример #10
0
        public void Task2StringTest()
        {
            //arrange
            string expected   = "<Name>Task Number</Name>\ntest task\ntest task\ntest task";
            var    taskLength = 4;

            //act
            var actual = BasicOperations.Task2String(InputList, taskLength, TaskSplits[0]);


            //assert
            Assert.AreEqual(actual, expected);
        }
Пример #11
0
 protected internal override Automaton ConvertAutomaton(Automaton a)
 {
     if (unicodeAware)
     {
         Automaton utf8automaton = (new UTF32ToUTF8()).Convert(a);
         BasicOperations.Determinize(utf8automaton);
         return(utf8automaton);
     }
     else
     {
         return(a);
     }
 }
Пример #12
0
        public void Add_AddPositiveNumbersUsingAAA_ResultIsCorrect()
        {
            //Arrange
            var basicOperations = new BasicOperations();

            //Act
            var result = basicOperations.Add(5, 1);

            //Assert
            var expectedResult = 6;

            Assert.AreEqual(result, expectedResult);
        }
        public void MinusFunktionTest0()
        {
            //Arrange

            var cal = new BasicOperations(2, 2);

            //Act

            double result = cal.MinusFunktion();

            //Assert

            Assert.AreEqual(0, result);
        }
Пример #14
0
        public void Add_AddNegativeNumbers_ResultIsCorrect()
        {
            //Lets try to use debug mode here
            //Arrange
            var basicOperations = new BasicOperations();

            //Act
            var result = basicOperations.Add(-5, -1);

            //Assert
            var expectedResult = -6;

            Assert.AreEqual(result, expectedResult);
        }
        public void DividerFunktionTest2()
        {
            //Arrange

            var cal = new BasicOperations(4, 2);

            //Act

            double result = cal.DividerFunktion();

            //Assert

            Assert.AreEqual(2, result);
        }
Пример #16
0
        public void TestKeep()
        {
            CharacterRunAutomaton keepWords =
                new CharacterRunAutomaton(
                    BasicOperations.Complement(
                        BasicOperations.Union(
                            BasicAutomata.MakeString("foo"), BasicAutomata.MakeString("bar")) /*,
                                                                                               * Operations.DEFAULT_MAX_DETERMINIZED_STATES*/));
            Analyzer a = new MockAnalyzer(Random, MockTokenizer.SIMPLE, true, keepWords);

            AssertAnalyzesTo(a, "quick foo brown bar bar fox foo",
                             new String[] { "foo", "bar", "bar", "foo" },
                             new int[] { 2, 2, 1, 2 });
        }
        public void GangeFunktionTest10()
        {
            //Arrange

            var cal = new BasicOperations(2, 5);

            //Act

            double result = cal.GangeFunktion();

            //Assert

            Assert.AreEqual(10, result);
        }
Пример #18
0
 public virtual void TestBasicAutomata()
 {
     AssertAutomatonHits(0, BasicAutomata.MakeEmpty());
     AssertAutomatonHits(0, BasicAutomata.MakeEmptyString());
     AssertAutomatonHits(2, BasicAutomata.MakeAnyChar());
     AssertAutomatonHits(3, BasicAutomata.MakeAnyString());
     AssertAutomatonHits(2, BasicAutomata.MakeString("doc"));
     AssertAutomatonHits(1, BasicAutomata.MakeChar('a'));
     AssertAutomatonHits(2, BasicAutomata.MakeCharRange('a', 'b'));
     AssertAutomatonHits(2, BasicAutomata.MakeInterval(1233, 2346, 0));
     AssertAutomatonHits(1, BasicAutomata.MakeInterval(0, 2000, 0));
     AssertAutomatonHits(2, BasicOperations.Union(BasicAutomata.MakeChar('a'), BasicAutomata.MakeChar('b')));
     AssertAutomatonHits(0, BasicOperations.Intersection(BasicAutomata.MakeChar('a'), BasicAutomata.MakeChar('b')));
     AssertAutomatonHits(1, BasicOperations.Minus(BasicAutomata.MakeCharRange('a', 'b'), BasicAutomata.MakeChar('a')));
 }
Пример #19
0
        public void DoBasicOperation(BasicOperations opr)
        {
            if (_answerObtained)
            {
                _answerObtained = false;
            }

            if (OutputDisplay.Text != "")
            {
                string symbol = EvaluateOperation(opr);
                _results           = double.Parse(OutputDisplay.Text);
                OutputDisplay.Text = "";
                InputDisplay.Text  = _results.ToString() + " " + symbol;
            }
        }
Пример #20
0
        public void MoveToMemoryList(BasicOperations function, IndexBaseAddresses fromValue, IndexBaseAddresses toValue, TextBox[] textBoxes)
        {
            var disp = DispTextBox.Text;

            switch (function)
            {
            case BasicOperations.MOV:
                textBoxes[1].Text = textBoxes[0].Text;
                if (fromValue == IndexBaseAddresses.DIplusBP || fromValue == IndexBaseAddresses.SIplusBP || fromValue == IndexBaseAddresses.DIplusBX || fromValue == IndexBaseAddresses.SIplusBX)
                {
                    MemoryCells.Add(new MemoryCell {
                        Data             = textBoxes[0].Text,
                        EffectiveAddress = $"{textBoxes[0].Text}{disp}"
                    });
                }
                else
                {
                    MemoryCells.Add(new MemoryCell {
                        Data             = textBoxes[1].Text,
                        EffectiveAddress = $"{textBoxes[1].Text}{disp}"
                    });
                }
                break;

            case BasicOperations.ECHG:
                var toText = textBoxes[1].Text;
                textBoxes[1].Text = textBoxes[0].Text;
                textBoxes[0].Text = toText;
                if (fromValue == IndexBaseAddresses.DIplusBP || fromValue == IndexBaseAddresses.SIplusBP || fromValue == IndexBaseAddresses.DIplusBX || fromValue == IndexBaseAddresses.SIplusBX)
                {
                    MemoryCells.Add(new MemoryCell {
                        Data             = textBoxes[0].Text,
                        EffectiveAddress = $"{textBoxes[0].Text}{disp}"
                    });
                }
                else
                {
                    MemoryCells.Add(new MemoryCell {
                        Data             = textBoxes[1].Text,
                        EffectiveAddress = $"{textBoxes[1].Text}{disp}"
                    });
                }
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
    private void Awake()
    {
        basicOperations = new BasicOperations();

        operation = Operations.Addition;

        transform.Find("FirstFactor").Find("InputField").GetComponent <InputField>().onEndEdit.AddListener(SetFirstFactor);

        transform.Find("SecondFactor").Find("InputField").GetComponent <InputField>().onEndEdit.AddListener(SetSecondFactor);

        transform.Find("OperationDropdown").GetComponent <Dropdown>().onValueChanged.AddListener(SetOperation);

        transform.Find("ComputeButton").GetComponent <Button>().onClick.AddListener(() =>
        {
            float result = 0;

            switch (operation)
            {
            case Operations.Addition:
                result = basicOperations.Addition(firstFactor, secondFactor);
                break;

            case Operations.Subtraction:
                result = basicOperations.Subtraction(firstFactor, secondFactor);
                break;

            case Operations.Multiplication:
                result = basicOperations.Multiplication(firstFactor, secondFactor);
                break;

            case Operations.Division:
                if (secondFactor == 0)
                {
                    ShowResultMessage("You can't divide by 0!");
                    return;
                }

                result = basicOperations.Division(firstFactor, secondFactor);
                break;
            }

            ShowResult(result);
        });

        resultText = transform.Find("Result").Find("Value").GetComponent <Text>();
    }
Пример #22
0
        public static BasicOperations GetReverse(this BasicOperations op)
        {
            switch (op)
            {
            case BasicOperations.Add:
                return(BasicOperations.Sub);

            case BasicOperations.Sub:
                return(BasicOperations.Add);

            case BasicOperations.Xor:
                return(BasicOperations.Xor);

            default:
                throw new InvalidOperationException(string.Format("Cannot reverse unknown op '{0}'", op));
            }
        }
Пример #23
0
        private static void Main(string[] args)
        {
            var tester          = new Assert("Basic Operations");
            var basicOperations = new BasicOperations();

            tester.AreEqual("Addition", 10, basicOperations.Addition(5, 5));

            tester.AreEqual("Subtraction", 0, basicOperations.Subtraction(5, 5));

            tester.AreEqual("Division", 1, basicOperations.Division(5, 5));

            tester.ThrowsException <ZeroDivisorNotAllowed>("Zero Division", () => basicOperations.Division(10, 0));

            tester.AreEqual("Multiplication", 25, basicOperations.Multiplication(5, 5));

            Console.ReadKey();
        }
Пример #24
0
        public virtual void TestIntersect()
        {
            for (int i = 0; i < numIterations; i++)
            {
                string                   reg       = AutomatonTestUtil.RandomRegexp(Random);
                Automaton                automaton = (new RegExp(reg, RegExpSyntax.NONE)).ToAutomaton();
                CompiledAutomaton        ca        = new CompiledAutomaton(automaton, SpecialOperations.IsFinite(automaton), false);
                TermsEnum                te        = MultiFields.GetTerms(reader, "field").Intersect(ca, null);
                Automaton                expected  = BasicOperations.Intersection(termsAutomaton, automaton);
                JCG.SortedSet <BytesRef> found     = new JCG.SortedSet <BytesRef>();
                while (te.Next() != null)
                {
                    found.Add(BytesRef.DeepCopyOf(te.Term));
                }

                Automaton actual = BasicAutomata.MakeStringUnion(found);
                Assert.IsTrue(BasicOperations.SameLanguage(expected, actual));
            }
        }
Пример #25
0
        /// <summary>
        /// Convert Lucene wildcard syntax into an automaton.
        /// <para/>
        /// @lucene.internal
        /// </summary>
        public static Automaton ToAutomaton(Term wildcardquery)
        {
            IList <Automaton> automata = new JCG.List <Automaton>();

            string wildcardText = wildcardquery.Text;

            for (int i = 0; i < wildcardText.Length;)
            {
                int c      = Character.CodePointAt(wildcardText, i);
                int length = Character.CharCount(c);
                switch (c)
                {
                case WILDCARD_STRING:
                    automata.Add(BasicAutomata.MakeAnyString());
                    break;

                case WILDCARD_CHAR:
                    automata.Add(BasicAutomata.MakeAnyChar());
                    break;

                case WILDCARD_ESCAPE:
                    // add the next codepoint instead, if it exists
                    if (i + length < wildcardText.Length)
                    {
                        int nextChar = Character.CodePointAt(wildcardText, i + length);
                        length += Character.CharCount(nextChar);
                        automata.Add(BasicAutomata.MakeChar(nextChar));
                        break;
                    }     // else fallthru, lenient parsing with a trailing \
                    goto default;

                default:
                    automata.Add(BasicAutomata.MakeChar(c));
                    break;
                }
                i += length;
            }

            return(BasicOperations.Concatenate(automata));
        }
Пример #26
0
        static void Main(string[] args)
        {
            Console.WriteLine("-------------- Velkommen til din nye lommeregner --------------");

            Console.WriteLine("Indtast dit første tal...");
            string Tal1  = Console.ReadLine();
            double temp1 = Double.Parse(Tal1);

            Console.WriteLine("Indtast en operator...");
            string Operator = Console.ReadLine();

            Console.WriteLine("Indtast dit andet tal...");
            string Tal2  = Console.ReadLine();
            double temp2 = Double.Parse(Tal2);

            var calc = new BasicOperations(temp1, temp2);

            switch (Operator)
            {
            case "+":
                Console.WriteLine(calc.PlusFunktion());
                break;

            case "-":
                Console.WriteLine(calc.MinusFunktion());
                break;

            case "*":
                Console.WriteLine(calc.GangeFunktion());
                break;

            case "/":
                Console.WriteLine(calc.DividerFunktion());
                break;

            default:
                Console.WriteLine("Indtast venligst en korrekt operator.");
                break;
            }
        }
        public override void SetUp()
        {
            base.SetUp();
            // build an automaton matching this jvm's letter definition
            State initial = new State();
            State accept  = new State();

            accept.Accept = true;
            for (int i = 0; i <= 0x10FFFF; i++)
            {
                if (Character.IsLetter(i))
                {
                    initial.AddTransition(new Transition(i, i, accept));
                }
            }
            Automaton single = new Automaton(initial);

            single.Reduce();
            Automaton repeat = BasicOperations.Repeat(single);

            jvmLetter = new CharacterRunAutomaton(repeat);
        }
Пример #28
0
        public static Op GetOpFunc(this BasicOperations op)
        {
            Op d = null;

            switch (op)
            {
            case BasicOperations.Add:
                d = (a, b) => a + b;
                break;

            case BasicOperations.Sub:
                d = (a, b) => a - b;
                break;

            case BasicOperations.Xor:
                d = (a, b) => a ^ b;
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(op));
            }
            return(d);
        }
Пример #29
0
        public virtual void TestFiniteVersusInfinite()
        {
            for (int i = 0; i < numIterations; i++)
            {
                string           reg          = AutomatonTestUtil.RandomRegexp(Random);
                Automaton        automaton    = (new RegExp(reg, RegExpSyntax.NONE)).ToAutomaton();
                IList <BytesRef> matchedTerms = new List <BytesRef>();
                foreach (BytesRef t in terms)
                {
                    if (BasicOperations.Run(automaton, t.Utf8ToString()))
                    {
                        matchedTerms.Add(t);
                    }
                }

                Automaton alternate = BasicAutomata.MakeStringUnion(matchedTerms);
                //System.out.println("match " + matchedTerms.Size() + " " + alternate.getNumberOfStates() + " states, sigma=" + alternate.getStartPoints().length);
                //AutomatonTestUtil.minimizeSimple(alternate);
                //System.out.println("minmize done");
                AutomatonQuery a1 = new AutomatonQuery(new Term("field", ""), automaton);
                AutomatonQuery a2 = new AutomatonQuery(new Term("field", ""), alternate);
                CheckHits.CheckEqual(a1, searcher.Search(a1, 25).ScoreDocs, searcher.Search(a2, 25).ScoreDocs);
            }
        }
Пример #30
0
        /// <summary>
        /// Initialize levenshtein DFAs up to maxDistance, if possible </summary>
        private IList <CompiledAutomaton> InitAutomata(int maxDistance)
        {
            IList <CompiledAutomaton> runAutomata = dfaAtt.Automata;

            //System.out.println("cached automata size: " + runAutomata.size());
            if (runAutomata.Count <= maxDistance && maxDistance <= LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE)
            {
                LevenshteinAutomata builder = new LevenshteinAutomata(UnicodeUtil.NewString(m_termText, m_realPrefixLength, m_termText.Length - m_realPrefixLength), transpositions);

                for (int i = runAutomata.Count; i <= maxDistance; i++)
                {
                    Automaton a = builder.ToAutomaton(i);
                    //System.out.println("compute automaton n=" + i);
                    // constant prefix
                    if (m_realPrefixLength > 0)
                    {
                        Automaton prefix = BasicAutomata.MakeString(UnicodeUtil.NewString(m_termText, 0, m_realPrefixLength));
                        a = BasicOperations.Concatenate(prefix, a);
                    }
                    runAutomata.Add(new CompiledAutomaton(a, true, false));
                }
            }
            return(runAutomata);
        }