/// <summary> /// Generate a function with no arguments that returns an int given that name. The /// actual statement is a very simple constant. /// </summary> /// <param name="fname"></param> /// <returns></returns> public static QMFuncSource GenerateFunction() { int[] ints = new int[10]; var qmb = new QueryModelBuilder(); qmb.AddClause(new MainFromClause("i", typeof(int), Expression.Constant(ints))); qmb.AddClause(new SelectClause(Expression.Constant(1))); qmb.AddResultOperator(new Remotion.Linq.Clauses.ResultOperators.CountResultOperator()); var h = new QMFuncHeader() { Arguments = new object[] { }, QM = qmb.Build() }; h.QMText = h.QM.ToString(); var f = new QMFuncSource(h); var p = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var st = new StatementAssign(p, new ValSimple("5", typeof(int))); var inlineblock = new StatementInlineBlock(); inlineblock.Add(st); inlineblock.Add(new StatementReturn(p)); f.SetCodeBody(inlineblock); return(f); }
public void TestCombineWithSameArray() { var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var arrayRecord = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int)); var stp1 = new StatementPairLoop(arrayRecord, index1, index2); var index3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var index4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var stp2 = new StatementPairLoop(arrayRecord, index3, index4); var statAss = new StatementAssign(index3, new ValSimple("dude", typeof(int)), null); stp2.Add(statAss); var opt = new Factories.CodeOptimizerTest(true); Assert.IsTrue(stp1.TryCombineStatement(stp2, opt), "Combine should have been ok"); Assert.AreEqual(1, stp1.Statements.Count(), "Improper number of combined sub-statements"); var s1 = stp1.Statements.First(); Assert.IsInstanceOfType(s1, typeof(StatementAssign), "Statement is not right type"); var sa = s1 as StatementAssign; Assert.AreEqual(index1.RawValue, sa.ResultVariable.RawValue, "rename of variables didn't occur correctly"); }
public void TestNoDeclare() { var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var sv = new ValSimple("5", typeof(int)); var s1 = new StatementAssign(i, sv); Assert.IsTrue(s1.CodeItUp().First().Trim().StartsWith("aInt32_"), "Check for decl: " + s1.CodeItUp().First()); }
public void TryCombineTwoNoneDeclaresDeclFound() { var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var sv = new ValSimple("5", typeof(int)); var s1 = new StatementAssign(i, sv); var s2 = new StatementAssign(i, sv); Assert.IsTrue(s1.TryCombineStatement(s2, new DummyTrackingOptimizationService(true)), "Combine when no decl found"); }
Tuple <IDeclaredParameter, IStatement> CreateAssignStatement(IValue valToAssign, IDeclaredParameter p1 = null) { if (p1 == null) { p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); } IStatement s1 = new StatementAssign(p1, valToAssign); return(Tuple.Create(p1, s1)); }
/// <summary> /// Helper to create an assignment to a constant. /// </summary> /// <returns></returns> Tuple <IDeclaredParameter, IStatement> CreateConstAssignStatement(IDeclaredParameter p1 = null) { if (p1 == null) { p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); } IStatement s1 = new StatementAssign(p1, new ValSimple("5", typeof(int))); return(Tuple.Create(p1, s1)); }
public void TestBasicCMValues() { var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var sv = new ValSimple("5", typeof(int)); var s1 = new StatementAssign(i, sv); Assert.AreEqual(1, s1.ResultVariables.Count(), "# result variables"); Assert.AreEqual(i.RawValue, s1.ResultVariables.First(), "the name"); Assert.AreEqual(0, s1.DependentVariables.Count(), "no dependent variables"); }
public void AssignDependents() { var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var p2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var v = new ValSimple($"{p2.RawValue}+10", typeof(int), new IDeclaredParameter[] { p2 }); var a = new StatementAssign(p1, v); Assert.AreEqual(1, a.DependentVariables.Count()); Assert.AreEqual(p2.RawValue, a.DependentVariables.First()); }
public void TestCMValuesForSimpleExpression() { var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var di = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var sv = new ValSimple("5", typeof(int), new IDeclaredParameter[] { di }); var s1 = new StatementAssign(i, sv); Assert.AreEqual(1, s1.ResultVariables.Count(), "# result variables"); Assert.AreEqual(i.RawValue, s1.ResultVariables.First(), "the name"); Assert.AreEqual(1, s1.DependentVariables.Count(), "no dependent variables"); Assert.AreEqual(di.RawValue, s1.DependentVariables.First(), "a dependent variable"); }
public void AssignEquivalentDiffFunc() { var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}", typeof(int), new IDeclaredParameter[] { d1 })); var s2 = new StatementAssign(p1, new ValSimple($"sin({d1.RawValue})", typeof(int), new IDeclaredParameter[] { d1 })); var r = s1.RequiredForEquivalence(s2); Assert.IsFalse(r.Item1, "should not be able to do the combination"); }
public void AssignEquivalentSame() { var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}", typeof(int), new IDeclaredParameter[] { d1 })); var s2 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}", typeof(int), new IDeclaredParameter[] { d1 })); var r = s1.RequiredForEquivalence(s2); Assert.IsTrue(r.Item1, "can do the combination"); Assert.AreEqual(0, r.Item2.Count(), "# of variables to rename"); }
public void DependentAndResultVariablesWithDecl() { var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s = new StatementForLoop(counter, new ValSimple("5", typeof(int))); var result = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); s.Add(result); var assign = new StatementAssign(result, new ValSimple($"{result.RawValue}+{counter.RawValue}", typeof(int), new IDeclaredParameter[] { counter, result })); s.Add(assign); Assert.AreEqual(0, s.DependentVariables.Count(), "# of dependent variables"); Assert.AreEqual(0, s.ResultVariables.Count(), "# of result variables"); }
public void AssignEquivalentTwoDifferentDependents() { // Replacing two dependents gets to be more than we can do becasue of ordering and the roll they might // be playing. var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}+{d2.RawValue}", typeof(int), new IDeclaredParameter[] { d1, d2 })); var s2 = new StatementAssign(p1, new ValSimple($"{d3.RawValue}+{d4.RawValue}", typeof(int), new IDeclaredParameter[] { d3, d4 })); var r = s1.RequiredForEquivalence(s2); Assert.IsTrue(r.Item1, "can do the combination"); }
public void AssignEquivalentSameAfterReplacementWith2Vars() { var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var d4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}+{d2.RawValue}", typeof(int), new IDeclaredParameter[] { d1, d2 })); var s2 = new StatementAssign(p1, new ValSimple($"{d3.RawValue}+{d4.RawValue}", typeof(int), new IDeclaredParameter[] { d3, d4 })); var r = s1.RequiredForEquivalence(s2, new Tuple <string, string>[] { new Tuple <string, string>(d3.RawValue, d1.RawValue) }); Assert.IsTrue(r.Item1, "can do the combination"); Assert.AreEqual(1, r.Item2.Count(), "# of variables to rename"); Assert.AreEqual(d4.RawValue, r.Item2.First().Item1); }
private QMFuncSource[] GenerateFunction2() { var fsub = QMFuncUtils.GenerateFunction(); int[] ints = new int[10]; var h = new QMFuncHeader() { Arguments = new object[] { }, QM = new QueryModel(new MainFromClause("i", typeof(int), Expression.Constant(ints)), new SelectClause(Expression.Constant(10))) }; h.QMText = h.QM.ToString(); var f = new QMFuncSource(h); var p = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var st = new StatementAssign(p, new ValSimple(fsub.Name + "()", typeof(int))); var inlineblock = new StatementInlineBlock(); inlineblock.Add(st); inlineblock.Add(new StatementReturn(p)); f.SetCodeBody(inlineblock); return(new QMFuncSource[] { fsub, f }); }