 			else
 				return 1
 
+		# Checks equality of this Variable and another Variable
+		#
+		# @param b [Variable] The other variable
+		# @param equivalencies [???] Optional. 
 		equals: (b, equivalencies=null) ->
 			# Check equality between this and some other object.
 			unless b instanceof Variable

				# Also returning a float.
				return new Constant(Math.pow(@evaluate(), b.evaluate()), 1, "float")

		equals: (b) ->
			# Test equality between this object and another.
			unless b instanceof Constant
				return false
			return @evaluate() == b.evaluate()

		replaceVariables: (replacements) ->
			@copy() # Does nothing - this is a constant.

		getAllVariables: ->
			[]

		sub: (substitutions, uncertaintySubstitutions) ->
			@copy()

		simplifyInPlace: ->
			# Get the greatest common divisor.
			a = @numerator

			else
				return 1

		# Evaluates the SymbolicConstant
		# @return [Integer, Float] Returns the current value of the SymbolicConstant
		evaluate: ->
			@value

		# Checks equality of this and another SymbolicConstant
		# 
		# @param b [SymbolicConstant]
		# @return [Boolean] Whether or not the two SymbolicConstants are equal
		equals: (b) ->
			unless b instanceof SymbolicConstant
				return false
			return @label == b.label and @value == b.value

		# Does nothing - included for API parity
		#
		# @params replacements [???]
		# @return [SymbolicConstant]
		replaceVariables: (replacements) ->
			@copy() # Does nothing - this is a constant.

		#Does nothing??? Matt, please check
		getAllVariables: ->
			[]


		# Substitute values into the SymbolicConstant - does nothing as this is a SymbolicConstant;
		# Included for API parity
		# 
		#@param substitutions [Object] A map of variable labels to their values. Values can be integers, Expressions, Terminals or BasicNodes
		#@param uncertaintySubstitutions [???] I don't know how this works
		sub: (substitutions, uncertaintySubstitutions, equivalencies=null, assumeZeroUncertainty=false, evaluateSymbolicConstants=false) ->
			unless evaluateSymbolicConstants
				return @copy()
			if @label of constants
				return new Constant(constants[@label])

		# Simplify the SymbolicConstant
		#
		# @return [SymbolicConstant] Returns a deep copy of the SymbolicConstant
		simplify: ->
			@copy()

		# Expand the SymbolicConstant
		#
		# @return [SymbolicConstant] Returns a deep copy of the SymbolicConstant
		expand: ->
			@copy()

		# Expand and simplify the SymbolicConstant
		#
		# @return [SymbolicConstant] Returns a deep copy of the SymbolicConstant
		expandAndSimplify: ->
			@copy()

		# Substitutes an expression into the SymbolicConstant
		#
		# @param sourceExpression [Expression]
		# @param variable [???]
		# @param equivalencies []
		substituteExpression: (sourceExpression, variable, equivalencies) ->
			[@copy()]

		# Gets the uncertainty of the SymbolicConstant
		#
		# @return [Constant] Returns a Constant of 0
		getUncertainty: ->
			new Constant(0)

		# Gets the units of the SymbolicConstant i.e. null
		# @return null
		getVariableUnits: ->
			null

		# Sets the units of the SymbolicConstant
		# @param variable
		# @param equivalencies
		# @param units
		setVariableUnits: (variable, equivalencies, units) ->
			null

		# Creates a DrawingNode of the SymbolicConstant to be viewed
		#
		# @return [VariableNode] Returns a prettyRendered DrawingNode of the SymbolicConstant
		toDrawingNode: ->
			VariableNode = prettyRender.Variable
			return new VariableNode(@label, "constant symbolic-constant")

		# Differentiates the SymbolicConstant
		# @param variable [???]
		# @return [Constant] Returns a Constant of 0
		differentiate: (variable) ->
			return new Constant(0)

	# A class to represent Variables in the Equation tree; e.g. 'm'
	class Variable extends Terminal
		# Variables in the equation tree, e.g. m

		# Make a new Variable
		# 
		# @param label [String]
		# @param units [???] Optional. Defaults to null.
		constructor: (@label, @units=null) ->
			@cmp = -4

		# Creates a deep copy of the current Variable
		#
		# @return [Variable] Returns a deep copy of the current Variable
		copy: ->
			return new Variable(@label, @units)

		# Compares this Variable with another Variable
		#
		# @param b [Variable] The other Variable
		# @return [Integer -1, 0, 1] Returns an integer to indicate less than, equal to or greater than the other Variable
		compareSameType: (b) ->
			# Compare this object with another of the same type.
			if @label < b.label
