public version (9d27f769) · Commits · Ec327 Public Projects / 2024 / Group 5

6-simple-conversion.js

0 → 100644

+92 −0

Original line number	Diff line number	Diff line
		// Function for Scientific Notation
		function snot(val) {
		if (Math.abs(val) > 1e6 \|\| Math.abs(val) < 1e-6) {
		return val.toExponential(6); // Return value in scientific notation
		}
		return val; // Return value as-is
		}

		// Meters Conversions
		function metersToCentimeters(meters) {
		return snot(meters * 100);
		}

		function metersToInches(meters) {
		return snot(meters * 39.3701);
		}

		function metersToFeet(meters) {
		return snot(meters * 3.28084);
		}

		function metersToMiles(meters) {
		return snot(meters * 0.000621371);
		}

		// Centimeter Conversions
		function centimetersToMeters(centimeters) {
		return snot(centimeters / 100.0);
		}

		function centimetersToInches(centimeters) {
		return snot(centimeters * 0.393701);
		}

		function centimetersToFeet(centimeters) {
		return snot(centimeters * 0.0328084);
		}

		function centimetersToMiles(centimeters) {
		return snot(centimeters * 0.00000621371);
		}

		// Feet Conversions
		function FeetToMiles(feet) {
		return snot(feet * 0.0001893939394);
		}

		function FeetToInches(feet) {
		return snot(feet * 12);
		}

		function FeetToMeters(feet) {
		return snot(feet * 0.3048);
		}

		function FeetToCentimeters(feet) {
		return snot(feet * 30.48);
		}

		// Mile Conversions
		function MilesToFeet(miles) {
		return snot(miles * 5280);
		}

		function MilesToInches(miles) {
		return snot(miles * 63360);
		}

		function MilesToMeters(miles) {
		return snot(miles * 1609.34);
		}

		function MilesToCentimeters(miles) {
		return snot(miles * 160934);
		}

		// Inch Conversions
		function inchesToCentimeters(inches) {
		return snot(inches * 2.54);
		}

		function inchesToMeters(inches) {
		return snot(inches * 0.0254);
		}

		function InchesToFeet(inches) {
		return snot(inches * 0.0833333);
		}

		function InchesToMiles(inches) {
		return snot(inches * 0.0000157828);
		}

C Files/Angles.c

0 → 100644

+93 −0

Original line number	Diff line number	Diff line
		#include <stdio.h>
		#include <stdlib.h>
		#include <math.h>
		#include <emscripten.h>

		#define PI 3.14159265358979323846

		//The function utilizes a switch statement to determine the type of conversion to apply. Depending on the value of query, the function calculates the equivalent value in a different unit or returns the input unchanged. If an invalid query is provided, the function returns NAN to indicate an error. The EMSCRIPTEN_KEEPALIVE directive ensures the function remains accessible in a WebAssembly context when compiled using Emscripten.


		// Degrees conversions
		EMSCRIPTEN_KEEPALIVE
		double ConvertFromDegrees(double value, int query) {
		switch (query) {
		case 1: return value; // Degrees to Degrees
		case 2: return value * (PI / 180.0); // Degrees to Radians
		case 3: return value * 3600; // Degrees to Arcsecond
		case 4: return value * 1.111111; // Degrees to Gradian
		case 5: return value * 17.777777778; // Degrees to Milliradian
		case 6: return value * 60; // Degrees to Minute of arc
		default: return NAN;
		}
		}

		// Radians conversions
		EMSCRIPTEN_KEEPALIVE
		double ConvertFromRadians(double value, int query) {
		switch (query) {
		case 1: return value * (180.0 / PI); // Radians to Degrees
		case 2: return value; // Radians to Radians
		case 3: return value * 206264.806; // Radians to Arcsecond
		case 4: return value * 63.661977236; // Radians to Gradian
		case 5: return value * 1000; // Radians to Milliradian
		case 6: return value * 3437.746771; // Radians to Minute of arc
		default: return NAN;
		}
		}

		// Arcsecond conversions
		EMSCRIPTEN_KEEPALIVE
		double ConvertFromArcsecond(double value, int query) {
		switch (query) {
		case 1: return value * (1.0 / 3600.0); // Arcsecond to Degrees
		case 2: return value * (PI / (180.0 * 3600.0)); // Arcsecond to Radians
		case 3: return value; // Arcsecond to Arcsecond
		case 4: return value * 0.0003086; // Arcsecond to Gradian
		case 5: return value * 0.004848; // Arcsecond to Milliradian
		case 6: return value * (1.0 / 60.0); // Arcsecond to Minute of arc
		default: return NAN;
		}
		}

		// Gradian conversions
		EMSCRIPTEN_KEEPALIVE
		double ConvertFromGradian(double value, int query) {
		switch (query) {
		case 1: return value * 0.9; // Gradian to Degrees
		case 2: return value * (PI / 200.0); // Gradian to Radians
		case 3: return value * 3240; // Gradian to Arcsecond
		case 4: return value; // Gradian to Gradian
		case 5: return value * 15.707963268; // Gradian to Milliradian
		case 6: return value * 54; // Gradian to Minute of arc
		default: return NAN;
		}
		}

		// Milliradian conversions
		EMSCRIPTEN_KEEPALIVE
		double ConvertFromMilliradian(double value, int query) {
		switch (query) {
		case 1: return value * 0.0572958; // Milliradian to Degrees
		case 2: return value * 0.001; // Milliradian to Radians
		case 3: return value * 206.2648062; // Milliradian to Arcsecond
		case 4: return value * 0.0636620; // Milliradian to Gradian
		case 5: return value; // Milliradian to Milliradian
		case 6: return value * 3.437746771; // Milliradian to Minute of arc
		default: return NAN;
		}
		}

		// Minute of arc conversions
		EMSCRIPTEN_KEEPALIVE
		double ConvertFromMinuteOfArc(double value, int query) {
		switch (query) {
		case 1: return value * (1.0 / 60.0); // Minute of arc to Degrees
		case 2: return value * (PI / (180.0 * 60.0)); // Minute of arc to Radians
		case 3: return value * 60; // Minute of arc to Arcsecond
		case 4: return value * 0.018519; // Minute of arc to Gradian
		case 5: return value * 0.290888; // Minute of arc to Milliradian
		case 6: return value; // Minute of arc to Minute of arc
		default: return NAN;
		}
		}
		No newline at end of file

C Files/AreaFunction.c

0 → 100644

+142 −0

Original line number	Diff line number	Diff line
		#include <stdio.h>
		#include <stdlib.h>
		#include <math.h>
		#include <emscripten.h>

		//The function utilizes a switch statement to determine the type of conversion to apply. Depending on the value of query, the function calculates the equivalent value in a different unit or returns the input unchanged. If an invalid query is provided, the function returns NAN to indicate an error. The EMSCRIPTEN_KEEPALIVE directive ensures the function remains accessible in a WebAssembly context when compiled using Emscripten.

		// Conversions For Square Kilometer

		EMSCRIPTEN_KEEPALIVE
		double convertSquareKilo(double SquareKilo, int query) {
		switch(query) {
		case 1: return SquareKilo; // Square Kilometer
		case 2: return SquareKilo * 1e+6; // Squaremeter
		case 3: return SquareKilo * 0.386102; // Squaremile
		case 4: return SquareKilo * 1.19599e+6; // Squareyard
		case 5: return SquareKilo * 1.076391e+7; // Squarefoot
		case 6: return SquareKilo * 1.55e+9; // Squareinch
		case 7: return SquareKilo * 100; // Hectare
		case 8: return SquareKilo * 247.105; // Acre
		default: return NAN; // Invalid query
		}
		}

		//Conversions For Square Meter

		EMSCRIPTEN_KEEPALIVE
		double convertSquareMeter(double SquareMeter, int query) {
		switch(query) {
		case 1: return SquareMeter * 1e-6; // Squarekilometer
		case 2: return SquareMeter; // SquareMeter
		case 3: return SquareMeter * 3.861e-7; // Squaremile
		case 4: return SquareMeter * 1.19599; // Squareyard
		case 5: return SquareMeter * 10.76391; // Squarefoot
		case 6: return SquareMeter * 1550.003; // Squareinch
		case 7: return SquareMeter * 0.0001; // Hectare
		case 8: return SquareMeter * 0.000247105; // Acre
		default: return NAN; // Invalid query
		}
		}

		// Conversions For Square Mile

		EMSCRIPTEN_KEEPALIVE
		double convertSquareMile(double SquareMile, int query) {
		switch(query) {
		case 1: return SquareMile * 2.58999e+6; // Squaremeter
		case 2: return SquareMile * 2.58999; // Squarekilometer
		case 3: return SquareMile; // SquareMile
		case 4: return SquareMile * 3.0976e+6; // Squareyard
		case 5: return SquareMile * 2.78784e+7; // Squarefoot
		case 6: return SquareMile * 4.01449e+9; // Squareinch
		case 7: return SquareMile * 258.99881; // Hectare
		case 8: return SquareMile * 640; // Acre
		default: return NAN; // Invalid query
		}
		}

		// Conversions For Yard

		EMSCRIPTEN_KEEPALIVE
		double convertSquareYard(double SquareYard, int query) {
		switch(query) {
		case 1: return SquareYard * 0.836127; // Squaremeter
		case 2: return SquareYard * 8.3613e-7; // Squarekilometer
		case 3: return SquareYard * 3.2296e-7; // Squaremile
		case 4: return SquareYard; // Square Yard
		case 5: return SquareYard * 9; // Squarefoot
		case 6: return SquareYard * 1296; // Squareinch
		case 7: return SquareYard * 8.36127e-5; // Hectare
		case 8: return SquareYard * 0.00020661157; // Acre
		default: return NAN; // Invalid query
		}
		}

		// Conversions For Square Foot

		EMSCRIPTEN_KEEPALIVE
		double convertSquareFoot(double SquareFoot, int query) {
		switch(query) {
		case 1: return SquareFoot * 0.092903; // Squaremeter
		case 2: return SquareFoot * 9.2903e-8; // Squarekilometer
		case 3: return SquareFoot * 3.587e-8; // Squaremile
		case 4: return SquareFoot * 0.111111; // Squareyard
		case 5: return SquareFoot; // Square Foot
		case 6: return SquareFoot * 144; // Squareinch
		case 7: return SquareFoot * 9.2903e-6; // Hectare
		case 8: return SquareFoot * 2.2957e-5; // Acre
		default: return NAN; // Invalid query
		}
		}

		// Conversions For Square Inch

		EMSCRIPTEN_KEEPALIVE
		double convertSquareInch(double SquareInch, int query) {
		switch(query) {
		case 1: return SquareInch * 0.00064516; // Squaremeter
		case 2: return SquareInch * 6.4516e-10; // Squarekilometer
		case 3: return SquareInch * 2.49098e-10; // Squaremile
		case 4: return SquareInch * 0.000771605; // Squareyard
		case 5: return SquareInch * 0.00694444; // Squarefoot
		case 6: return SquareInch; // SquareInch
		case 7: return SquareInch * 6.4516e-8; // Hectare
		case 8: return SquareInch * 1.5942e-7; // Acre
		default: return NAN; // Invalid query
		}
		}

		// Conversions For Hectare

		EMSCRIPTEN_KEEPALIVE
		double convertHectare(double Hectare, int query) {
		switch(query) {
		case 1: return Hectare * 10000; // Squaremeter
		case 2: return Hectare * 0.01; // Squarekilometer
		case 3: return Hectare * 0.00386102; // Squaremile
		case 4: return Hectare * 11959.9; // Squareyard
		case 5: return Hectare * 107639.104; // Squarefoot
		case 6: return Hectare * 1.55e+7; // Squareinch
		case 7: return Hectare; // Hectare
		case 8: return Hectare * 2.47105; // Acre
		default: return NAN; // Invalid query
		}
		}

		// Conversions For Acre

		EMSCRIPTEN_KEEPALIVE
		double convertAcre(double Acre, int query) {
		switch(query) {
		case 1: return Acre * 4046.86; // Squaremeter
		case 2: return Acre * 0.00404686; // Squarekilometer
		case 3: return Acre * 0.0015625; // Squaremile
		case 4: return Acre * 4840; // Squareyard
		case 5: return Acre * 43560; // Squarefoot
		case 6: return Acre * 6272640; // Squareinch
		case 7: return Acre * 0.404686; // Hectare
		case 8: return Acre; // Acre
		default: return NAN; // Invalid query
		}
		}
		No newline at end of file