From 696e8423de958396d7802f949efc94dc5122b426 Mon Sep 17 00:00:00 2001 From: Shreya123714 Date: Wed, 30 Oct 2024 20:35:40 +0530 Subject: [PATCH] created triangular fuzzy set class --- fuzzy_logic/triangular_fuzzyset.c | 214 ++++++++++++++++++++++++++++++ 1 file changed, 214 insertions(+) create mode 100644 fuzzy_logic/triangular_fuzzyset.c diff --git a/fuzzy_logic/triangular_fuzzyset.c b/fuzzy_logic/triangular_fuzzyset.c new file mode 100644 index 00000000..9344a848 --- /dev/null +++ b/fuzzy_logic/triangular_fuzzyset.c @@ -0,0 +1,214 @@ +/** + * @file + * @brief Implementation of a triangular fuzzy set. + * @details + * This file provides functions to create and manipulate triangular fuzzy sets, + * including methods to calculate membership values, union, intersection, + * complement, and a basic plot representation. + * + * By @Shreya123714 + * + * Based on: https://en.wikipedia.org/wiki/Fuzzy_set + */ + +#include // for assert +#include //for complex math operations +#include // for IO operations +#include // for string operations + +/** + * @brief Struct to represent a triangular fuzzy set. + */ +struct triangular_fuzzy_set +{ + char name[50]; ///< Name of the fuzzy set + double left_boundary; ///< Left boundary of the fuzzy set + double peak; ///< Peak (central) value of the fuzzy set + double right_boundary; ///< Right boundary of the fuzzy set +}; + +/** + * @brief Creates a triangular fuzzy set. + * @param name The name of the fuzzy set. + * @param left_boundary The left boundary of the fuzzy set. + * @param peak The peak of the fuzzy set. + * @param right_boundary The right boundary of the fuzzy set. + * @returns A triangular fuzzy set struct. + */ +struct triangular_fuzzy_set create_triangular_fuzzy_set(const char *name, + double left_boundary, + double peak, + double right_boundary) +{ + struct triangular_fuzzy_set set; + strncpy(set.name, name, sizeof(set.name) - 1); + set.name[sizeof(set.name) - 1] = '\0'; // Ensure null termination + set.left_boundary = left_boundary; + set.peak = peak; + set.right_boundary = right_boundary; + return set; +} + +/** + * @brief Calculates the membership value for a given input. + * @param set The triangular fuzzy set. + * @param x The value to evaluate the membership for. + * @returns The membership value. + */ +double membership_value(struct triangular_fuzzy_set set, double x) +{ + if (x <= set.left_boundary || x >= set.right_boundary) + { + return 0.0; // Out of range + } + else if (set.left_boundary < x && x <= set.peak) + { + return (x - set.left_boundary) / + (set.peak - set.left_boundary); // Increasing slope + } + else if (set.peak < x && x < set.right_boundary) + { + return (set.right_boundary - x) / + (set.right_boundary - set.peak); // Decreasing slope + } + return 0.0; // Should not reach here +} + +/** + * @brief Calculates the complement (negation) of this fuzzy set. + * @param set The triangular fuzzy set. + * @returns A new triangular fuzzy set representing the complement. + */ +struct triangular_fuzzy_set complement(struct triangular_fuzzy_set set) +{ + return create_triangular_fuzzy_set(set.name, 1.0 - set.right_boundary, + 1.0 - set.left_boundary, 1.0 - set.peak); +} + +/** + * @brief Calculates the intersection of this fuzzy set with another fuzzy set. + * @param set The triangular fuzzy set. + * @param other The other triangular fuzzy set to intersect with. + * @returns A new triangular fuzzy set representing the intersection. + */ +struct triangular_fuzzy_set intersection(struct triangular_fuzzy_set set, + struct triangular_fuzzy_set other) +{ + return create_triangular_fuzzy_set( + "Intersection", fmax(set.left_boundary, other.left_boundary), + fmin(set.right_boundary, other.right_boundary), + (set.peak + other.peak) / 2); +} + +/** + * @brief Calculates the union of this fuzzy set with another fuzzy set. + * @param set The triangular fuzzy set. + * @param other The other triangular fuzzy set to union with. + * @returns A new triangular fuzzy set representing the union. + */ +struct triangular_fuzzy_set union_sets(struct triangular_fuzzy_set set, + struct triangular_fuzzy_set other) +{ + return create_triangular_fuzzy_set( + "Union", fmin(set.left_boundary, other.left_boundary), + fmax(set.right_boundary, other.right_boundary), + (set.peak + other.peak) / 2); +} + +/** + * @brief Prints the details of the triangular fuzzy set. + * @param set The triangular fuzzy set. + */ +void print_triangular_fuzzy_set(struct triangular_fuzzy_set set) +{ + printf("Triangular Fuzzy Set '%s': [%f, %f, %f]\n", set.name, + set.left_boundary, set.peak, set.right_boundary); +} + +/** + * @brief Basic plotting of the membership function of the fuzzy set. + * This is a textual representation, as actual graphing is more complex in C. + * + * @param set The triangular fuzzy set to plot. + */ +void plot_triangular_fuzzy_set(struct triangular_fuzzy_set set) +{ + printf("Membership function of %s:\n", set.name); + for (double x = 0; x <= 1.0; x += 0.1) + { + double membership = membership_value(set, x); + printf("x: %0.1f | Membership: %0.2f | ", x, membership); + for (int i = 0; i < (int)(membership * 50); i++) + { // Scale for better visibility + printf("*"); + } + printf("\n"); + } +} + +/** + * @brief Self-test implementations. + * @returns void + */ +static void tests() +{ + struct triangular_fuzzy_set a = + create_triangular_fuzzy_set("A", 0.0, 0.5, 1.0); + struct triangular_fuzzy_set b = + create_triangular_fuzzy_set("B", 0.2, 0.7, 1.0); + + // Test membership values + assert(membership_value(a, 0.1) == 0.2); + assert(membership_value(a, 0.5) == 1.0); + assert(membership_value(a, 0.8) == 0.4); + assert(membership_value(b, 0.6) == 0.8); + + // Test union + struct triangular_fuzzy_set union_ab = union_sets(a, b); + assert(union_ab.left_boundary == 0.0); + assert(union_ab.right_boundary == 1.0); + + // Test intersection + struct triangular_fuzzy_set intersection_ab = intersection(a, b); + assert(intersection_ab.left_boundary == 0.2); + + // Test complement + struct triangular_fuzzy_set complement_a = complement(a); + assert(complement_a.left_boundary == 0.0); + + printf("All tests have successfully passed!\n"); +} + +/** + * @brief Main function. + * @returns 0 on exit. + */ +int main() +{ + tests(); // Run self-test implementations + + struct triangular_fuzzy_set a = + create_triangular_fuzzy_set("A", 0.0, 0.5, 1.0); + struct triangular_fuzzy_set b = + create_triangular_fuzzy_set("B", 0.2, 0.7, 1.0); + + print_triangular_fuzzy_set(a); + print_triangular_fuzzy_set(b); + + plot_triangular_fuzzy_set(a); + plot_triangular_fuzzy_set(b); + + struct triangular_fuzzy_set union_ab = union_sets(a, b); + struct triangular_fuzzy_set intersection_ab = intersection(a, b); + struct triangular_fuzzy_set complement_a = complement(a); + + print_triangular_fuzzy_set(union_ab); + print_triangular_fuzzy_set(intersection_ab); + print_triangular_fuzzy_set(complement_a); + + plot_triangular_fuzzy_set(union_ab); + plot_triangular_fuzzy_set(intersection_ab); + plot_triangular_fuzzy_set(complement_a); + + return 0; +}