diff --git a/math/perimeter b/math/perimeter
new file mode 100755
index 000000000..7ddf1b4e4
Binary files /dev/null and b/math/perimeter differ
diff --git a/math/perimeter.cpp b/math/perimeter.cpp
index 7967535e7..2c4377ed4 100644
--- a/math/perimeter.cpp
+++ b/math/perimeter.cpp
@@ -1,9 +1,9 @@
 /**
  * @file
- * @brief Implementations for the [area](https://en.wikipedia.org/wiki/Perimeter) of
+ * @brief Implementations for the [perimeter](https://en.wikipedia.org/wiki/Perimeter) of
  * various shapes
- * @details The area of a shape is the amount of 2D space it takes up.
- * All shapes have a formula to get the area of any given shape.
+ * @details The  of a shape is the amount of 2D space it takes up.
+ * All shapes have a formula to get the perimeter of any given shape.
  * These implementations support multiple return types.
  *
  * @author [OGscorpion](https://github.com/OGscorpion)
@@ -21,93 +21,90 @@
  */
 namespace math {
 /**
- * @brief area of a [square](https://en.wikipedia.org/wiki/Square) (l * l)
+ * @brief perimeter of a [square](https://en.wikipedia.org/wiki/Square) (4 * l)
  * @param length is the length of the square
- * @returns area of square
+ * @returns perimeter of square
  */
 template <typename T>
-T square_area(T length) {
-    return length * length;
+T square_perimeter(T length) {
+    return 4 * length;
 }
 
 /**
- * @brief area of a [rectangle](https://en.wikipedia.org/wiki/Rectangle) (l * w)
+ * @brief perimeter of a [rectangle](https://en.wikipedia.org/wiki/Rectangle) ( 2(l * w) )
  * @param length is the length of the rectangle
  * @param width is the width of the rectangle
- * @returns area of the rectangle
+ * @returns perimeter of the rectangle
  */
 template <typename T>
-T rect_area(T length, T width) {
-    return length * width;
+T rect_perimeter(T length, T width) {
+    return 2 * (length + width);
 }
 
 /**
- * @brief area of a [triangle](https://en.wikipedia.org/wiki/Triangle) (b * h /
- * 2)
+ * @brief perimeter of a [triangle](https://en.wikipedia.org/wiki/Triangle) (a + b + c)
  * @param base is the length of the bottom side of the triangle
  * @param height is the length of the tallest point in the triangle
- * @returns area of the triangle
+ * @returns perimeter of the triangle
  */
 template <typename T>
-T triangle_area(T base, T height) {
-    return base * height / 2;
+T triangle_perimeter(T base, T height, T hypotenuse) {
+    return base + height + hypotenuse;
 }
 
 /**
- * @brief area of a [circle](https://en.wikipedia.org/wiki/Area_of_a_circle) (pi
- * * r^2)
+ * @brief perimeter of a [circle](https://en.wikipedia.org/wiki/perimeter_of_a_circle) (2 * pi * r)
  * @param radius is the radius of the circle
- * @returns area of the circle
+ * @returns perimeter of the circle
  */
 template <typename T>
-T circle_area(T radius) {
-    return M_PI * pow(radius, 2);
+T circle_perimeter(T radius) {
+    return 2 * M_PI * radius;
 }
 
 /**
- * @brief area of a [parallelogram](https://en.wikipedia.org/wiki/Parallelogram)
- * (b * h)
+ * @brief perimeter of a [parallelogram](https://en.wikipedia.org/wiki/Parallelogram)
+ * 2(b + h)
  * @param base is the length of the bottom side of the parallelogram
  * @param height is the length of the tallest point in the parallelogram
- * @returns area of the parallelogram
+ * @returns perimeter of the parallelogram
  */
 template <typename T>
-T parallelogram_area(T base, T height) {
-    return base * height;
+T parallelogram_perimeter(T base, T height) {
+    return  2 * (base + height);
 }
 
 /**
- * @brief surface area of a [cube](https://en.wikipedia.org/wiki/Cube) ( 6 * (l
- * * l))
+ * @brief surface perimeter of a [cube](https://en.wikipedia.org/wiki/Cube) ( 12 * l)
  * @param length is the length of the cube
- * @returns surface area of the cube
+ * @returns surface perimeter of the cube
  */
 template <typename T>
-T cube_surface_area(T length) {
-    return 6 * length * length;
+T cube_surface_perimeter(T length) {
+    return 12 * length;
 }
 
 /**
- * @brief surface area of a [sphere](https://en.wikipedia.org/wiki/Sphere) ( 4 *
- * pi * r^2)
- * @param radius is the radius of the sphere
- * @returns surface area of the sphere
+ * @brief surface perimeter of a [n-polygon](https://www.cuemath.com/measurement/perimeter-of-polygon/) ( n * l)
+ * @param length is the length of the polygon
+ * @param sides is the number of sides of the polygon
+ * @returns surface perimeter of the polygon
  */
 template <typename T>
-T sphere_surface_area(T radius) {
-    return 4 * M_PI * pow(radius, 2);
+T n_polygon_surface_perimeter(T sides, T length) {
+    return sides * length;
 }
 
 /**
- * @brief surface area of a [cylinder](https://en.wikipedia.org/wiki/Cylinder)
- * (2 * pi * r * h + 2 * pi * r^2)
+ * @brief surface perimeter of a [cylinder](https://en.wikipedia.org/wiki/Cylinder)
+ * (2 * radius + 2 * height)
  * @param radius is the radius of the cylinder
  * @param height is the height of the cylinder
- * @returns surface area of the cylinder
+ * @returns surface perimeter of the cylinder
  */
 template <typename T>
-T cylinder_surface_area(T radius, T height) {
-    return 2 * M_PI * radius * height + 2 * M_PI * pow(radius, 2);
+T cylinder_surface_perimeter(T radius, T height) {
+    return (2 * radius) + (2 * height);
 }
 }  // namespace math
 
@@ -121,151 +118,155 @@ static void test() {
     uint16_t int_width = 0;     // 16 bit integer width input
     uint16_t int_base = 0;      // 16 bit integer base input
     uint16_t int_height = 0;    // 16 bit integer height input
+    uint16_t int_hypotenuse = 0;  // 16 bit integer hypotenuse input
+    uint16_t int_sides = 0;     // 16 bit integer sides input
     uint16_t int_expected = 0;  // 16 bit integer expected output
-    uint16_t int_area = 0;      // 16 bit integer output
+    uint16_t int_perimeter = 0;      // 16 bit integer output
 
     float float_length = NAN;    // float length input
     float float_expected = NAN;  // float expected output
-    float float_area = NAN;      // float output
+    float float_perimeter = NAN;      // float output
 
     double double_length = NAN;    // double length input
     double double_width = NAN;     // double width input
     double double_radius = NAN;    // double radius input
     double double_height = NAN;    // double height input
     double double_expected = NAN;  // double expected output
-    double double_area = NAN;      // double output
+    double double_perimeter = NAN;  // double output
 
     // 1st test
     int_length = 5;
-    int_expected = 25;
-    int_area = math::square_area(int_length);
+    int_expected = 20;
+    int_perimeter = math::square_perimeter(int_length);
 
-    std::cout << "AREA OF A SQUARE (int)" << std::endl;
+    std::cout << "perimeter OF A SQUARE (int)" << std::endl;
     std::cout << "Input Length: " << int_length << std::endl;
     std::cout << "Expected Output: " << int_expected << std::endl;
-    std::cout << "Output: " << int_area << std::endl;
-    assert(int_area == int_expected);
+    std::cout << "Output: " << int_perimeter << std::endl;
+    assert(int_perimeter == int_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 2nd test
     float_length = 2.5;
-    float_expected = 6.25;
-    float_area = math::square_area(float_length);
+    float_expected = 10;
+    float_perimeter = math::square_perimeter(float_length);
 
-    std::cout << "AREA OF A SQUARE (float)" << std::endl;
+    std::cout << "perimeter OF A SQUARE (float)" << std::endl;
     std::cout << "Input Length: " << float_length << std::endl;
     std::cout << "Expected Output: " << float_expected << std::endl;
-    std::cout << "Output: " << float_area << std::endl;
-    assert(float_area == float_expected);
+    std::cout << "Output: " << float_perimeter << std::endl;
+    assert(float_perimeter == float_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 3rd test
     int_length = 4;
     int_width = 7;
-    int_expected = 28;
-    int_area = math::rect_area(int_length, int_width);
+    int_expected = 22;
+    int_perimeter = math::rect_perimeter(int_length, int_width);
 
-    std::cout << "AREA OF A RECTANGLE (int)" << std::endl;
+    std::cout << "perimeter OF A RECTANGLE (int)" << std::endl;
     std::cout << "Input Length: " << int_length << std::endl;
     std::cout << "Input Width: " << int_width << std::endl;
     std::cout << "Expected Output: " << int_expected << std::endl;
-    std::cout << "Output: " << int_area << std::endl;
-    assert(int_area == int_expected);
+    std::cout << "Output: " << int_perimeter << std::endl;
+    assert(int_perimeter == int_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 4th test
     double_length = 2.5;
     double_width = 5.7;
-    double_expected = 14.25;
-    double_area = math::rect_area(double_length, double_width);
+    double_expected = 16.4;
+    double_perimeter = math::rect_perimeter(double_length, double_width);
 
-    std::cout << "AREA OF A RECTANGLE (double)" << std::endl;
+    std::cout << "perimeter OF A RECTANGLE (double)" << std::endl;
     std::cout << "Input Length: " << double_length << std::endl;
     std::cout << "Input Width: " << double_width << std::endl;
     std::cout << "Expected Output: " << double_expected << std::endl;
-    std::cout << "Output: " << double_area << std::endl;
-    assert(double_area == double_expected);
+    std::cout << "Output: " << double_perimeter << std::endl;
+    assert(double_perimeter == double_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 5th test
     int_base = 10;
     int_height = 3;
-    int_expected = 15;
-    int_area = math::triangle_area(int_base, int_height);
+    int_hypotenuse = 5;
+    int_expected = 18;
+    int_perimeter = math::triangle_perimeter(int_base, int_height, int_hypotenuse);
 
-    std::cout << "AREA OF A TRIANGLE" << std::endl;
+    std::cout << "perimeter OF A TRIANGLE" << std::endl;
     std::cout << "Input Base: " << int_base << std::endl;
     std::cout << "Input Height: " << int_height << std::endl;
     std::cout << "Expected Output: " << int_expected << std::endl;
-    std::cout << "Output: " << int_area << std::endl;
-    assert(int_area == int_expected);
+    std::cout << "Output: " << int_perimeter << std::endl;
+    assert(int_perimeter == int_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 6th test
     double_radius = 6;
     double_expected =
-        113.09733552923255;  // rounded down because the double datatype
+        37.69911184307752;  // rounded down because the double datatype
                              // truncates after 14 decimal places
-    double_area = math::circle_area(double_radius);
+    double_perimeter = math::circle_perimeter(double_radius);
 
-    std::cout << "AREA OF A CIRCLE" << std::endl;
+    std::cout << "perimeter OF A CIRCLE" << std::endl;
     std::cout << "Input Radius: " << double_radius << std::endl;
     std::cout << "Expected Output: " << double_expected << std::endl;
-    std::cout << "Output: " << double_area << std::endl;
-    assert(double_area == double_expected);
+    std::cout << "Output: " << double_perimeter << std::endl;
+    assert(double_perimeter == double_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 7th test
     int_base = 6;
     int_height = 7;
-    int_expected = 42;
-    int_area = math::parallelogram_area(int_base, int_height);
+    int_expected = 26;
+    int_perimeter = math::parallelogram_perimeter(int_base, int_height);
 
-    std::cout << "AREA OF A PARALLELOGRAM" << std::endl;
+    std::cout << "perimeter OF A PARALLELOGRAM" << std::endl;
     std::cout << "Input Base: " << int_base << std::endl;
     std::cout << "Input Height: " << int_height << std::endl;
     std::cout << "Expected Output: " << int_expected << std::endl;
-    std::cout << "Output: " << int_area << std::endl;
-    assert(int_area == int_expected);
+    std::cout << "Output: " << int_perimeter << std::endl;
+    assert(int_perimeter == int_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 8th test
     double_length = 5.5;
-    double_expected = 181.5;
-    double_area = math::cube_surface_area(double_length);
+    double_expected = 66.0;
+    double_perimeter = math::cube_surface_perimeter(double_length);
 
-    std::cout << "SURFACE AREA OF A CUBE" << std::endl;
+    std::cout << "SURFACE perimeter OF A CUBE" << std::endl;
     std::cout << "Input Length: " << double_length << std::endl;
     std::cout << "Expected Output: " << double_expected << std::endl;
-    std::cout << "Output: " << double_area << std::endl;
-    assert(double_area == double_expected);
+    std::cout << "Output: " << double_perimeter << std::endl;
+    assert(double_perimeter == double_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 9th test
-    double_radius = 10.0;
-    double_expected = 1256.6370614359172;  // rounded down because the whole
-                                           // value gets truncated
-    double_area = math::sphere_surface_area(double_radius);
+    int_sides = 7;
+    int_length = 10;
+    int_expected = 70; 
+    int_perimeter = math::n_polygon_surface_perimeter(int_sides, int_length);
 
-    std::cout << "SURFACE AREA OF A SPHERE" << std::endl;
-    std::cout << "Input Radius: " << double_radius << std::endl;
-    std::cout << "Expected Output: " << double_expected << std::endl;
-    std::cout << "Output: " << double_area << std::endl;
-    assert(double_area == double_expected);
+    std::cout << "SURFACE perimeter OF A N-POLYGON" << std::endl;
+    std::cout << "Input Sides: " << int_sides << std::endl;
+    std::cout << "Input Length: " << int_length << std::endl;
+    std::cout << "Expected Output: " << int_expected << std::endl;
+    std::cout << "Output: " << int_perimeter << std::endl;
+    assert(int_perimeter == int_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 
     // 10th test
     double_radius = 4.0;
     double_height = 7.0;
-    double_expected = 276.46015351590177;
-    double_area = math::cylinder_surface_area(double_radius, double_height);
+    double_expected = 22.0;
+    double_perimeter = math::cylinder_surface_perimeter(double_radius, double_height);
 
-    std::cout << "SURFACE AREA OF A CYLINDER" << std::endl;
+    std::cout << "SURFACE perimeter OF A CYLINDER" << std::endl;
     std::cout << "Input Radius: " << double_radius << std::endl;
     std::cout << "Input Height: " << double_height << std::endl;
     std::cout << "Expected Output: " << double_expected << std::endl;
-    std::cout << "Output: " << double_area << std::endl;
-    assert(double_area == double_expected);
+    std::cout << "Output: " << double_perimeter << std::endl;
+    assert(double_perimeter == double_expected);
     std::cout << "TEST PASSED" << std::endl << std::endl;
 }
 
diff --git a/math/perimeter.dSYM/Contents/Info.plist b/math/perimeter.dSYM/Contents/Info.plist
new file mode 100644
index 000000000..c5f324668
--- /dev/null
+++ b/math/perimeter.dSYM/Contents/Info.plist
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.perimeter</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>
diff --git a/math/perimeter.dSYM/Contents/Resources/DWARF/perimeter b/math/perimeter.dSYM/Contents/Resources/DWARF/perimeter
new file mode 100644
index 000000000..1b6810752
Binary files /dev/null and b/math/perimeter.dSYM/Contents/Resources/DWARF/perimeter differ