private static void sort(ref double[][] inputs, ref double[] time, ref int[] output)
        {
            int[] idx = Matrix.Indices(0, inputs.Length);

            time = (double[])time.Clone();

            IComparer <double> comparer = new GeneralComparer(ComparerDirection.Descending);

            Array.Sort(time, idx, comparer);

            inputs = inputs.Submatrix(idx);
            output = output.Submatrix(idx);
        }
        public static Expression <Func <T, bool> > GetExpression <T>(this IDictionary <string, string> queryValues) where T : class
        {
            if (!queryValues.Any())
            {
                return(null);
            }
            var filteredQuery = FilterQuery(queryValues);
            var filters       = DeserializePropertiesValue(filteredQuery);

            var memberType = typeof(T);

            var stringFilters  = new List <FilterProperty <StringOperation> >();
            var generalFilters = new List <FilterProperty <GeneralOperation> >();


            foreach (var filter in filters)
            {
                var propertyName = memberType.GetProperty(filter.Key
                                                          .Replace(">", "")
                                                          .Replace("<", "")
                                                          .Replace("=", ""),
                                                          BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance)?.Name;

                if (string.IsNullOrEmpty(propertyName))
                {
                    continue;
                }

                if (filter.Value is string)
                {
                    stringFilters.AddFilter(propertyName, filter);
                }
                else
                {
                    var operation = (GeneralOperation)(
                        ((filter.Key.EndsWith(GeneralOperation.GreaterThan.GetKey()) ? 1 : 0)) |
                        ((filter.Key.EndsWith(GeneralOperation.LessThan.GetKey()) ? 1 : 0) << 1) |
                        ((filter.Key.EndsWith(GeneralOperation.GreaterOrEqualThan.GetKey()) ? 1 : 0) << 2) |
                        ((filter.Key.EndsWith(GeneralOperation.LessOrEqualThan.GetKey()) ? 1 : 0) << 3)
                        );
                    generalFilters.Add(new FilterProperty <GeneralOperation>
                    {
                        Key       = propertyName,
                        Value     = filter.Value,
                        Operation = operation,
                        ConcatenationOperation = filter.ConcatenationOperation
                    });
                }
            }
            if (!stringFilters.Any() && !generalFilters.Any())
            {
                return(null);
            }
            var filterQuery = Operations.StringComparer.GetQuery(stringFilters, "", new List <object>());

            filterQuery       = GeneralComparer.GetQuery(generalFilters, filterQuery.query, filterQuery.values);
            filterQuery.query = filterQuery.query.Substring(2, filterQuery.query.Length - 2);

            var expression = DynamicExpressionParser.ParseLambda <T, bool>(null, false, filterQuery.query, filterQuery.values);

            return(expression);
        }