Exemple #1
0
    public override void Load()
    {
        path = Application.persistentDataPath + "\\" + filePath;

        // On récupère notre QTable si elle existe déjà
        try
        {
            BinaryFormatter formatter = new BinaryFormatter();
            Stream          stream    = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
            qTable = (QTable)formatter.Deserialize(stream);
            stream.Close();
            stream.Dispose();

            // Si elle n'existe pas, on l'initialise :)
        } catch (Exception e) {
            Debug.LogError(e.Message);
            // Initialiser la QTable
            qTable = new QTable();
            foreach (GameState gs in GameState.AllStates())
            {
                foreach (MyInput input in MyInput.AllInputs())
                {
                    qTable.table.Add(new QValue(gs, input));
                }
            }
        }
        Debug.Log("Taille de la QTable = " + qTable.table.Count);
    }
Exemple #2
0
        //-------------------------------------------------------------------//
        /// <summary>
        ///     This function applies data received from Q process to in-memory cache.
        ///     All operations are structured in a way that only data that has been subscribed is kept,
        ///     i.e.: data from columns that were not requested is simply discarded.
        /// </summary>
        /// <param name="alias">alias of the connection producing the data</param>
        /// <param name="table">name of the table</param>
        /// <param name="data">table data</param>
        private static void UpdateCache(string alias, string table, QTable data)
        {
            var symIdx = data.GetColumnIndex(_symColName);
            var cols   = data.Columns;

            foreach (QTable.Row row in data)
            {
                var ra      = row.ToArray();
                var symName = ra[symIdx].ToString();

                var symId = GetSymbolId(alias, table, symName);
                if (WildCardMapping.ContainsKey(alias) /*&& symId != null*/)
                {
                    for (var i = 0; i < cols.Length; i++)
                    {
                        Cache.UpdateData(alias, table, symName, cols[i], Conversions.Convert2Excel(ra[i]));

                        AllSymbols[alias][table].Add(symName);
                        if (symId == null)
                        {
                            continue;
                        }
                        if (!WildCardMapping[alias].ContainsColumn(table, symId, cols[i]))
                        {
                            continue;
                        }

                        foreach (var ti in WildCardMapping[alias].GetTopics(table, symId, cols[i]))
                        {
                            DataOut.AddOrUpdate(ti, "", (k, v) => "");
                            var val = string.IsNullOrEmpty(ti.History)
                                ? Conversions.Convert2Excel(ra[i])
                                : Cache.GetData(alias, table, symName, cols[i], ti.History);
                            ti.Topic.UpdateValue(val ?? ExcelEmpty.Value);
                        }
                    }
                }

                if (!Mapping.ContainsKey(alias) || !Mapping[alias].ContainsSymbol(table, symName))
                {
                    continue;
                }
                for (var i = 0; i < cols.Length; i++)
                {
                    if (!Mapping[alias].ContainsColumn(table, symName, cols[i]))
                    {
                        continue;
                    }
                    Cache.UpdateData(alias, table, symName, cols[i], Conversions.Convert2Excel(ra[i]));
                    foreach (var ti in Mapping[alias].GetTopics(table, symName, cols[i]))
                    {
                        DataOut.AddOrUpdate(ti, "", (k, v) => "");
                        var val = string.IsNullOrEmpty(ti.History)
                            ? Conversions.Convert2Excel(ra[i])
                            : Cache.GetData(alias, table, symName, cols[i], ti.History);
                        ti.Topic.UpdateValue(val ?? ExcelEmpty.Value);
                    }
                }
            }
        }
Exemple #3
0
        private static QTable ConvertToQTable <T>(IEnumerable <T> dataModels, Dictionary <string, PropertyInfo> propertiesDict, MappingContext cxt)
        {
            var rowCount = dataModels.Count();

            var columns         = propertiesDict.Keys.ToArray();
            var propertiesArray = propertiesDict.Values.ToArray();

            var data = new object[propertiesDict.Count];

            for (int i = 0; i < data.Length; ++i)
            {
                data[i] = Array.CreateInstance(ToQType(propertiesArray[i].PropertyType), rowCount);
            }

            int rowIndex = 0;
            var result   = new QTable(columns, data);

            foreach (var dataModel in dataModels)
            {
                for (int propIndex = 0; propIndex < propertiesArray.Length; propIndex++)
                {
                    var propInfo       = propertiesArray[propIndex];
                    var dataModelValue = cxt.TypeAccessor[dataModel, propInfo.Name];
                    ((Array)data.GetValue(propIndex)).SetValue(ToQObject(dataModelValue, propInfo), rowIndex);
                }

                rowIndex++;
            }
            return(result);
        }
        private async Task DoSelectAsync <T>(QTable <T> tb, bool single = false, bool singleOrDefault = false, bool first = false) where T : class
        {
            if (single)
            {
                await tb.SingleAsync();
            }
            if (singleOrDefault)
            {
                await tb.SingleOrDefaultAsync();
            }
            if (first)
            {
                await tb.FirstAsync();
            }
            await tb.FirstOrDefaultAsync();

            await tb.SelectAsync();

            await tb.SelectAsync(10);

            await tb.SelectAsync(2, 10);

            await tb.PageAsync(2, 10);

            //Microsoft.Data.Sqlite Bug
            //https://github.com/aspnet/Microsoft.Data.Sqlite/issues/435
            //await tb.ExecuteDataTableAsync();
        }
Exemple #5
0
        public void TestQTable()
        {
            var columns = new[] { "pos", "dates" };
            var data    = new object[] { new[] { "d1", "d2", "d3" }, new[] { 1001, 1002, 1003 } };

            var t = new QTable(columns, data);

            Assert.AreEqual(t, new QTable(columns, data));

            Assert.IsTrue(t.HasColumn("pos"));
            Assert.IsFalse(t.HasColumn("unknown"));

            Assert.AreEqual(1, t.GetColumnIndex("dates"));
            Assert.Throws <NullReferenceException>(() => t.GetColumnIndex("unknown"));

            int i = 0;
            var e = t.GetEnumerator();

            while (e.MoveNext())
            {
                var r = e.Current;
                Assert.AreEqual(t[i].ToArray(), r.ToArray());
                i++;
            }

            Assert.AreEqual(i, t.RowsCount);
        }
    public void importQtableText(QTable qtable)
    {
        // open a reading session
        StreamReader readObj = new StreamReader(textFPath);
        string       currentValue;
        int          CurrentNumValue;

        while ((currentValue = readObj.ReadLine()) == (null) || (currentValue = readObj.ReadLine()) == "")
        {
        }

        for (int i = 0; i < 15; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                // write to textFile
                Debug.Log(currentValue);
                int.TryParse(currentValue, out CurrentNumValue);
                // update the qtable with values from textFile
                qtable.qTable[i, j] = CurrentNumValue;
                currentValue        = readObj.ReadLine();
            }
        }
        // close reading session
        readObj.Close();
    }
Exemple #7
0
        /// <summary>
        /// 获取组
        /// </summary>
        /// <param name="joinTable"></param>
        /// <param name="incDisabled"></param>
        /// <param name="incUnVisible"></param>
        /// <param name="p_pgids"></param>
        /// <returns></returns>
        protected DataTable DoGetGroups(QTable joinTable, bool incDisabled, bool incUnVisible, params int[] p_pgids)
        {
            if (p_pgids == null || p_pgids.Length < 1)
            {
                return(null);
            }

            //-------------------------------------
            GroupM g  = new GroupM();
            SQuery SQ = new SQuery();

            SQ.From(g.NoLock());

            if (joinTable != null)
            {
                SQ.InnerJoin(joinTable.NoLock()).On(g.PGID == joinTable["PGID"]);
            }

            SQ.Where(g.P_PGID.In(p_pgids));

            if (incDisabled == false)
            {
                SQ.And(g.Is_Disabled != 1);
            }

            if (incUnVisible == false)
            {
                SQ.And(g.Is_Visibled != 0);
            }

            return(SQ.OrderBy(g.Order_Index)
                   .Select());
        }
        public void StoreInfo(QData data)
        {
            var qt = new QTable {
                Name = "a_Tes", Comment = "", Pk = "Id", PkComment = "Идентификатор"
            };

            RootType.StoreInfo(qt, null, "", null, "a_Tes_", null, data);
        }
Exemple #9
0
 public void Join(QTable table, JoinType joinType = JoinType.Inner)
 {
     if (_jump)
     {
         _jump = false; return;
     }
     this.AddTable(table);
     table._joinType = joinType;
 }
Exemple #10
0
 internal void AddTable(QTable table)
 {
     _tables.Add(table);
     table._asName = "t" + _tables.Count;
     if (string.IsNullOrEmpty(table._schemaName) == false)
     {
         SetUsedSchemaName();
     }
 }
Exemple #11
0
 public void FullJoin(QTable table)
 {
     if (_jump)
     {
         _jump = false; return;
     }
     this.AddTable(table);
     table._joinType = JoinType.Full;
 }
Exemple #12
0
 public void RightJoin(QTable table)
 {
     if (_jump)
     {
         _jump = false; return;
     }
     this.AddTable(table);
     table._joinType = JoinType.Right;
 }
 public void LeftJoin(QTable table)
 {
     if (_jump)
     {
         _jump = false; return;
     }
     AddTable(table);
     table._joinType = JoinType.Left;
 }
 public void InnerJoin(QTable table)
 {
     if (_jump)
     {
         _jump = false; return;
     }
     AddTable(table);
     table._joinType = JoinType.Inner;
 }
Exemple #15
0
 private static void AssignToPropertyFromQColumn <T>(MappingContext cxt, QTable table, T[] result, int row)
 {
     for (int col = 0; col < table.Data.Length; ++col)
     {
         Array x        = (Array)table.Data.GetValue(col);
         var   propName = cxt.ColumnsToProperties[table.Columns[col]];
         cxt.TypeAccessor[result[row], propName.Name] = x.GetValue(row);
     }
 }
Exemple #16
0
 public void FullJoin(QTable table, QJoinCondition @on)
 {
     if (_jump)
     {
         _jump = false; return;
     }
     this.AddTable(table);
     table._joinType      = JoinType.Full;
     table._joinCondition = @on;
 }
 public void InnerJoin(QTable table, QJoinCondition @on)
 {
     if (_jump)
     {
         _jump = false; return;
     }
     AddTable(table);
     table._joinType      = JoinType.Inner;
     table._joinCondition = @on;
 }
 public void Join(QTable table, JoinType joinType, QJoinCondition @on)
 {
     if (_jump)
     {
         _jump = false; return;
     }
     AddTable(table);
     table._joinType      = joinType;
     table._joinCondition = @on;
 }
Exemple #19
0
        public void setUp()
        {
            // simple qlearning example from
            // http://people.revoledu.com/kardi/tutorial/ReinforcementLearning/index.
            // html
            // List<String> states = Arrays.asList(new String[] { "A", "B", "C",
            // "D",
            // "E", "F" });
            List<String> actions = new List<String>() { "toA", "toB",
				"toC", "toD", "toE", "toF" };
            qt = new QTable<String, String>(actions);
        }
Exemple #20
0
        private static T[] FromQTable <T>(MappingContext cxt, QTable table)
        {
            var result = new T[table.RowsCount];

            for (int row = 0; row < result.Length; ++row)
            {
                result[row] = Activator.CreateInstance <T>();
                AssignToPropertyFromQColumn(cxt, table, result, row);
            }

            return(result);
        }
        public QLearningOrientationOffsetHandler(
            float minOffset   = -180, float maxOffset    = 180, float offsetIncrements   = 1,
            float minThrottle = -0.3f, float maxThrottle = 0.3f, float throttleIncrement = 0.01f
            )
        {
            MinThrottle       = minThrottle;
            MaxThrottle       = maxThrottle;
            ThrottleIncrement = throttleIncrement;

            this.qTable  = new QTable(minOffset, maxOffset, offsetIncrements, minThrottle, maxThrottle, throttleIncrement);
            this.isFirst = true;
        }
Exemple #22
0
 protected override string GetTableName(string tableName)
 {
     if (SqlClientFactory.NameBrackets)
     {
         QTable table = (QTable)tableName;
         if (!String.IsNullOrEmpty(table.Alias))
         {
             return(FormatInBrackets(table.Name) + " " + table.Alias);
         }
         return(FormatInBrackets(table.Name));
     }
     return(base.GetTableName(tableName));
 }
Exemple #23
0
        public static void RenderEnvironment(
            QTable qtable,
            State state)
        {
            _canvas.Dispatcher.Invoke(
                () =>
            {
                foreach (var field in _maze.Fields)
                {
                    UpdateField(field, qtable, state);
                }

                var mw = (MainWindow)Application.Current.MainWindow;
                mw.UpdateLayout();
            });
        }
Exemple #24
0
        public void setUp()
        {
            // simple qlearning example from
            // http://people.revoledu.com/kardi/tutorial/ReinforcementLearning/index.
            // html
            // List<String> states = Arrays.asList(new String[] { "A", "B", "C",
            // "D",
            // "E", "F" });
            List <String> actions = new List <String>()
            {
                "toA", "toB",
                "toC", "toD", "toE", "toF"
            };

            qt = new QTable <String, String>(actions);
        }
Exemple #25
0
        private static void UpdateField(MazeField field, QTable qtable, State state)
        {
            var qCells = qtable.Cells.Where(f => f.State.Column == field.Column && f.State.Row == field.Row);

            var rect = _canvas.Children.OfType <Rectangle>().Single(f => f.Tag == field);

            rect.Fill = MapBrush(field, state);

            var dp         = _canvas.Children.OfType <DockPanel>().Single(f => f.Tag == field);
            var textBlocks = dp.Children.OfType <TextBlock>();

            foreach (var txb in textBlocks)
            {
                var action = (Domain.Models.Action)txb.Tag;
                var qValue = Math.Round(qCells.Single(f => f.Action == action).QValue, 2).ToString(CultureInfo.InvariantCulture);
                txb.Text = qValue;
            }
        }
    void Start()
    {
        dataObj     = GetComponent <DataCollect>();
        lookupTable = GetComponent <QTable>();

        lookupTable.qTableInit();



        positions       = dataObj.getPositions();
        directionsTaken = dataObj.getdDirectionTaken();
        distToGoal      = dataObj.getDistToGoal();
        canMoveLeft     = dataObj.getCanMoveLeft();
        canMoveRight    = dataObj.getCanMoveRight();
        canMoveBack     = dataObj.getCanMoveBack();
        canMoveForward  = dataObj.getCanMoveForward();
        rewardGiven     = dataObj.getRewardGiven();
    }
    void Start()
    {
        energyScriptRef = energyBarr.GetComponent <energyScript>();
        lookupTable     = GetComponent <QTable>();
        lookupTable.qTableInit();
        tableMessenger = GetComponent <TextWriteTest>();
        // keep reference to numIterations alive when scene reload
        variableForPrefab      = Resources.Load("prefabs/MainCube", typeof(GameObject)) as GameObject;
        numIterationsScriptRef = variableForPrefab.GetComponent <numIterationsScript>();
        // run the read function to update Qtable from local text files
        read();
        numIterationsScriptRef.numIterations += 1;    // increment numIterations
        completeText.text = "";
        StartCoroutine(runStartText());

        // if aiEnabled = false hide the aiCube and render in the playerCube
        if (aiEnabled == false)
        {
            cube.SetActive(false);
            CubeController scriptRef = GetComponent <CubeController>();
            scriptRef.enabled = false;  // disable the mlScript so computations dont use resources in background
        }
        if (playerEnabled == false)
        {
            //playerCube.SetActive(false);
            GameObject.Destroy(playerCube);
            //CubeController scriptRefTwo = GetComponent<playerController>();
            //scriptRefTwo.enabled = false;
        }
        else
        {
            aiCam.enabled = false;
        }
        dataObj         = GetComponent <DataCollect>();
        positions       = dataObj.getPositions();
        directionsTaken = dataObj.getdDirectionTaken();
        distToGoal      = dataObj.getDistToGoal();
        canMoveLeft     = dataObj.getCanMoveLeft();
        canMoveRight    = dataObj.getCanMoveRight();
        canMoveBack     = dataObj.getCanMoveBack();
        canMoveForward  = dataObj.getCanMoveForward();
        rewardGiven     = dataObj.getRewardGiven();
    }
Exemple #28
0
        //-------------------------------------------------------------------//
        private static object[,] QTable2Excel(QTable table)
        {
            var res = new object[table.RowsCount + 1, table.ColumnsCount];

            for (var i = 0; i < table.ColumnsCount; i++)
            {
                for (var j = 0; j < table.RowsCount + 1; j++)
                {
                    if (j == 0) //write header
                    {
                        res[j, i] = table.Columns.GetValue(i).ToString();
                    }
                    else //write data
                    {
                        res[j, i] = Convert2Excel(((Array)table.Data.GetValue(i)).GetValue(j - 1));
                    }
                }
            }
            return(res);
        }
        public void testQLearningAgent()
        {
            QLearningAgent <CellWorldPosition, String> qla = new QLearningAgent <CellWorldPosition, string>(
                fourByThree);
            Randomizer r = new MockRandomizer(new double[] { 0.1, 0.9, 0.2, 0.8,
                                                             0.3, 0.7, 0.4, 0.6, 0.5 });

            // Randomizer r = new JavaRandomizer();
            Dictionary <Pair <CellWorldPosition, String>, Double> q = null;
            QTable <CellWorldPosition, String> qTable = null;

            for (int i = 0; i < 100; i++)
            {
                qla.executeTrial(r);
                q      = qla.getQ();
                qTable = qla.getQTable();
            }
            // qTable.normalize();
            // System.Console.WriteLine(qTable);
            // System.Console.WriteLine(qTable.getPolicy());
        }
        static void PrintResult(QTable t, Func <string, Task> func)
        {
            var rowsToShow  = Math.Min(t.RowsCount, 20);
            var dataBuffer  = new object[1 + rowsToShow][];
            var columnWidth = new int[t.ColumnsCount];

            dataBuffer[0] = new string[t.ColumnsCount];
            for (int j = 0; j < t.ColumnsCount; j++)
            {
                dataBuffer[0][j] = t.Columns[j];
                columnWidth[j]   = t.Columns[j].Length + 1;
            }

            for (int i = 1; i < rowsToShow; i++)
            {
                dataBuffer[i] = new string[t.ColumnsCount];
                for (int j = 0; j < t.ColumnsCount; j++)
                {
                    var value = t[i - 1][j].ToString();
                    dataBuffer[i][j] = value;
                    columnWidth[j]   = Math.Max(columnWidth[j], value.Length + 1);
                }
            }

            var formatting = "";

            for (int i = 0; i < columnWidth.Length; i++)
            {
                formatting += "{" + i + ",-" + columnWidth[i] + "}";
            }

            Console.WriteLine(formatting, dataBuffer[0]);
            Console.WriteLine(new string('-', columnWidth.Sum()));
            for (int i = 1; i < rowsToShow; i++)
            {
                Console.WriteLine(formatting, dataBuffer[i]);
                func(dataBuffer[i].ToString());
            }
        }
 private void DoSelect <T, OutT>(QTable <T> tb, bool single = false, bool singleOrDefault = false, bool first = false)
     where T : class
     where OutT : class
 {
     if (single)
     {
         tb.Single <OutT>();
     }
     if (singleOrDefault)
     {
         tb.SingleOrDefault <OutT>();
     }
     if (first)
     {
         tb.First <OutT>();
     }
     tb.FirstOrDefault <OutT>();
     tb.Select <OutT>();
     tb.Select <OutT>(10);
     tb.Select <OutT>(2, 10);
     tb.Page <OutT>(2, 10);
 }
Exemple #32
0
        public void TestQDictionary()
        {
            string[] keys = new string[] { "foo", "bar", "z" };
            object[] values = new object[] { 1, "val", null };

            var d = new QDictionary(keys, values);
            Assert.IsTrue(d.Equals(new QDictionary(keys, values)));

            var e = d.GetEnumerator();
            int i = 0;
            while (e.MoveNext())
            {
                var kv = e.Current;
                Assert.AreEqual(keys[i], kv.Key);
                Assert.AreEqual(values[i], kv.Value);
                i++;
            }

            Assert.AreEqual(i, d.Count);

            var table = new QTable(new[] { "eid" }, new object[] { new[] { 1001, 1002, 1003 } });
            d = new QDictionary(keys, table);
            Assert.IsTrue(d.Equals(new QDictionary(keys, table)));

            e = d.GetEnumerator();
            i = 0;
            while (e.MoveNext())
            {
                var kv = e.Current;
                Assert.AreEqual(keys[i], kv.Key);
                Assert.AreEqual(table[i].ToArray(), ((QTable.Row)kv.Value).ToArray());
                i++;
            }

            Assert.AreEqual(i, d.Count);
        }
Exemple #33
0
        /// <summary>
        /// Generates a <see cref="QLearnerModel"/> based on states/actions with transitions and rewards.
        /// </summary>
        /// <param name="X1">Initial State matrix.</param>
        /// <param name="y">Action label vector.</param>
        /// <param name="X2">Transition State matrix.</param>
        /// <param name="r">Reward values.</param>
        /// <returns>QLearnerModel.</returns>
        public override IReinforcementModel Generate(Matrix X1, Vector y, Matrix X2, Vector r)
        {
            this.Preprocess(X1, y, X2, r);

            var examples = MDPConverter.GetStates(X1, y, X2, this.FeatureProperties, this.FeatureDiscretizer);

            var states = examples.Item1; var actions = examples.Item2; var statesP = examples.Item3;

            QTable Q = new QTable();

            // construct Q table
            for (int i = 0; i < states.Count(); i++)
            {
                var state = states.ElementAt(i);
                var action = actions.ElementAt(i);
                var stateP = statesP.ElementAt(i);

                Q.AddOrUpdate(state, action, r[i]);

                if (!Q.ContainsKey(stateP))
                    Q.AddKey(stateP);
            }

            double count = states.Select(s => s.Id).Distinct().Count();

            double change = 0;
            for (int pass = 0; pass < this.MaxIterations; pass++)
            {
                change = 0;

                for (int i = 0; i < states.Count(); i++)
                {
                    IState state = states.ElementAt(i);
                    IAction action = actions.ElementAt(i);
                    IState stateP = statesP.ElementAt(i);
                    double reward = r[i];

                    double q = (1.0 - this.LearningRate) * Q[state, action]
                                        + this.LearningRate * (reward + this.Lambda * Q[stateP, Q.GetMaxAction(stateP)]);

                    change += (1.0 / count) * System.Math.Abs((Q[state, action] - q));

                    Q[state, action] = q;
                }

                if (change <= this.Epsilon)
                    break;
            }

            return new QLearnerModel()
            {
                Descriptor = this.Descriptor,
                TransitionDescriptor = this.TransitionDescriptor,
                NormalizeFeatures = this.NormalizeFeatures,
                FeatureNormalizer = this.FeatureNormalizer,
                FeatureProperties = this.FeatureProperties,
                FeatureDiscretizer = this.FeatureDiscretizer,
                LearningRate = this.LearningRate,
                Lambda = this.Lambda,
                Q = Q
            };
        }
Exemple #34
0
        public void TestQTable()
        {
            var columns = new[] { "pos", "dates" };
            var data = new object[] { new[] { "d1", "d2", "d3" }, new[] { 1001, 1002, 1003 } };

            var t = new QTable(columns, data);
            Assert.AreEqual(t, new QTable(columns, data));

            Assert.IsTrue(t.HasColumn("pos"));
            Assert.IsFalse(t.HasColumn("unknown"));

            Assert.AreEqual(1, t.GetColumnIndex("dates"));
            Assert.Throws<NullReferenceException>(() => t.GetColumnIndex("unknown"));

            int i = 0;
            var e = t.GetEnumerator();

            while (e.MoveNext())
            {
                var r = e.Current;
                Assert.AreEqual(t[i].ToArray(), r.ToArray());
                i++;
            }

            Assert.AreEqual(i, t.RowsCount);
        }
Exemple #35
0
        public void TestCompressedObjectDeserializationQ2()
        {
            var expressions =
                new QExpressions(new Dictionary<string, string> {{"q2", "..\\..\\test\\QCompressedExpressions.out"}});
            var reference = new Dictionary<string, object>();

            var q1000 = new string[1000];
            var q200 = new object[] {new int[200], new int[200], new string[200]};
            for (int i = 0; i < q1000.Length; i++)
            {
                q1000[i] = "q";
            }
            for (int i = 0; i < 200; i++)
            {
                ((int[]) q200[0])[i] = i;
                ((int[]) q200[1])[i] = i + 25;
                ((string[]) q200[2])[i] = "a";
            }

            reference["1000#`q"] = q1000;
            reference["([] q:1000#`q)"] = new QTable(new[] {"q"}, new object[] {q1000});
            reference["([] a:til 200;b:25+til 200;c:200#`a)"] = new QTable(new[] {"a", "b", "c"}, q200);

            foreach (string expr in expressions.GetExpressions("q2"))
            {
                var stream = new MemoryStream();
                var writer = new BinaryWriter(stream);
                var reader = new QReader(stream, Encoding.ASCII, QBasicConnection.DefaultMaxReadingChunk);
                byte[] binaryExpr = expressions.GetBinaryExpression("q2", expr);
                writer.Write((byte) 1); // little endian
                writer.Write((byte) 0);
                writer.Write((byte) 1); // compressed
                writer.Write((byte) 0);
                writer.Write(binaryExpr.Length + 8);
                writer.Write(binaryExpr);
                writer.Flush();
                stream.Seek(0, SeekOrigin.Begin);

                try
                {
                    object obj = reader.Read().Data;
                    if (obj is QDictionary || obj is QTable || obj is QLambda)
                    {
                        // force usage of Equals method
                        Assert.IsTrue(reference[expr].Equals(obj), "Deserialization failed for q expression: " + expr);
                    }
                    else
                    {
                        Assert.AreEqual(reference[expr], obj, "Deserialization failed for q expression: " + expr);
                    }
                }
                catch (System.Exception e)
                {
                    Assert.Fail("Deserialization failed for q expression: " + expr + " caused by: " + e);
                }
                finally
                {
                    stream.Close();
                }
            }
        }
        static void PrintResult(QTable t)
        {
            var rowsToShow = Math.Min(t.RowsCount + 1, 20);
            var dataBuffer = new object[1 + rowsToShow][];
            var columnWidth = new int[t.ColumnsCount];

            dataBuffer[0] = new string[t.ColumnsCount];
            for (int j = 0; j < t.ColumnsCount; j++)
            {
                dataBuffer[0][j] = t.Columns[j];
                columnWidth[j] = t.Columns[j].Length + 1;
            }

            for (int i = 1; i < rowsToShow; i++)
            {
                dataBuffer[i] = new string[t.ColumnsCount];
                for (int j = 0; j < t.ColumnsCount; j++)
                {
                    var value = t[i - 1][j].ToString();
                    dataBuffer[i][j] = value;
                    columnWidth[j] = Math.Max(columnWidth[j], value.Length + 1);
                }
            }

            var formatting = "";
            for (int i = 0; i < columnWidth.Length; i++)
            {
                formatting += "{" + i + ",-" + columnWidth[i] + "}";
            }

            Console.WriteLine(formatting, dataBuffer[0]);
            Console.WriteLine(new string('-', columnWidth.Sum()));
            for (int i = 1; i < rowsToShow; i++)
            {
                Console.WriteLine(formatting, dataBuffer[i]);
            }
        }