trackler 2.2.1.85 → 2.2.1.86

data/tracks/bash/exercises/two-fer/README.md

@@ -21,7 +21,7 @@ readable as we can.
 
 Run the tests with:
 
-    bats whatever_test.sh
+    bats two_fer_test.sh
 
 ## Source
 

data/tracks/bash/exercises/word-count/README.md

@@ -14,7 +14,7 @@ free: 1
 
 Run the tests with:
 
-    bats whatever_test.sh
+    bats word_count_test.sh
 
 ## Source
 

data/tracks/c/config.json

@@ -477,6 +477,17 @@
         "enums"
       ],
       "uuid": "b0a152e9-5a45-41f9-bda0-427111d9a56c"
+    },
+    {
+      "core": false,
+      "difficulty": 2,
+      "slug": "complex-numbers",
+      "topics": [
+        "structs",
+        "performance_optimizations"
+      ],
+      "unlocked_by": "difference-of-squares",
+      "uuid": "472b1a6b-2b7a-4609-a97d-4c2b6c941a1f"
     }
   ],
   "foregone": [],

data/tracks/c/exercises/complex-numbers/README.md

@@ -0,0 +1,67 @@
+# Complex Numbers
+
+A complex number is a number in the form `a + b * i` where `a` and `b` are real and `i` satisfies `i^2 = -1`.
+
+`a` is called the real part and `b` is called the imaginary part of `z`.
+The conjugate of the number `a + b * i` is the number `a - b * i`.
+The absolute value of a complex number `z = a + b * i` is a real number `|z| = sqrt(a^2 + b^2)`. The square of the absolute value `|z|^2` is the result of multiplication of `z` by its complex conjugate.
+
+The sum/difference of two complex numbers involves adding/subtracting their real and imaginary parts separately:
+`(a + i * b) + (c + i * d) = (a + c) + (b + d) * i`,
+`(a + i * b) - (c + i * d) = (a - c) + (b - d) * i`.
+
+Multiplication result is by definition
+`(a + i * b) * (c + i * d) = (a * c - b * d) + (b * c + a * d) * i`.
+
+The reciprocal of a non-zero complex number is
+`1 / (a + i * b) = a/(a^2 + b^2) - b/(a^2 + b^2) * i`.
+
+Dividing a complex number `a + i * b` by another `c + i * d` gives:
+`(a + i * b) / (c + i * d) = (a * c + b * d)/(c^2 + d^2) + (b * c - a * d)/(c^2 + d^2) * i`.
+
+Exponent of a complex number can be expressed as
+`exp(a + i * b) = exp(a) * exp(i * b)`,
+and the last term is given by Euler's formula `exp(i * b) = cos(b) + i * sin(b)`.
+
+
+Implement the following operations:
+ - addition, subtraction, multiplication and division of two complex numbers,
+ - conjugate, absolute value, exponent of a given complex number.
+
+
+Assume the programming language you are using does not have an implementation of complex numbers.
+
+
+## Getting Started
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/c).
+
+## Running the tests
+
+To run the test suite, execute the following command:
+
+```bash
+make test
+```
+
+To check for memory leaks using [Valgrind](http://valgrind.org/), execute the following command:
+```bash
+make memcheck
+```
+You will need Valgrind to do this. See your distribution documentation for how to install Valgrind.
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/c](https://github.com/exercism/c) repository on
+GitHub is the home for all of the C exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue.  We'll do our best to help you!
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Complex_number](https://en.wikipedia.org/wiki/Complex_number)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/c/exercises/complex-numbers/makefile

@@ -0,0 +1,27 @@
+CFLAGS  = -std=c99
+CFLAGS += -g
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -pedantic
+CFLAGS += -Werror
+
+VFLAGS  = --quiet
+VFLAGS += --tool=memcheck
+VFLAGS += --leak-check=full
+VFLAGS += --error-exitcode=1
+
+LDFLAGS  = -lm
+
+test: tests.out
+	@./tests.out
+
+memcheck: tests.out
+	@valgrind $(VFLAGS) ./tests.out
+	@echo "Memory check passed"
+
+clean:
+	rm -rf *.o *.out *.out.dSYM
+
+tests.out: test/test_complex_numbers.c src/complex_numbers.c src/complex_numbers.h
+	@echo Compiling $@
+	@cc $(CFLAGS) src/complex_numbers.c test/vendor/unity.c test/test_complex_numbers.c $(LDFLAGS) -o tests.out

data/tracks/c/exercises/complex-numbers/src/complex_numbers.c

@@ -0,0 +1,46 @@
+#include "complex_numbers.h"
+
+complex_t c_add(complex_t a, complex_t b)
+{
+   // TODO: implement
+}
+
+complex_t c_sub(complex_t a, complex_t b)
+{
+   // TODO: implement
+}
+
+complex_t c_mul(complex_t a, complex_t b)
+{
+   // TODO: implement
+}
+
+complex_t c_div(complex_t a, complex_t b)
+{
+   // TODO: implement
+}
+
+double c_abs(complex_t x)
+{
+   // TODO: implement
+}
+
+complex_t c_conjugate(complex_t x)
+{
+   // TODO: implement
+}
+
+double c_real(complex_t x)
+{
+   // TODO: implement
+}
+
+double c_imag(complex_t x)
+{
+   // TODO: implement
+}
+
+complex_t c_exp(complex_t x)
+{
+   // TODO: implement
+}

data/tracks/c/exercises/complex-numbers/src/complex_numbers.h

@@ -0,0 +1,19 @@
+#ifndef _COMPLEX_NUMBERS_H_
+#define _COMPLEX_NUMBERS_H_
+
+typedef struct {
+   double real;
+   double imag;
+} complex_t;
+
+complex_t c_add(complex_t a, complex_t b);
+complex_t c_sub(complex_t a, complex_t b);
+complex_t c_mul(complex_t a, complex_t b);
+complex_t c_div(complex_t a, complex_t b);
+double c_abs(complex_t x);
+complex_t c_conjugate(complex_t x);
+double c_real(complex_t x);
+double c_imag(complex_t x);
+complex_t c_exp(complex_t x);
+
+#endif

data/tracks/c/exercises/complex-numbers/src/example.c

@@ -0,0 +1,80 @@
+#include "complex_numbers.h"
+#include <math.h>
+
+static double square(double x)
+{
+   return x * x;
+}
+
+complex_t c_add(const complex_t a, const complex_t b)
+{
+   complex_t result;
+   result.real = a.real + b.real;
+   result.imag = a.imag + b.imag;
+
+   return result;
+}
+
+complex_t c_sub(const complex_t a, const complex_t b)
+{
+   complex_t result;
+   result.real = a.real - b.real;
+   result.imag = a.imag - b.imag;
+
+   return result;
+}
+
+complex_t c_mul(const complex_t a, const complex_t b)
+{
+   complex_t result;
+   result.real = a.real * b.real - a.imag * b.imag;
+   result.imag = a.imag * b.real + a.real * b.imag;
+
+   return result;
+}
+
+complex_t c_div(const complex_t a, const complex_t b)
+{
+   double denominator = square(b.real) + square(b.imag);
+
+   complex_t result;
+   result.real = (a.real * b.imag + a.imag * b.real) / denominator;
+   result.imag = (a.imag * b.real - a.real * b.imag) / denominator;
+
+   return result;
+}
+
+double c_abs(const complex_t x)
+{
+   return sqrt(square(x.real) + square(x.imag));
+}
+
+complex_t c_conjugate(const complex_t x)
+{
+   complex_t result;
+   result.real = x.real;
+   result.imag = -(x.imag);
+
+   return result;
+}
+
+double c_real(const complex_t x)
+{
+   return x.real;
+}
+
+double c_imag(const complex_t x)
+{
+   return x.imag;
+}
+
+complex_t c_exp(const complex_t x)
+{
+   double real_exp = exp(x.real);
+
+   complex_t result;
+   result.real = real_exp * cos(x.imag);
+   result.imag = real_exp * sin(x.imag);
+
+   return result;
+}

data/tracks/c/exercises/complex-numbers/test/test_complex_numbers.c

@@ -0,0 +1,397 @@
+#include "../src/complex_numbers.h"
+
+#define UNITY_FLOAT_TYPE double
+#include "vendor/unity.h"
+
+#include <math.h>
+
+#define PI acos(-1)
+#define E exp(1)
+
+void compare_complex(complex_t lhs, complex_t rhs)
+{
+   TEST_ASSERT_EQUAL_FLOAT(lhs.real, rhs.real);
+   TEST_ASSERT_EQUAL_FLOAT(lhs.imag, rhs.imag);
+}
+
+void test_imaginary_unit(void)
+{
+   complex_t z = {.real = 0.0,.imag = 1.0 };
+
+   complex_t expected = {.real = -1.0,.imag = 0.0 };
+   complex_t actual = c_mul(z, z);
+
+   compare_complex(expected, actual);
+}
+
+void test_add_purely_real_numbers(void)
+{
+   TEST_IGNORE();
+
+   complex_t z1 = {.real = 1.0,.imag = 0.0 };
+   complex_t z2 = {.real = 2.0,.imag = 0.0 };
+
+   complex_t expected = {.real = 3.0,.imag = 0.0 };
+   complex_t actual = c_add(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_add_purely_imaginary_numbers(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 0.0,.imag = 1.0 };
+   complex_t z2 = {.real = 0.0,.imag = 2.0 };
+
+   complex_t expected = {.real = 0.0,.imag = 3.0 };
+   complex_t actual = c_add(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_add_numbers_with_real_and_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 1.0,.imag = 2.0 };
+   complex_t z2 = {.real = 3.0,.imag = 4.0 };
+
+   complex_t expected = {.real = 4.0,.imag = 6.0 };
+   complex_t actual = c_add(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_subtract_purely_real_numbers(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 1.0,.imag = 0.0 };
+   complex_t z2 = {.real = 2.0,.imag = 0.0 };
+
+   complex_t expected = {.real = -1.0,.imag = 0.0 };
+   complex_t actual = c_sub(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_subtract_purely_imaginary_numbers(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 0.0,.imag = 1.0 };
+   complex_t z2 = {.real = 0.0,.imag = 2.0 };
+
+   complex_t expected = {.real = 0.0,.imag = -1.0 };
+   complex_t actual = c_sub(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_subtract_numbers_with_real_and_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 1.0,.imag = 2.0 };
+   complex_t z2 = {.real = 3.0,.imag = 4.0 };
+
+   complex_t expected = {.real = -2.0,.imag = -2.0 };
+   complex_t actual = c_sub(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_multiply_purely_real_numbers(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 1.0,.imag = 0.0 };
+   complex_t z2 = {.real = 2.0,.imag = 0.0 };
+
+   complex_t expected = {.real = 2.0,.imag = 0.0 };
+   complex_t actual = c_mul(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_multiply_purely_imaginary_numbers(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 0.0,.imag = 1.0 };
+   complex_t z2 = {.real = 0.0,.imag = 2.0 };
+
+   complex_t expected = {.real = -2.0,.imag = 0.0 };
+   complex_t actual = c_mul(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_multiply_numbers_with_real_and_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 1.0,.imag = 2.0 };
+   complex_t z2 = {.real = 3.0,.imag = 4.0 };
+
+   complex_t expected = {.real = -5.0,.imag = 10.0 };
+   complex_t actual = c_mul(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_divide_purely_real_numbers(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 1.0,.imag = 0.0 };
+   complex_t z2 = {.real = 2.0,.imag = 0.0 };
+
+   complex_t expected = {.real = 0.5,.imag = 0.0 };
+   complex_t actual = c_div(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_divide_purely_imaginary_numbers(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 0.0,.imag = 1.0 };
+   complex_t z2 = {.real = 0.0,.imag = 2.0 };
+
+   complex_t expected = {.real = 0.5,.imag = 0.0 };
+   complex_t actual = c_div(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_divide_numbers_with_real_and_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z1 = {.real = 1.0,.imag = 2.0 };
+   complex_t z2 = {.real = 3.0,.imag = 4.0 };
+
+   complex_t expected = {.real = 0.44,.imag = 0.08 };
+   complex_t actual = c_div(z1, z2);
+
+   compare_complex(expected, actual);
+}
+
+void test_abs_of_a_positive_purely_real_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 5.0,.imag = 0.0 };
+
+   double expected = 5.0;
+   double actual = c_abs(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_abs_of_a_negative_purely_real_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = -5.0,.imag = 0.0 };
+
+   double expected = 5.0;
+   double actual = c_abs(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_abs_of_a_purely_imaginary_number_with_positive_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 0.0,.imag = 5.0 };
+
+   double expected = 5.0;
+   double actual = c_abs(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_abs_of_a_purely_imaginary_number_with_negative_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 0.0,.imag = -5.0 };
+
+   double expected = 5.0;
+   double actual = c_abs(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_abs_of_a_number_with_real_and_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 3.0,.imag = 4.0 };
+
+   double expected = 5.0;
+   double actual = c_abs(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_complex_conjugate_of_a_purely_real_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 5.0,.imag = 0.0 };
+
+   complex_t expected = {.real = 5.0,.imag = 0.0 };
+   complex_t actual = c_conjugate(z);
+
+   compare_complex(expected, actual);
+}
+
+void test_complex_conjugate_of_a_purely_imaginary_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 0.0,.imag = 5.0 };
+
+   complex_t expected = {.real = 0.0,.imag = -5.0 };
+   complex_t actual = c_conjugate(z);
+
+   compare_complex(expected, actual);
+}
+
+void test_complex_conjugate_of_a_number_with_real_and_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 1.0,.imag = 1.0 };
+
+   complex_t expected = {.real = 1.0,.imag = -1.0 };
+   complex_t actual = c_conjugate(z);
+
+   compare_complex(expected, actual);
+}
+
+void test_real_part_of_a_purely_real_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 1.0,.imag = 0.0 };
+
+   double expected = 1.0;
+   double actual = c_real(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_real_part_of_a_purely_imaginary_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 0.0,.imag = 1.0 };
+
+   double expected = 0.0;
+   double actual = c_real(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_real_part_of_a_number_with_real_and_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 1.0,.imag = 2.0 };
+
+   double expected = 1.0;
+   double actual = c_real(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_imaginary_part_of_a_purely_real_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 1.0,.imag = 0.0 };
+
+   double expected = 0.0;
+   double actual = c_imag(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_imaginary_part_of_a_purely_imaginary_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 0.0,.imag = 1.0 };
+
+   double expected = 1.0;
+   double actual = c_imag(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_imaginary_part_of_a_number_with_real_and_imaginary_part(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 1.0,.imag = 2.0 };
+
+   double expected = 2.0;
+   double actual = c_imag(z);
+
+   TEST_ASSERT_EQUAL_FLOAT(expected, actual);
+}
+
+void test_eulers_identity(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 0.0,.imag = PI };
+
+   complex_t expected = {.real = -1.0,.imag = 0.0 };
+   complex_t actual = c_exp(z);
+
+   TEST_ASSERT_FLOAT_WITHIN(1e-10, expected.real, actual.real);
+   TEST_ASSERT_FLOAT_WITHIN(1e-10, expected.imag, actual.imag);
+}
+
+void test_exponential_of_zero(void)
+{
+   TEST_IGNORE();
+   complex_t zero = {.real = 0.0,.imag = 0.0 };
+
+   complex_t expected = {.real = 1.0,.imag = 0.0 };
+   complex_t actual = c_exp(zero);
+
+   compare_complex(expected, actual);
+}
+
+void test_exponential_of_a_purely_real_number(void)
+{
+   TEST_IGNORE();
+   complex_t z = {.real = 1.0,.imag = 0.0 };
+
+   complex_t expected = {.real = E,.imag = 0.0 };
+   complex_t actual = c_exp(z);
+
+   compare_complex(expected, actual);
+}
+
+int main(void)
+{
+   UnityBegin("test/test_complex_numbers.c");
+
+   RUN_TEST(test_imaginary_unit);
+   RUN_TEST(test_add_purely_real_numbers);
+   RUN_TEST(test_add_purely_imaginary_numbers);
+   RUN_TEST(test_add_numbers_with_real_and_imaginary_part);
+   RUN_TEST(test_subtract_purely_real_numbers);
+   RUN_TEST(test_subtract_purely_imaginary_numbers);
+   RUN_TEST(test_subtract_numbers_with_real_and_imaginary_part);
+   RUN_TEST(test_multiply_numbers_with_real_and_imaginary_part);
+   RUN_TEST(test_multiply_numbers_with_real_and_imaginary_part);
+   RUN_TEST(test_multiply_numbers_with_real_and_imaginary_part);
+   RUN_TEST(test_divide_numbers_with_real_and_imaginary_part);
+   RUN_TEST(test_divide_numbers_with_real_and_imaginary_part);
+   RUN_TEST(test_divide_numbers_with_real_and_imaginary_part);
+   RUN_TEST(test_abs_of_a_positive_purely_real_number);
+   RUN_TEST(test_abs_of_a_negative_purely_real_number);
+   RUN_TEST(test_abs_of_a_purely_imaginary_number_with_positive_imaginary_part);
+   RUN_TEST(test_abs_of_a_purely_imaginary_number_with_negative_imaginary_part);
+   RUN_TEST(test_abs_of_a_number_with_real_and_imaginary_part);
+   RUN_TEST(test_complex_conjugate_of_a_purely_real_number);
+   RUN_TEST(test_complex_conjugate_of_a_purely_imaginary_number);
+   RUN_TEST(test_complex_conjugate_of_a_number_with_real_and_imaginary_part);
+   RUN_TEST(test_real_part_of_a_purely_real_number);
+   RUN_TEST(test_real_part_of_a_purely_imaginary_number);
+   RUN_TEST(test_real_part_of_a_number_with_real_and_imaginary_part);
+   RUN_TEST(test_imaginary_part_of_a_purely_real_number);
+   RUN_TEST(test_imaginary_part_of_a_purely_imaginary_number);
+   RUN_TEST(test_imaginary_part_of_a_number_with_real_and_imaginary_part);
+   RUN_TEST(test_eulers_identity);
+   RUN_TEST(test_exponential_of_zero);
+   RUN_TEST(test_exponential_of_a_purely_real_number);
+
+   UnityEnd();
+   return 0;
+}