diff --git a/MathExpressionsNet.Tests/CodeDomTests.cs b/MathExpressionsNet.Tests/CodeDomTests.cs
index 53d97c1..86c6fd8 100644
--- a/MathExpressionsNet.Tests/CodeDomTests.cs
+++ b/MathExpressionsNet.Tests/CodeDomTests.cs
@@ -13,10 +13,13 @@ public class CodeDomTests
 		[Test]
 		public void StringsToExpressionsTest()
 		{
+			var f0 = CodeDom.ParseExpression<Func<double>>("2+5*4").Compile();
+			Assert.That(f0(), Is.EqualTo(22));
+
 			var f1 = ((Expression<Func<double, double>>)CodeDom.GetExpressionFrom("x=>0")).Compile();
 			VerifyFunctions(f1, functions.LeftBoundCond);
 
-			f1 = ((Expression<Func<double, double>>)CodeDom.GetExpressionFrom("t=>t+3*t*t")).Compile();
+			f1 = CodeDom.ParseExpression<Func<double, double>>("t+3*t*t", "t").Compile();
 			VerifyFunctions(f1, functions.RightBoundCond);
 
 			var f2 = ((Expression<Func<double, double, double>>)CodeDom.GetExpressionFrom("(x,t)=>x*x*t+3*x*t*t")).Compile();
@@ -27,9 +30,6 @@ public void StringsToExpressionsTest()
 
 			var f3 = ((Expression<Func<double, double, double, double>>)CodeDom.GetExpressionFrom("(x,t,u)=>x*x*t+u*u")).Compile();
 			VerifyFunctions(f3, functions.K);
-
-			f3 = ((Expression<Func<double, double, double, double>>)CodeDom.GetExpressionFrom("(x,t,u)=>x*x+6*x*t-2*u*Math.Pow(2*x*t+3*t*t,2)-2*t*(x*x*t+u*u)")).Compile();
-			VerifyFunctions(f3, functions.g);
 		}
 
 		private void VerifyFunctions(Func<double, double> generatedFunc, Func<double, double> expectedFunc)
@@ -53,6 +53,22 @@ private void VerifyFunctions(Func<double, double, double, double> generatedFunc,
 			Assert.That(generatedFunc(a, b, c), Is.EqualTo(expectedFunc(a, b, c)));
 		}
 
+		[Test]
+		public void MakeNewFunction()
+		{
+			var exprU = CodeDom.ParseExpression<Func<double, double, double>>("x * x * t + 3 * x * t * t", "x", "t");
+			var exprK = CodeDom.ParseExpression<Func<double, double, double, double>>("x * x * t + u * u", "x", "t", "u");
+			string du_dt = exprU.Derive("t").Simplify().Body.ToString();
+			string dK_du = exprK.Derive("u").Simplify().Body.ToString();
+			var dudx = exprU.Derive("x").Simplify();
+			string du_dx = dudx.Body.ToString();
+			string d2u_dx2 = dudx.Derive("x").Simplify().Body.ToString();
+			string g = $"{du_dt}-{dK_du}*Math.Pow({du_dx},2)-{d2u_dx2}*{exprK.Simplify().Body}".Replace(" ", "");
+			Assert.That(g, Is.EqualTo("((x*x)+(6*(x*t)))-(2*u)*Math.Pow(((2*(x*t))+(3*(t*t))),2)-(2*t)*(((x*x)*t)+(u*u))"));
+			var gFunc = CodeDom.ParseExpression<Func<double, double, double, double>>(g, "x", "t", "u").Compile();
+			VerifyFunctions(gFunc, functions.g);
+		}
+
 		[Test]
 		public void ThrowingException()
 		{
diff --git a/MathExpressionsNet.Tests/Functions.cs b/MathExpressionsNet.Tests/Functions.cs
index 00b5cc3..f03578e 100644
--- a/MathExpressionsNet.Tests/Functions.cs
+++ b/MathExpressionsNet.Tests/Functions.cs
@@ -5,14 +5,10 @@ namespace MathExpressionsNet.Tests
 	public class Functions
 	{
 		public Func<double, double, double, double> K => (x, t, u) => x * x * t + u * u;
-		public Func<double, double, double, double> dK_du => (x, t, u) => 2 * u;
 		public Func<double, double, double, double> g => (x, t, u) => x * x + 6 * x * t - 2 * u * Math.Pow(2 * x * t + 3 * t * t, 2) - 2 * t * (x * x * t + u * u);
 		public Func<double, double> LeftBoundCond => t => 0;
 		public Func<double, double> RightBoundCond => t => t + 3 * t * t;
-
 		public Func<double, double, double> u => (x, t) => x * x * t + 3 * x * t * t;
 		public Func<double, double, double> du_dx => (x, t) => 2 * x * t + 3 * t * t;
-		public Func<double, double, double> d2u_dx2 => (x, t) => 2 * t;
-		public Func<double, double, double> du_dt => (x, t) => x * x + 6 * x * t;
 	}
 }
diff --git a/MathExpressionsNet.Tests/Properties/AssemblyInfo.cs b/MathExpressionsNet.Tests/Properties/AssemblyInfo.cs
index c51a7bf..a3cccb2 100644
--- a/MathExpressionsNet.Tests/Properties/AssemblyInfo.cs
+++ b/MathExpressionsNet.Tests/Properties/AssemblyInfo.cs
@@ -31,5 +31,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.0.1.0")]
+[assembly: AssemblyFileVersion("1.0.1.0")]
diff --git a/MathExpressionsNet/CodeDom.cs b/MathExpressionsNet/CodeDom.cs
index c0eac45..b070430 100644
--- a/MathExpressionsNet/CodeDom.cs
+++ b/MathExpressionsNet/CodeDom.cs
@@ -11,9 +11,10 @@ namespace MathExpressionsNet
 {
 	public class CodeDom
 	{
-		const string TYPE_NAME = "TemporaryNamespace.Temporary";
-		const string METHOD_NAME = "Get";
-		const string CODE_HEADER = @"
+		private const string TypeName = "TemporaryNamespace.Temporary";
+		private const string MethodName = "Get";
+
+		private const string CodeHeader = @"
 namespace TemporaryNamespace
 {
 	using System;
@@ -25,10 +26,12 @@ public Expression Get()
 		{
 			return New(
 ";
-		const string CODE_FOOTER = @"
+
+		private const string CodeFooter = @"
 				);
 		}
 
+		static Expression New(Expression<Func<double>> e) { return e; }
 		static Expression New(Expression<Func<double, double>> e) { return e; }
 		static Expression New(Expression<Func<double, double, double>> e) { return e; }
 		static Expression New(Expression<Func<double, double, double, double>> e) { return e; }
@@ -37,29 +40,28 @@ public Expression Get()
 }
 ";
 
-		static CompilerResults Compile(string source)
+		private static CompilerResults Compile(string source)
 		{
 			CodeDomProvider provider = new CSharpCodeProvider(
 				new Dictionary<string, string> { { "CompilerVersion", "v3.5" } });
 
-			CompilerParameters cp = new CompilerParameters();
-			cp.GenerateInMemory = true;
+			var cp = new CompilerParameters { GenerateInMemory = true };
 			cp.ReferencedAssemblies.Add("System.Core.dll");
 
 			CompilerResults cr = provider.CompileAssemblyFromSource(
 				cp,
-				CODE_HEADER + source + CODE_FOOTER
+				CodeHeader + source + CodeFooter
 			);
 
 			return cr;
 		}
 
-		static Expression Execute(CompilerResults cr)
+		private static Expression Execute(CompilerResults cr)
 		{
 			Assembly asm = cr.CompiledAssembly;
-			Type myClass = asm.GetType(TYPE_NAME);
+			Type myClass = asm.GetType(TypeName);
 			Object o = Activator.CreateInstance(myClass);
-			MethodInfo mi = myClass.GetMethod(METHOD_NAME);
+			MethodInfo mi = myClass.GetMethod(MethodName);
 			return (Expression)mi.Invoke(o, null);
 		}
 
@@ -69,9 +71,9 @@ public static Expression GetExpressionFrom(string source)
 
 			if (cr.Errors.HasErrors)
 			{
-				StringBuilder sb = new StringBuilder();
+				var sb = new StringBuilder();
 				sb.Append("Compilation failed: ");
-				Regex reg = new Regex(@":\serror\s(?<reason>.*)$");
+				var reg = new Regex(@":\serror\s(?<reason>.*)$");
 
 				foreach (var error in cr.Errors)
 				{
@@ -87,6 +89,12 @@ public static Expression GetExpressionFrom(string source)
 
 			return Execute(cr);
 		}
+
+		public static Expression<T> ParseExpression<T>(string func, params string[] variables)
+		{
+			var expr = (Expression<T>)GetExpressionFrom($"({string.Join(",", variables)}) => {func}");
+			return expr.Simplify();
+		}
 	}
 
 	public class ExpressionCodeDomException : Exception
diff --git a/MathExpressionsNet/DifferentialOperator.cs b/MathExpressionsNet/DifferentialOperator.cs
index bee5fd7..fbb5524 100644
--- a/MathExpressionsNet/DifferentialOperator.cs
+++ b/MathExpressionsNet/DifferentialOperator.cs
@@ -5,7 +5,7 @@ namespace MathExpressionsNet
 {
 	public class DifferentialOperator
 	{
-		Expression characteristic;
+		private Expression characteristic;
 
 		#region init
 
@@ -16,7 +16,7 @@ public class DifferentialOperator
 		/// <param name="paramName">parameter name</param>
 		public DifferentialOperator(string paramName)
 		{
-			this.characteristic = Expression.Parameter(typeof(double), paramName);
+			characteristic = Expression.Parameter(typeof(double), paramName);
 		}
 
 		/// <summary>
@@ -25,7 +25,7 @@ public DifferentialOperator(string paramName)
 		/// Laplacian = (∂/∂x)^2 + (∂/∂y)^2
 		/// </summary>
 		/// <param name="characteristic"></param>
-		DifferentialOperator(Expression characteristic)
+		private DifferentialOperator(Expression characteristic)
 		{
 			this.characteristic = characteristic;
 		}
@@ -55,6 +55,7 @@ public DifferentialOperator(
 			: this((Expression)e) { }
 
 		#endregion
+
 		#region apply operator
 
 		/// <summary>
@@ -65,7 +66,7 @@ public DifferentialOperator(
 		/// <returns>derivative</returns>
 		public Expression<T> Apply<T>(Expression<T> e)
 		{
-			return Apply(this.characteristic, e);
+			return Apply(characteristic, e);
 		}
 
 		/// <summary>
@@ -128,6 +129,7 @@ static public Expression<T> Apply<T>(Expression characteristic, Expression<T> e)
 		}
 
 		#endregion
+
 		#region operator
 
 		/// <summary>
diff --git a/MathExpressionsNet/ExpressionExtensions.cs b/MathExpressionsNet/ExpressionExtensions.cs
index c84db21..b8e1517 100644
--- a/MathExpressionsNet/ExpressionExtensions.cs
+++ b/MathExpressionsNet/ExpressionExtensions.cs
@@ -14,30 +14,46 @@ public static class ExpressionExtensions
 		/// express a term as style such like { constant, body }.
 		/// 2 * x * 3 * y -> { 6, x * y }.
 		/// </summary>
-		class Term
+		private class Term
 		{
 			public double Constant { get; set; }
 			public Expression Body { get; set; }
-			public Term(double c) { this.Constant = c; this.Body = null; }
-			public Term(Expression b) { this.Constant = 1.0; this.Body = b; }
-			public Term(double c, Expression b) { this.Constant = c; this.Body = b; }
+
+			public Term(double c)
+			{
+				Constant = c;
+				Body = null;
+			}
+
+			public Term(Expression b)
+			{
+				Constant = 1.0;
+				Body = b;
+			}
+
+			public Term(double c, Expression b)
+			{
+				Constant = c;
+				Body = b;
+			}
 
 			public Expression ToExpression()
 			{
-				if (this.Constant == 0)
+				if (Constant == 0)
 					return Expression.Constant(0.0);
-				if (this.Body == null)
-					return Expression.Constant(this.Constant);
-				if (this.Constant == 1)
-					return this.Body;
+				if (Body == null)
+					return Expression.Constant(Constant);
+				if (Constant == 1)
+					return Body;
 
 				return Expression.Multiply(
-					Expression.Constant(this.Constant),
-					this.Body);
+					Expression.Constant(Constant),
+					Body);
 			}
 		}
 
 		#endregion
+
 		#region Derive
 
 		/// <summary>
@@ -118,6 +134,7 @@ private static Expression Derive(this Expression e, string paramName)
 						Expression d = op.Derive(paramName);
 						return OptimizedNegate(d);
 					}
+
 				case ExpressionType.Add:
 					{
 						Expression dleft =
@@ -261,16 +278,12 @@ private static Expression Derive(this MethodCallExpression me, string paramName)
 		/// <param name="methodName">method name</param>
 		/// <param name="arguments">arguments of the method</param>
 		/// <returns>expression</returns>
-		static Expression MathCall(string methodName,
-			IEnumerable<Expression> arguments)
+		private static Expression MathCall(string methodName, IEnumerable<Expression> arguments)
 		{
-			return Expression.Call(null,
-				typeof(System.Math).GetMethod(methodName),
-				arguments);
+			return Expression.Call(null, typeof(Math).GetMethod(methodName), arguments);
 		}
 
-		static Expression MathCall(string methodName,
-			params Expression[] arguments)
+		private static Expression MathCall(string methodName, params Expression[] arguments)
 		{
 			return MathCall(methodName, arguments);
 		}
@@ -278,6 +291,7 @@ static Expression MathCall(string methodName,
 		#endregion
 
 		#endregion
+
 		#region optimized arithmetic
 
 		/// <summary>
@@ -289,8 +303,7 @@ internal static Expression OptimizedNegate(Expression e)
 		{
 			if (e.IsConstant())
 			{
-				return Expression.Constant(
-					-(double)((ConstantExpression)e).Value);
+				return Expression.Constant(-(double)((ConstantExpression)e).Value);
 			}
 
 			if (e.NodeType == ExpressionType.Negate)
@@ -309,7 +322,7 @@ internal static Expression OptimizedNegate(Expression e)
 		/// <param name="e1">operand 1</param>
 		/// <param name="e2">operand 2</param>
 		/// <returns>result</returns>
-		static Expression OptimizedAdd(Expression e1, Expression e2)
+		private static Expression OptimizedAdd(Expression e1, Expression e2)
 		{
 			// 0 + x -> x
 			if (e1.IsConstant())
@@ -365,7 +378,7 @@ static Expression OptimizedAdd(Expression e1, Expression e2)
 		/// <param name="e1">operand 1</param>
 		/// <param name="e2">operand 2</param>
 		/// <returns>result</returns>
-		static Expression OptimizedSub(Expression e1, Expression e2)
+		private static Expression OptimizedSub(Expression e1, Expression e2)
 		{
 			// 0 - x -> -x
 			if (e1.IsConstant())
@@ -419,7 +432,7 @@ static Expression OptimizedSub(Expression e1, Expression e2)
 		/// <param name="e1">operand 1</param>
 		/// <param name="e2">operand 2</param>
 		/// <returns>result</returns>
-		static Expression OptimizedMul(Expression e1, Expression e2)
+		private static Expression OptimizedMul(Expression e1, Expression e2)
 		{
 			Expression mul = Expression.Multiply(e1, e2);
 
@@ -433,7 +446,7 @@ static Expression OptimizedMul(Expression e1, Expression e2)
 		/// <param name="e1">operand 1</param>
 		/// <param name="e2">operand 2</param>
 		/// <returns>result</returns>
-		static Expression OptimizedDiv(Expression e1, Expression e2)
+		private static Expression OptimizedDiv(Expression e1, Expression e2)
 		{
 			Expression div = Expression.Divide(e1, e2);
 
@@ -529,7 +542,7 @@ public static Expression<T> Simplify<T>(this Expression<T> e)
 		/// </summary>
 		/// <param name="e">expression to be reduced</param>
 		/// <returns>reduced result</returns>
-		static Expression Simplify(this Expression e)
+		private static Expression Simplify(this Expression e)
 		{
 			switch (e.NodeType)
 			{
@@ -568,7 +581,7 @@ static Expression Simplify(this Expression e)
 		/// </summary>
 		/// <param name="e">terget</param>
 		/// <returns>result</returns>
-		static Expression Cancel(this Expression e)
+		private static Expression Cancel(this Expression e)
 		{
 			List<Term> terms = new List<Term>();
 
@@ -583,7 +596,7 @@ static Expression Cancel(this Expression e)
 		/// <param name="e">expression to be deconstructed</param>
 		/// <param name="minus">negate sign of e if minus == true</param>
 		/// <param name="terms">list into which deconstructed terms are stored</param>
-		static void DeconstructSum(Expression e, bool minus, List<Term> terms)
+		private static void DeconstructSum(Expression e, bool minus, List<Term> terms)
 		{
 			if (e.NodeType == ExpressionType.Negate)
 			{
@@ -625,7 +638,7 @@ static void DeconstructSum(Expression e, bool minus, List<Term> terms)
 		/// </summary>
 		/// <param name="terms">list in which expressions are stored</param>
 		/// <returns>sum of terms</returns>
-		static Expression ConstructSum(List<Term> terms)
+		private static Expression ConstructSum(List<Term> terms)
 		{
 			Expression sum = Expression.Constant(0.0);
 			foreach (var term in terms)
@@ -643,7 +656,7 @@ static Expression ConstructSum(List<Term> terms)
 		/// for example, 2 * x * 3 * x * 4 -> 24 * x * x.
 		/// </summary>
 		/// <param name="e">Expression to be optimized</param>
-		static Term FoldConstants(Expression e)
+		private static Term FoldConstants(Expression e)
 		{
 			List<Expression> n = new List<Expression>();
 			List<Expression> d = new List<Expression>();
@@ -656,7 +669,7 @@ static Term FoldConstants(Expression e)
 		/// </summary>
 		/// <param name="e">terget</param>
 		/// <returns>result</returns>
-		static Expression Reduce(this Expression e)
+		private static Expression Reduce(this Expression e)
 		{
 			return FoldConstants(e).ToExpression();
 		}
@@ -666,8 +679,8 @@ static Expression Reduce(this Expression e)
 		/// x / a * y * z / b / c -> num = {x, y, z}, denom = {a, b, c}.
 		/// </summary>
 		/// <param name="e">expression to be deconstructed</param>
-		/// <param name="list">list into which deconstructed expressions are stored</param>
-		static void DeconstructProduct(Expression e, List<Expression> num, List<Expression> denom)
+		/// <param name="num">list into which deconstructed expressions are stored</param>
+		private static void DeconstructProduct(Expression e, List<Expression> num, List<Expression> denom)
 		{
 			if (e.NodeType == ExpressionType.Multiply)
 			{
@@ -724,7 +737,7 @@ static void DeconstructProduct(Expression e, List<Expression> num, List<Expressi
 		/// {x, y, z} -> x * y * z.
 		/// </summary>
 		/// <param name="list">list in which expressions are stored</param>
-		static Term ConstructProduct(IEnumerable<Expression> list)
+		private static Term ConstructProduct(IEnumerable<Expression> list)
 		{
 			double c = 1;
 			Expression prod = null;
@@ -748,7 +761,7 @@ static Term ConstructProduct(IEnumerable<Expression> list)
 		/// </summary>
 		/// <param name="num">list in which expressions of numerator are stored</param>
 		/// <param name="denom">list in which expressions of denominator are stored</param>
-		static Term ConstructProduct(List<Expression> num, List<Expression> denom)
+		private static Term ConstructProduct(List<Expression> num, List<Expression> denom)
 		{
 			double c = 1;
 
@@ -796,7 +809,7 @@ static Term ConstructProduct(List<Expression> num, List<Expression> denom)
 		/// <param name="t1">operand 1</param>
 		/// <param name="t2">operand 2</param>
 		/// <returns>result</returns>
-		static Term Div(Term t1, Term t2)
+		private static Term Div(Term t1, Term t2)
 		{
 			double c1 = t1.Constant;
 			double c2 = t2.Constant;
@@ -950,7 +963,7 @@ public static bool IsZero(this Expression e)
 		/// </summary>
 		/// <param name="e">operand</param>
 		/// <returns>true if e is a constant</returns>
-		static bool IsConstant(this Expression e)
+		private static bool IsConstant(this Expression e)
 		{
 			return e.NodeType == ExpressionType.Constant
 				   && e.Type.Name == "Double";
@@ -959,7 +972,7 @@ static bool IsConstant(this Expression e)
 		#endregion
 		#region identical for parameters/arguments
 
-		static bool IsIdenticalTo(
+		private static bool IsIdenticalTo(
 			this ICollection<ParameterExpression> args1,
 			ICollection<ParameterExpression> args2)
 		{
@@ -977,7 +990,7 @@ static bool IsIdenticalTo(
 			return true;
 		}
 
-		static bool IsIdenticalTo(
+		private static bool IsIdenticalTo(
 			this ICollection<Expression> args1,
 			ICollection<Expression> args2)
 		{
diff --git a/MathExpressionsNet/Properties/AssemblyInfo.cs b/MathExpressionsNet/Properties/AssemblyInfo.cs
index 2ac4758..10e1a6e 100644
--- a/MathExpressionsNet/Properties/AssemblyInfo.cs
+++ b/MathExpressionsNet/Properties/AssemblyInfo.cs
@@ -31,5 +31,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.0.1.0")]
+[assembly: AssemblyFileVersion("1.0.1.0")]