/// <summary>
        /// Matrix ^ scalar
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public QsMatrix PowerScalar(QsScalar value)
        {
            QsMatrix Total = (QsMatrix)this.Identity; //first get the identity matrix of this matrix.

            int count = Qs.IntegerFromQsValue(value);

            if (count > 0)
            {
                for (int i = 1; i <= count; i++)
                {
                    Total = Total.MultiplyMatrix(this);
                }
            }
            else if (count == 0)
            {
                return(Total);   //which id identity already
            }
            else
            {
                count = Math.Abs(count);
                for (int i = 1; i <= count; i++)
                {
                    Total = Total.MultiplyMatrix(this.Inverse);    //multiply the inverses many times
                }
            }

            return(Total);
        }
예제 #2
0
 protected internal Base(ConnectionStringSettings connectionStringSettings, string fileTable, string hashTable, bool debugMode)
 {
     _fileTable   = new Regex(@"[^a-zA-Z0-9\._-]").Replace(fileTable.Trim(), "");
     _hashTable   = hashTable;
     qs           = new Qs(connectionStringSettings);
     qs.DebugMode = debugMode;
 }
        override public void initialize()
        {
            setProblemClass();

            int total_nodes = this.Ranks.Length;

            maxcells = Convert.ToInt32(Math.Sqrt(total_nodes));
            ncells   = Convert.ToInt32(Math.Sqrt(total_nodes));

            MAX_CELL_DIM     = (problem_size / maxcells) + 1;
            IMAX             = JMAX = KMAX = MAX_CELL_DIM;
            _grid_points_[0] = _grid_points_[1] = _grid_points_[2] = problem_size;
            IMAXP            = IMAX / 2 * 2 + 1;
            JMAXP            = JMAX / 2 * 2 + 1;

            set_constants(0, dt_default);

            U.initialize_field("u", maxcells, KMAX + 4, JMAXP + 4, IMAXP + 4, 5);
            Rhs.initialize_field("rhs", maxcells, KMAX + 2, JMAXP + 2, IMAXP + 2, 5);
            Lhs.initialize_field("lhs", maxcells, KMAX + 2, JMAXP + 2, IMAXP + 2, 15);
            Forcing.initialize_field("forcing", maxcells, KMAX + 2, JMAXP + 2, IMAXP + 2, 5);

            Us.initialize_field("us", maxcells, KMAX + 3, JMAX + 3, IMAX + 3);
            Vs.initialize_field("vs", maxcells, KMAX + 3, JMAX + 3, IMAX + 3);
            Ws.initialize_field("ws", maxcells, KMAX + 3, JMAX + 3, IMAX + 3);
            Qs.initialize_field("qs", maxcells, KMAX + 3, JMAX + 3, IMAX + 3);
            Ainv.initialize_field("ainv", maxcells, KMAX + 3, JMAX + 3, IMAX + 3);
            Rho.initialize_field("rho", maxcells, KMAX + 3, JMAX + 3, IMAX + 3);
            Speed.initialize_field("speed", maxcells, KMAX + 3, JMAX + 3, IMAX + 3);
            Square.initialize_field("square", maxcells, KMAX + 3, JMAX + 3, IMAX + 3);

            //Lhsa.initialize_field("lhsa", maxcells, KMAX+2, JMAXP+2, IMAXP+2, 15);
            //Lhsb.initialize_field("lhsb", maxcells, KMAX+2, JMAXP+2, IMAXP+2, 15);
            //Lhsc.initialize_field("lhsc", maxcells, KMAX+2, JMAXP+2, IMAXP+2, 15);
        }
        public QsValue StdDeviation(int fromIndex, int toIndex)
        {
            var n = toIndex - fromIndex + 1;

            if (this.Parameters.Length > 0)
            {
                throw new QsException("Standard Deviation with symbolic quantities (I think you went so far ^_^ )", new NotImplementedException());
            }
            else
            {
                FixIndices(ref fromIndex, ref toIndex);
                var     mean  = Average(fromIndex, toIndex);
                var     Two   = "2".ToScalarValue();
                QsValue Total = (GetElementValue(fromIndex) - mean).PowerOperation(Two);
                for (int i = fromIndex + 1; i <= toIndex; i++)
                {
                    var p   = GetElementValue(i) - mean;
                    var pp2 = p.PowerOperation(Two);
                    Total = Total + pp2;
                }
                var count = new QsScalar {
                    NumericalQuantity = Qs.ToQuantity((double)n)
                };

                return(Total / count);
            }
        }
예제 #5
0
        public override QsValue RightShiftOperation(QsValue times)
        {
            int itimes = Qs.IntegerFromQsValue((QsScalar)times);

            if (itimes > this.Text.Length)
            {
                itimes = itimes % this.Text.Length;
            }

            // 1 2 3 4 5 >> 2  == 4 5 1 2 3

            StringBuilder vec = new StringBuilder(this.Text.Length);

            for (int i = this.Text.Length - itimes; i < this.Text.Length; i++)
            {
                vec.Append(this.Text[i]);
            }

            for (int i = 0; i < (this.Text.Length - itimes); i++)
            {
                vec.Append(this.Text[i]);
            }


            return(new QsText(vec.ToString()));
        }
예제 #6
0
        public void ToStringTests()
        {
            Helper.RunWithMultipleSimulators((qsim) =>
            {
                var _ = AbstractCallable._;

                var dump  = qsim.Get <ICallable>(typeof(Microsoft.Quantum.Extensions.Diagnostics.DumpMachine <>));
                var trace = qsim.Get <IUnitary>(typeof(Circuits.Generics.Trace <>));
                var x     = qsim.Get <Intrinsic.X>();
                var q2    = new FreeQubit(2) as Qubit;
                var Q     = new Q(q2);
                var Qs    = new QArray <Qubit>(q2);
                var qs    = new Qs(Qs);
                var udtOp = new U3(x);
                var udtQ  = new Q(q2);
                var t1    = new QTuple <(long, Range, (Qubit, IUnitary))>((1L, new Range(10, -2, 4), (q2, x)));
                var t4    = new T4((3L, (1.1, false, Result.One)));
                var t5    = new T5((Pauli.PauliX, Qs, qs, Q));

                var d_1 = dump.Partial(_);
                var d_2 = d_1.Partial(_);
                var x_1 = x.Partial(new Func <Qubit, Qubit>(q => q));
                var x_2 = x_1.Partial(new Func <Qubit, Qubit>(q => q));
                var x_3 = x.Partial <OperationPartial <Qubit, Qubit, QVoid> >(_);

                var t_1 = trace.Adjoint.Partial(_);
                var t_2 = t_1.Controlled.Partial(_);

                Assert.Equal("()", QVoid.Instance.ToString());
                Assert.Equal("_", _.ToString());
                Assert.Equal("U3(X)", udtOp.ToString());
                Assert.Equal("q:2", q2.ToString());
                Assert.Equal("Q(q:2)", udtQ.ToString());
                Assert.Equal("(1, 10..-2..4, (q:2, X))", t1.ToString());
                Assert.Equal("T4((3, (1.1, False, One)))", t4.ToString());
                Assert.Equal("T5((PauliX, [q:2], Qs([q:2]), Q(q:2)))", t5.ToString());
                Assert.Equal("X", x.ToString());
                Assert.Equal("(Adjoint X)", x.Adjoint.ToString());
                Assert.Equal("(Controlled X)", x.Controlled.ToString());
                Assert.Equal("(Adjoint (Controlled X))", x.Controlled.Adjoint.ToString());
                Assert.Equal("(Controlled (Adjoint X))", x.Adjoint.Controlled.ToString());
                Assert.Equal("X{_}", x_1.ToString());
                Assert.Equal("(Adjoint X{_})", x_1.Adjoint.ToString());
                Assert.Equal("X{_}{_}", x_2.ToString());
                Assert.Equal("X{_}", x_3.ToString());
                Assert.Equal("DumpMachine", dump.ToString());
                Assert.Equal("DumpMachine{_}", d_1.ToString());
                Assert.Equal("DumpMachine{_}{_}", d_2.ToString());
                Assert.Equal("Trace", trace.ToString());
                Assert.Equal("(Adjoint Trace)", trace.Adjoint.ToString());
                Assert.Equal("(Controlled Trace)", trace.Controlled.ToString());
                Assert.Equal("(Adjoint (Controlled Trace))", trace.Controlled.Adjoint.ToString());
                Assert.Equal("(Adjoint Trace){_}", t_1.ToString());
                Assert.Equal("(Adjoint (Controlled (Adjoint Trace){_}){_})", t_2.Adjoint.ToString());
            });
        }
예제 #7
0
        public QsValue Average(int fromIndex, int toIndex, QsValue arg0, QsValue arg1, QsValue arg2, QsValue arg3)
        {
            FixIndices(ref fromIndex, ref toIndex);

            var tot   = SumElements(fromIndex, toIndex, arg0, arg1, arg2, arg3);
            var n     = toIndex - fromIndex + 1;
            var count = new QsScalar {
                NumericalQuantity = Qs.ToQuantity((double)n)
            };

            return(tot / count);
        }
예제 #8
0
        /// <summary>
        /// QsValue ^x QsValue
        /// Power of multiple cross product operations
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        virtual public QsValue PowerCrossOperation(QsValue value)
        {
            QsValue Total = this.Identity;

            int count = Qs.IntegerFromQsValue((QsScalar)value);

            for (int i = 1; i <= count; i++)
            {
                Total = Total.CrossProductOperation(this);
            }

            return(Total);
        }
예제 #9
0
        public void CreateName()
        {
            if (Qs.Count > 0)
            {
                foreach (var q in Qs.OrderBy(o => o.Order))
                {
                    Name += $"{q.Q},";
                }

                Name = Name.TrimEnd(',');
                Name = "{" + Name + "}";
            }
        }
예제 #10
0
        public SettingUp()
        {
            Zipfile = "twitterdata.zip";
            //testdata file
            //CSVfile= "testdata.manual.2009.06.14.csv";

            //real data - large file
            CSVfile          = "training.1600000.processed.noemoticon.csv";
            DBname           = "TwitterTextDb";
            CollectionName   = "TweetDocs";
            host             = DetectDockerBridgeGateWay();
            port             = ":27017";
            ConnectionString = "mongodb://" + host + port;
            client           = new MongoClient(ConnectionString);
            mdb        = client.GetDatabase(DBname);
            collection = mdb.GetCollection <TwitterData>(CollectionName);
            queries    = new Qs(collection);
        }
예제 #11
0
        public void QSharpTypeTests()
        {
            Helper.RunWithMultipleSimulators((qsim) =>
            {
                var _ = AbstractCallable._;

                var x      = qsim.Get <Intrinsic.X>();
                var q2     = new FreeQubit(2) as Qubit;
                var Q      = new Q(q2);
                var Qs     = new QArray <Qubit>(q2);
                var qs     = new Qs(Qs);
                var udtOp  = new U3(x);
                var udtQ   = new Q(q2);
                var t4     = new T4((3L, (1.1, false, Result.One)));
                var t5     = new T5((Pauli.PauliX, Qs, qs, Q));
                var plain  = qsim.Get <BPlain1>();
                var adj    = qsim.Get <BAdj1>();
                var ctrl   = qsim.Get <BCtrl1>();
                var mapper = qsim.Get <Circuits.ClosedType.Map>();

                Assert.Equal("()", typeof(QVoid).QSharpType());
                Assert.Equal("_", _.GetType().QSharpType());
                Assert.Equal("U3", udtOp.GetType().QSharpType());
                Assert.Equal("Qubit => () : Adjoint, Controlled", udtOp.Data.GetType().QSharpType());
                Assert.Equal("Qubit", q2.GetType().QSharpType());
                Assert.Equal("Q", udtQ.GetType().QSharpType());
                Assert.Equal("Qubit", udtQ.Data.GetType().QSharpType());
                Assert.Equal("T4", t4.GetType().QSharpType());
                Assert.Equal("(Int,(Double,Boolean,Result))", t4.Data.GetType().QSharpType());
                Assert.Equal("T5", t5.GetType().QSharpType());
                Assert.Equal("(Pauli,Qubit[],Qs,Q)", t5.Data.GetType().QSharpType());
                Assert.Equal("Qubit => () : Adjoint, Controlled", x.GetType().QSharpType());
                Assert.Equal("Qubit => () : Adjoint, Controlled", x.Adjoint.GetType().QSharpType());
                Assert.Equal("(Qubit[],Qubit) => () : Adjoint, Controlled", x.Controlled.GetType().QSharpType());
                Assert.Equal("(Qubit[],Qubit) => () : Adjoint, Controlled", x.Controlled.Adjoint.GetType().QSharpType());
                Assert.Equal("(Int,Qubit,Callable) => ()", plain.GetType().QSharpType());
                Assert.Equal("(Int,(Qubit,Qubit,Qubit[]),Adjointable) => () : Adjoint", adj.GetType().QSharpType());
                Assert.Equal("(Int,Qs,Controllable) => () : Controlled", ctrl.GetType().QSharpType());
                Assert.Equal("(Callable,Result[]) => String[]", mapper.GetType().QSharpType());
            });
        }
예제 #12
0
        /// <summary>
        /// Take the average of the sequence.
        /// Corresponds To: S[i!!k]
        /// </summary>
        /// <param name="fromIndex"></param>
        /// <param name="toIndex"></param>
        /// <returns></returns>
        public QsValue Average(int fromIndex, int toIndex)
        {
            var n = toIndex - fromIndex + 1;

            if (this.Parameters.Length > 0)
            {
                // this is a call to form symbolic element
                // like g[n](x) ..> x^n
                // and calling g[0++2]
                //  the output should be x^0 + x^1 + x^2
                //  and be parsed into function  (QsFunction)


                string porma = string.Empty;  // the parameters separated by comma ','
                foreach (var prm in this.Parameters)
                {
                    porma += prm.Name + ", ";
                }
                porma = porma.TrimEnd(',', ' ');

                string FunctionBody = "(" + JoinElementsWithOperation(fromIndex, toIndex, "+") + ")/" + n.ToString(CultureInfo.InvariantCulture);

                string FunctionDeclaration = "_(" + porma + ") = " + FunctionBody;

                QsFunction qs = QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, FunctionDeclaration);

                return(qs);
            }
            else
            {
                FixIndices(ref fromIndex, ref toIndex);

                var tot = SumElements(fromIndex, toIndex);

                var count = new QsScalar {
                    NumericalQuantity = Qs.ToQuantity((double)n)
                };

                return(tot / count);
            }
        }
예제 #13
0
        public override QsValue LeftShiftOperation(QsValue vl)
        {
            QsValue times;

            if (vl is QsReference)
            {
                times = ((QsReference)vl).ContentValue;
            }
            else
            {
                times = vl;
            }

            int itimes = Qs.IntegerFromQsValue((QsScalar)times);

            int c = InitialValues.Count();

            if (itimes > c)
            {
                itimes = itimes % c;
            }


            QsTupleValue[] NewValues = new QsTupleValue[c];

            int ix = 0;

            for (int i = itimes; i < c; i++)
            {
                NewValues[ix] = InitialValues[i];
                ix++;
            }

            for (int i = 0; i < itimes; i++)
            {
                NewValues[ix] = InitialValues[i];
                ix++;
            }

            return(new QsFlowingTuple(NewValues));
        }
        public QsValue StdDeviation(int fromIndex, int toIndex, QsValue arg0, QsValue arg1, QsValue arg2)
        {
            var n = toIndex - fromIndex + 1;

            FixIndices(ref fromIndex, ref toIndex);
            var     mean  = Average(fromIndex, toIndex, arg0, arg1, arg2);
            var     Two   = "2".ToScalarValue();
            QsValue Total = (GetElementValue(fromIndex, arg0, arg1, arg2) - mean).PowerOperation(Two);

            for (int i = fromIndex + 1; i <= toIndex; i++)
            {
                var p   = GetElementValue(i, arg0, arg1, arg2) - mean;
                var pp2 = p.PowerOperation(Two);
                Total = Total + pp2;
            }
            var count = new QsScalar {
                NumericalQuantity = Qs.ToQuantity((double)n)
            };

            return(Total / count);
        }
예제 #15
0
        public override QsValue RightShiftOperation(QsValue vl)
        {
            QsValue times;

            if (vl is QsReference)
            {
                times = ((QsReference)vl).ContentValue;
            }
            else
            {
                times = vl;
            }


            int itimes = Qs.IntegerFromQsValue((QsScalar)times);

            if (itimes > this.Count)
            {
                itimes = itimes % this.Count;
            }

            // 1 2 3 4 5 >> 2  == 4 5 1 2 3

            QsVector vec = new QsVector(this.Count);

            for (int i = this.Count - itimes; i < this.Count; i++)
            {
                vec.AddComponent(this[i]);
            }

            for (int i = 0; i < (this.Count - itimes); i++)
            {
                vec.AddComponent(this[i]);
            }


            return(vec);
        }