Evaluating an expression (like 45/12) from a textbox - vb.net

Question

I need to be able to type a value in a textbox of either 45/12 or 3.75 which is a decimal inch conversion. Obviously the decimal value works. The code takes a different textbox value (a) and this value (b) subtracts b from a and multiplies the result by a shrink factor to populate in another textbox. Some know the decimal conversion some do not and resort to the 45/12 method. Value (a) is entered strictly by a decimal conversion 8'-1" would be 8.0833. Any help on this is appreciated. Value (b) however is used for more calculations further in the code which I can post if needed. This is part of the code, the value for b goes on and on to an expression of >4. Also this is my first ever VB design so it may not be the most efficient code. thanks
Option Explicit On
Public Class Form1
Dim a, b, c, d, r, w, h, x, y, z As Single
Dim s, t, u, v, f, g, j, k, l, m, n, o As Single
Private Sub radiobutton1_CheckedChanged(sender As Object, e As EventArgs) Handles RadioButton1.CheckedChanged
If (RadioButton1.Checked) = False Then
Button1.PerformClick()
End If
End Sub
Private Sub radiobutton3_CheckedChanged(sender As Object, e As EventArgs) Handles RadioButton3.CheckedChanged
If (RadioButton3.Checked) = False Then
Button1.PerformClick()
End If
End Sub
Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
If Timer1.Interval = 1000 Then
Label9.Text = DateTime.Now
End If
End Sub
' Calculate Button Does This
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Error Boxes
If TextBox1.Text = "" Then
MsgBox("Please Input 'Wall Height' And/Or 'Depth'")
With TextBox1
.Focus()
.SelectAll()
End With
Exit Sub
End If
If TextBox2.Text = "" Then
MsgBox("Please Input 'Wall Height' And/Or 'Depth'")
With TextBox2
.Focus()
.SelectAll()
End With
Exit Sub
End If
If (RadioButton1.Checked Or RadioButton3.Checked) = False Then
MsgBox("Please Select 'N/A' or 'Yes")
End If
If TextBox1.Text < TextBox2.Text Then
MsgBox("Re-check Depth and Wall Height")
With TextBox1
.Focus()
.SelectAll()
End With
Exit Sub
End If
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Values For Depth And Wall Height
a = Val(TextBox1.Text) 'Depth
b = Val(TextBox2.Text) 'Actual Wall Height
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Hopper Drop Shrink Calculation
If (RadioButton3.Checked) AndAlso ((a - b) <= 1) Then
r = Math.Round(((a - b) - 0.0833), 4)
ElseIf (RadioButton1.Checked) Then
r = Math.Round(((a - b) * 0.944), 4) ' Depth minus wall height .944 shrink factor
ElseIf (RadioButton3.Checked) Then
r = Math.Round(((a - b) * 0.89), 4) ' Depth minus wall height .89 shrink factor
End If
If r <= 0.01 Then
TextBox3.Text = "N/A"
Else : TextBox3.Text = r
End If
' Value For Hopper Drop after shrink
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Depth Minus Wall Height Ranges For Finish Wall Height
w = (b >= 0.0833 And b <= 3.25) ' Wall height between 12" and 39"
If w Then
h = Math.Round(((b - 0.0833) * 12), 2) ' Subtract 1" from wall height
End If
If w Then
t = 0
End If
If w Then
d = 0
End If
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
z = (b >= 3.26 And b <= 3.3332) ' Wall height between 39 1/4" and 39 3/4"
If z Then
h = 38 ' Wall height will be 38"
End If
If z Then
t = 0
End If
If z Then
d = 0
End If
TextBox4.Text = Int(h) & " " & DecToFraction(h - Int(h)) & "''" 'Finish Wall Height
TextBox6.Text = Int(t) & " " & DecToFraction(t - Int(t)) & "''" ' Strip Size
If CheckBox2.Checked Then
TextBox5.Text = "N/A"
ElseIf CheckBox2.Checked = False Then
TextBox5.Text = Int(t) & " " & DecToFraction(t - Int(t)) & "''" ' Wrap Size
End If
TextBox7.Text = Int(d) & " " & DecToFraction(d - Int(d)) & "''" ' Cut wall to (production wall height)

Answer 1

You could use a library like NCalc to treat the textbox input as a mathematical expression. This would handle 45/12 and 3.75 perfectly, as either will evaluate to a single number when executed through the expression engine.

Answer 2

Or you can use a Fraction struct like this:
class Program
{
static void Main(string[] args)
{
Fraction X=Fraction.Parse("45/12");
Console.WriteLine("X = {0} = {1} = {2}", X, X.GetReduced(),X.Value);
// X = 45/12 = 15/4 = 3.75
bool ok=X.Equals(3.75);
// true
}
}
/// <summary>
/// A Class to represent fraction from decimals using GCD and LCM.
/// </summary>
/// <remarks>Code taken from http://www.vcskicks.com/code-snippet/fraction.php</remarks>
[TypeConverter(typeof(ExpandableObjectConverter))]
public struct Fraction : IEquatable<Fraction>, IEquatable<double>, ICloneable
{
public static string DefaultFormat="G";
public readonly long numerator;
public readonly long denominator;
public static Fraction Zero=new Fraction(0, 1);
public Fraction(long numerator, long denominator)
{
this.numerator=numerator;
this.denominator=denominator;
//If denominator negative...
if(this.denominator<0)
{
//...move the negative up to the numerator
this.numerator=-this.numerator;
this.denominator=-this.denominator;
}
}
public Fraction(Fraction fraction)
{
this.numerator=fraction.numerator;
this.denominator=fraction.denominator;
}
public static Fraction Parse(string value)
{
long num=1;
long den=1;
string[] parts=value.Split('/');
bool is_den=false;
for(int i=0; i<parts.Length; i++)
{
if(is_den)
{
den*=long.Parse(parts[i]);
}
else
{
num*=long.Parse(parts[i]);
}
is_den=!is_den;
}
return new Fraction(num, den);
}
public static implicit operator Fraction(double value)
{
return Fraction.FromValue(value);
}
public static implicit operator double(Fraction rhs)
{
return rhs.Value;
}
public long Numerator { get { return numerator; } }
public long Denominator { get { return denominator; } }
public double Value { get { return (double)numerator/denominator; } }
public static Fraction operator+(Fraction lhs, Fraction rhs) { return lhs.Add(rhs); }
public static Fraction operator-(Fraction rhs) { return rhs.Negate(); }
public static Fraction operator-(Fraction lhs, Fraction rhs) { return lhs.Subtract(rhs); }
public static Fraction operator*(double lhs, Fraction rhs) { return rhs.Scale(lhs); }
public static Fraction operator*(Fraction lhs, double rhs) { return lhs.Scale(rhs); }
public static Fraction operator/(Fraction lhs, double rhs) { return lhs.Scale(1/rhs); }
public static Fraction operator/(double lhs, Fraction rhs) { return rhs.Reciprocal(lhs); }
public static Fraction operator*(Fraction lhs, Fraction rhs) { return lhs.Multiply(rhs); }
public static Fraction operator/(Fraction lhs, Fraction rhs) { return lhs.Divide(rhs); }
/// <summary>
/// Get the greatest common divisor
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private static long getGCD(long a, long b)
{
//Drop negative signs
a=Math.Abs(a);
b=Math.Abs(b);
//Return the greatest common denominator between two integers
while(a!=0&&b!=0)
{
if(a>b)
a%=b;
else
b%=a;
}
if(a==0)
return b;
else
return a;
}
/// <summary>
/// Get the least common measure
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
private static long getLCM(long a, long b)
{
//Return the Least Common Denominator between two integers
return (a*b)/getGCD(a, b);
}
public Fraction ToDenominator(long targetDenominator)
{
//Multiply the fraction by a factor to make the denominator
//match the target denominator
//Fraction modifiedFraction=this;
long n=this.numerator;
long d=this.denominator;
//Cannot reduce to smaller denominators
if(targetDenominator<this.denominator)
return this;
//The target denominator must be a factor of the current denominator
if(targetDenominator%this.denominator!=0)
return this;
if(d!=targetDenominator)
{
long factor=targetDenominator/d;
n*=factor;
d=targetDenominator;
//modifiedFraction.denominator=targetDenominator;
//modifiedFraction.numerator*=factor;
}
return new Fraction(n, d);
}
public Fraction GetReduced()
{
//Reduce the fraction to lowest terms
//Fraction modifiedFraction=this;
long n=this.numerator;
long d=this.denominator;
//While the numerator and denominator share a greatest common denominator,
//keep dividing both by it
long gcd=0;
while(Math.Abs(gcd=getGCD(n, d))!=1)
{
n/=gcd;
d/=gcd;
}
//Make sure only a single negative sign is on the numerator
n=n*Math.Sign(d);
d=Math.Abs(d);
return new Fraction(n, d);
}
/// <summary>
/// Uses a continious fraction scheme to iteratively aproximate a number with a fraction.
/// The accuracy is taken from <see cref="GRE.Mathematics.Dbl.Calculator.ZeroTolerance"/>
/// </summary>
/// <remarks>See <see cref="FromValue(double,double)"/> to understand how it works</remarks>
/// <param name="number">The number to approximate</param>
/// <returns></returns>
public static Fraction FromValue(double number)
{
return FromValue(number, 15);
}
/// <summary>
/// Uses a continious fraction scheme to iteratively aproximate a number with a fraction
/// </summary>
/// <remarks>See <see cref="FromValue(double,double)"/> to understand how it works</remarks>
/// <param name="number">The number to approximate</param>
/// <param name="digits">The number if digits to use in the aproximation</param>
/// <returns></returns>
public static Fraction FromValue(double number, int digits)
{
double accuracy=Math.Pow(10.0, -digits);
return FromValue(number, accuracy);
}
/// <summary>
/// Uses a continious fraction scheme to iteratively aproximate a number with a fraction
/// </summary>
/// <remarks>
/// See documentation for <see cref="FromContiniousFractionCoefficients(long[])"/> to understand how this works.
/// </remarks>
/// <param name="number">The number to aproximate</param>
/// <param name="accuracy">The accuracy to use |fraction-value|<![CDATA[<]]>accuracy </param>
/// <returns></returns>
public static Fraction FromValue(double number, double accuracy)
{
int sign=Math.Sign(number);
number=Math.Abs(number);
int passes=0;
List<long> coef=new List<long>();
Fraction x;
double r=number; // remainder (example 8.22)
do
{
long c=(int)r; // integer of remainder (r=8.22 -> c=8)
r=1/(r-c); // new remainder from r -> 1/(0.22)=4.54
coef.Add(c); // adds c to the list
x=FromContiniousFractionCoefficients(coef.ToArray()); // reconstruct the fraction from all the n's
passes++; // increment counter and repeat
} while(!x.Equals(number, accuracy)&&passes<10);
if(sign<0)
{
x=x.Negate();
}
return x;
}
/// <summary>
/// Use recursion to take the integer coefficients of a continious fraction and simplify it to a regular fraction
/// </summary>
/// <example>The parameters in array <c>c</c> define the following value:<![CDATA[
/// 1
/// c[0] + -------------------- -> recursion on e[i] = c[i] + 1/e[i+1] , e[i]=r[i]/r[i+1]
/// 1
/// c[1] + --------------- seed is 1/e[N]=0 (r[N]=1, r[N+1]=0)
/// 1 final result is x = r[0]/r[1]
/// c[2] + ---------
/// c[3]+...
/// ]]></example>
/// <remarks>Here are some references
/// * http://www.friesian.com/golden.htm
/// * http://archives.math.utk.edu/articles/atuyl/confrac/intro.html
/// * http://www.trans4mind.com/personal_development/mathematics/numberTheory/continuedFractions.htm
/// </remarks>
/// <param name="coef">The integer coefficients for the fraction (see example)</param>
/// <returns>A Fraction object</returns>
public static Fraction FromContiniousFractionCoefficients(params long[] coef)
{
int N=coef.Length;
if(N>0)
{
long[] r=new long[N+2];
r[N+1]=0;
r[N+0]=1;
for(int i=N-1; i>=0; i--)
{
r[i]=coef[i]*r[i+1]+r[i+2];
}
return new Fraction(r[0], r[1]);
}
else
{
return Fraction.Zero;
}
}
public Fraction Flip()
{
//Flip the numerator and the denominator
return new Fraction(this.denominator, this.numerator);
}
public override bool Equals(object obj)
{
if(obj is Fraction)
{
return Equals((Fraction)obj);
}
return false;
}
public bool Equals(Fraction other, double tolerance)
{
return Math.Abs(Value-other.Value)<=tolerance;
}
public bool Equals(Fraction other)
{
var A=GetReduced();
var B=other.GetReduced();
return A.numerator==B.numerator&&A.denominator==B.denominator;
}
public override int GetHashCode()
{
unchecked
{
return 17*23*Value.GetHashCode();
}
}
public Fraction Clone() { return new Fraction(this); }
object ICloneable.Clone()
{
return Clone();
}
public Fraction Scale(double factor)
{
Fraction other=new Fraction(factor);
return Multiply(other);
}
public Fraction Divide(double factor)
{
Fraction other=new Fraction(factor);
return Divide(other);
}
public Fraction Reciprocal(double numerator)
{
Fraction other=new Fraction(numerator);
return other.Divide(this);
}
public Fraction Multiply(Fraction other)
{
return new Fraction(numerator*other.numerator, denominator*other.denominator).GetReduced();
}
public Fraction Divide(Fraction other)
{
return new Fraction(numerator*other.denominator, denominator*other.numerator).GetReduced();
}
public Fraction Add(Fraction other)
{
return new Fraction(other.denominator*numerator+other.numerator*denominator, denominator*other.denominator).GetReduced();
}
public Fraction Subtract(Fraction other)
{
return new Fraction(other.denominator*numerator-other.numerator*denominator, denominator*other.denominator).GetReduced();
}
public Fraction Negate()
{
return new Fraction(-numerator, denominator);
}
public override string ToString()
{
return ToString(DefaultFormat);
}
public string ToString(string format)
{
return ToString(format, null);
}
public string ToString(string format, IFormatProvider formatProvider)
{
if(numerator==0)
{
string fmt="{0:#}".Replace("#", format);
return string.Format(formatProvider, fmt, numerator);
}
else
{
string fmt="{0:#}/{1:#}".Replace("#", format);
return string.Format(formatProvider, fmt, numerator, denominator);
}
}
public bool Equals(double other)
{
return Value.Equals(other);
}
public bool Equals(double other, double tolerance)
{
return Math.Abs(Value-other)<=tolerance;
}
}