 				# Also returning a float.
 				return new Constant(Math.pow(@evaluate(), b.evaluate()), 1, "float")
 
-		# Tests the equality between this Constant and another Constant.
-		# @param b [Constant]
-		# @return [Boolean] Whether or not the two Constants are equal
+		# Test the equality between this constant and another object.
+		# @param b [Object] The object to check.
+		# @return [Boolean] Whether or not the two objects are equal.
 		equals: (b) ->
 			unless b instanceof Constant
 				return false
 			return @evaluate() == b.evaluate()
 
-		# Does nothing - included for API parity
-		# @param replacements [???]
+		# Alias of copy. Included for API parity.
+		#
+		# @param replacements [Object] A map of replacements. Irrelevant.
 		replaceVariables: (replacements) ->
 			@copy() # Does nothing - this is a constant.
 
+		# Get all variables in this terminal. Included for API parity.
+		#
+		# @return [Array<Object>] Returns `[]`.
 		getAllVariables: ->
 			[]
 
-		# Substitute values into the constant - does nothing as this is a constant;
-		# Included for API parity
+		# Alias of copy. 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
+		# @param substitutions [Object] Map of substitutions. Irrelevant.
+		# @param uncertaintySubstitutions [Object] Map of uncertainty substitutions. Irrelevant.
 		sub: (substitutions, uncertaintySubstitutions) ->
 			@copy()
 
-		# Gets greatest common divisor and divides out to simplify Constant
-		#
+		# Simplify this fraction in-place using Euclid's method.
 		simplifyInPlace: ->
 			# Get the greatest common divisor.
 			a = @numerator

			else
				return [@copy()]

		# Gets the uncertainty of the Variable
		#
		# @return [???] IDK how this one works either TBH
		getUncertainty: ->
			new Uncertainty(@label)

		# Gets the units of the Variable 
		#
		# @param variable [???]
		# @param equivalencies [???]
		# @return [units] The current units of the Variable
		getVariableUnits: (variable, equivalencies) ->
			if equivalencies?
				if @label in equivalencies.get(variable)

			else
				return if not assumeZero then @copy() else new Constant("0")

		# Substitute an expression.
		#
		# @deprecated
		substituteExpression: (sourceExpression, variable, equivalencies=null, eliminate=false) ->
			throw new Error("Can't sub uncertainties")

		# Get uncertainty.
		#
		# @throw [Error] Not implemented for uncertainties.
		getUncertainty: ->
			throw new Error("Can't take uncertainty of an uncertainty")

		# Get variable units.
		#
		# @throw [Error] Not implemented for uncertainties.
		getVariableUnits: (variable, equivalencies) ->
			throw new Error("Can't do that with uncertainties")

		# Set variable units.
		#
		# @throw [Error] Not implemented for uncertainties.
		setVariableUnits: (variable, equivalencies, units) ->
			throw new Error("Can't do that with uncertainties")

		# Simplify this node.
		#
		# @return [Uncertainty] A copy of this uncertainty.
		simplify: ->
			@copy()

		# Expand this node.
		#
		# @return [Uncertainty] A copy of this uncertainty.
		expand: ->
			@copy()

		# Expand and then simplify this node.
		#
		# @return [Uncertainty] A copy of this uncertainty.
		expandAndSimplify: ->
			@copy()

		# Make a new drawing node representing this uncertainty.
		#
		# @return [DrawingNode] A drawing node representing this uncertainty.
		toDrawingNode: ->
			UncertaintyNode = prettyRender.Uncertainty
			return new UncertaintyNode(@label)

		# Differentiate.
		# Don't differentiate uncertainties. It won't work.
		#
		# @throw [Error] Not implemented for uncertainties.
		differentiate: (variable) ->
			throw new Error("Can't differentiate uncertainties!")

