Update index.c

index.c

@@ -2,60 +2,371 @@
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
+#include <math.h>
+#include <stdbool.h>
 
-// Result structure to return from zeta function
+// Struct to hold the return value
 typedef struct {
     int token;
-    char model[20];
+    char* model;
     char* return_value;
 } ZetaResult;
 
-// Function to convert string to lowercase
-void toLowerCase(char* str) {
+// Helper function to convert string to lowercase
+char* toLowerCase(const char* str) {
+    if (str == NULL) return NULL;
+    char* lower = (char*)malloc(strlen(str) + 1);
+    if (lower == NULL) return NULL;
     for (int i = 0; str[i]; i++) {
-        str[i] = tolower((unsigned char)str[i]);
+        lower[i] = tolower((unsigned char)str[i]);
     }
+    lower[strlen(str)] = '\0';
+    return lower;
 }
 
-// Function to check if a word is in an array of words
-int isWordInArray(const char* word, const char* words[], int count) {
-    for (int i = 0; i < count; i++) {
-        if (strcmp(word, words[i]) == 0) {
-            return 1;
+// Helper function to check if a string is in an array
+bool isInArray(const char* str, const char** array, int size) {
+    for (int i = 0; i < size; i++) {
+        if (strcmp(str, array[i]) == 0) {
+            return true;
         }
     }
-    return 0;
+    return false;
+}
+
+// Helper function to check if a string contains a substring (case-insensitive)
+bool containsIgnoreCase(const char* haystack, const char* needle) {
+    if (haystack == NULL || needle == NULL) return false;
+    char* hay_lower = toLowerCase(haystack);
+    char* needle_lower = toLowerCase(needle);
+    bool result = (strstr(hay_lower, needle_lower) != NULL);
+    free(hay_lower);
+    free(needle_lower);
+    return result;
 }
 
-// Function to remove non-alphabetic characters (keeps only letters and spaces)
-void removeNonAlphabetic(char* str) {
+// Helper function to remove non-alphabetic characters
+char* removeNonAlpha(const char* str) {
+    if (str == NULL) return NULL;
+    char* result = (char*)malloc(strlen(str) + 1);
+    if (result == NULL) return NULL;
     int j = 0;
     for (int i = 0; str[i]; i++) {
-        if (isalpha((unsigned char)str[i]) || isspace((unsigned char)str[i])) {
-            str[j++] = str[i];
+        if (isalpha((unsigned char)str[i]) || str[i] == ' ') {
+            result[j++] = str[i];
         }
     }
-    str[j] = '\0';
+    result[j] = '\0';
+    return result;
 }
 
-// Function to check if string contains substring (case insensitive)
-int containsSubstring(const char* haystack, const char* needle) {
-    char* haystackLower = strdup(haystack);
-    char* needleLower = strdup(needle);
+// Helper function to split a string by spaces
+char** splitString(const char* str, int* count) {
+    if (str == NULL) {
+        *count = 0;
+        return NULL;
+    }
     
-    toLowerCase(haystackLower);
-    toLowerCase(needleLower);
+    // Count words
+    int word_count = 0;
+    bool in_word = false;
+    for (int i = 0; str[i]; i++) {
+        if (str[i] != ' ' && !in_word) {
+            word_count++;
+            in_word = true;
+        } else if (str[i] == ' ') {
+            in_word = false;
+        }
+    }
     
-    int result = (strstr(haystackLower, needleLower) != NULL);
+    if (word_count == 0) {
+        *count = 0;
+        return NULL;
+    }
     
-    free(haystackLower);
-    free(needleLower);
+    char** words = (char**)malloc(word_count * sizeof(char*));
+    if (words == NULL) {
+        *count = 0;
+        return NULL;
+    }
     
-    return result;
+    // Extract words
+    int word_index = 0;
+    int start = -1;
+    for (int i = 0; i <= strlen(str); i++) {
+        if (str[i] != ' ' && str[i] != '\0' && start == -1) {
+            start = i;
+        } else if ((str[i] == ' ' || str[i] == '\0') && start != -1) {
+            int len = i - start;
+            words[word_index] = (char*)malloc(len + 1);
+            if (words[word_index] == NULL) {
+                for (int j = 0; j < word_index; j++) {
+                    free(words[j]);
+                }
+                free(words);
+                *count = 0;
+                return NULL;
+            }
+            strncpy(words[word_index], str + start, len);
+            words[word_index][len] = '\0';
+            word_index++;
+            start = -1;
+        }
+    }
+    
+    *count = word_count;
+    return words;
+}
+
+// Stack structure for expression evaluation
+typedef struct {
+    double* data;
+    int top;
+    int capacity;
+} DoubleStack;
+
+typedef struct {
+    char* data;
+    int top;
+    int capacity;
+} CharStack;
+
+DoubleStack* createDoubleStack(int capacity) {
+    DoubleStack* stack = (DoubleStack*)malloc(sizeof(DoubleStack));
+    if (stack == NULL) return NULL;
+    stack->data = (double*)malloc(capacity * sizeof(double));
+    if (stack->data == NULL) {
+        free(stack);
+        return NULL;
+    }
+    stack->top = -1;
+    stack->capacity = capacity;
+    return stack;
+}
+
+CharStack* createCharStack(int capacity) {
+    CharStack* stack = (CharStack*)malloc(sizeof(CharStack));
+    if (stack == NULL) return NULL;
+    stack->data = (char*)malloc(capacity * sizeof(char));
+    if (stack->data == NULL) {
+        free(stack);
+        return NULL;
+    }
+    stack->top = -1;
+    stack->capacity = capacity;
+    return stack;
+}
+
+void pushDouble(DoubleStack* stack, double value) {
+    if (stack->top < stack->capacity - 1) {
+        stack->data[++stack->top] = value;
+    }
+}
+
+double popDouble(DoubleStack* stack) {
+    if (stack->top >= 0) {
+        return stack->data[stack->top--];
+    }
+    return 0.0;
+}
+
+double peekDouble(DoubleStack* stack) {
+    if (stack->top >= 0) {
+        return stack->data[stack->top];
+    }
+    return 0.0;
+}
+
+void pushChar(CharStack* stack, char value) {
+    if (stack->top < stack->capacity - 1) {
+        stack->data[++stack->top] = value;
+    }
+}
+
+char popChar(CharStack* stack) {
+    if (stack->top >= 0) {
+        return stack->data[stack->top--];
+    }
+    return '\0';
+}
+
+char peekChar(CharStack* stack) {
+    if (stack->top >= 0) {
+        return stack->data[stack->top];
+    }
+    return '\0';
+}
+
+bool isEmptyChar(CharStack* stack) {
+    return stack->top == -1;
+}
+
+void freeDoubleStack(DoubleStack* stack) {
+    if (stack) {
+        free(stack->data);
+        free(stack);
+    }
+}
+
+void freeCharStack(CharStack* stack) {
+    if (stack) {
+        free(stack->data);
+        free(stack);
+    }
+}
+
+// Get operator precedence
+int getPrecedence(char op) {
+    if (op == '+' || op == '-') return 1;
+    if (op == '*' || op == '/') return 2;
+    if (op == '^') return 3;
+    return 0;
+}
+
+// Apply operator to two operands
+double applyOp(double a, double b, char op) {
+    switch (op) {
+        case '+': return a + b;
+        case '-': return a - b;
+        case '*': return a * b;
+        case '/': return b != 0 ? a / b : 0.0;
+        case '^': return pow(a, b);
+    }
+    return 0.0;
 }
 
+// Evaluate mathematical expression
+bool evalMath(const char* input, double* result) {
+    if (input == NULL) return false;
+    
+    // Extract mathematical expression (digits, operators, parentheses, decimal points)
+    char* expr = (char*)malloc(strlen(input) + 1);
+    if (expr == NULL) return false;
+    int expr_len = 0;
+    bool found_digit = false;
+    
+    for (int i = 0; input[i]; i++) {
+        char c = input[i];
+        if (isdigit(c) || c == '+' || c == '-' || c == '*' || c == '/' || 
+            c == '(' || c == ')' || c == '^' || c == '.') {
+            expr[expr_len++] = c;
+            if (isdigit(c)) found_digit = true;
+        }
+    }
+    expr[expr_len] = '\0';
+    
+    if (!found_digit || expr_len == 0) {
+        free(expr);
+        return false;
+    }
+    
+    // Replace ^ with ** is not needed in C, we handle ^ directly
+    
+    // Validate expression (only allowed characters)
+    for (int i = 0; expr[i]; i++) {
+        char c = expr[i];
+        if (!isdigit(c) && c != '+' && c != '-' && c != '*' && c != '/' && 
+            c != '(' && c != ')' && c != '.' && c != '^' && c != ' ') {
+            free(expr);
+            return false;
+        }
+    }
+    
+    // Evaluate expression using two stacks
+    DoubleStack* values = createDoubleStack(256);
+    CharStack* ops = createCharStack(256);
+    
+    if (values == NULL || ops == NULL) {
+        if (values) freeDoubleStack(values);
+        if (ops) freeCharStack(ops);
+        free(expr);
+        return false;
+    }
+    
+    int i = 0;
+    while (i < expr_len) {
+        // Skip whitespace
+        if (expr[i] == ' ') {
+            i++;
+            continue;
+        }
+        
+        // Current token is a number
+        if (isdigit(expr[i]) || expr[i] == '.') {
+            char num_str[64];
+            int num_len = 0;
+            while (i < expr_len && (isdigit(expr[i]) || expr[i] == '.')) {
+                num_str[num_len++] = expr[i++];
+            }
+            num_str[num_len] = '\0';
+            pushDouble(values, atof(num_str));
+            continue;
+        }
+        
+        // Current token is an opening parenthesis
+        if (expr[i] == '(') {
+            pushChar(ops, expr[i]);
+            i++;
+            continue;
+        }
+        
+        // Current token is a closing parenthesis
+        if (expr[i] == ')') {
+            while (!isEmptyChar(ops) && peekChar(ops) != '(') {
+                double val2 = popDouble(values);
+                double val1 = popDouble(values);
+                char op = popChar(ops);
+                pushDouble(values, applyOp(val1, val2, op));
+            }
+            if (!isEmptyChar(ops)) {
+                popChar(ops); // Remove '('
+            }
+            i++;
+            continue;
+        }
+        
+        // Current token is an operator
+        if (expr[i] == '+' || expr[i] == '-' || expr[i] == '*' || 
+            expr[i] == '/' || expr[i] == '^') {
+            while (!isEmptyChar(ops) && getPrecedence(peekChar(ops)) >= getPrecedence(expr[i])) {
+                double val2 = popDouble(values);
+                double val1 = popDouble(values);
+                char op = popChar(ops);
+                pushDouble(values, applyOp(val1, val2, op));
+            }
+            pushChar(ops, expr[i]);
+            i++;
+            continue;
+        }
+        
+        i++;
+    }
+    
+    // Apply remaining operators
+    while (!isEmptyChar(ops)) {
+        double val2 = popDouble(values);
+        double val1 = popDouble(values);
+        char op = popChar(ops);
+        pushDouble(values, applyOp(val1, val2, op));
+    }
+    
+    // Result is at top of values stack
+    *result = popDouble(values);
+    
+    bool is_finite = isfinite(*result);
+    
+    freeDoubleStack(values);
+    freeCharStack(ops);
+    free(expr);
+    
+    return is_finite;
+}
+
+// Main zeta function
 ZetaResult zeta(const char* q) {
     const char* db[] = {
+        "Who am I? I'm a model trained by NeuralNexusLab and developed by NeuralNexusLab. I can use article to answer you or computation math.",
+        "Who are you? I don't know who are you but I know you are my best friend! I can explain what is AI to you, or computation math.",
         "Artificial intelligence, or AI, is a technology that allows computers to learn, think, and make decisions like humans. Today, AI is used in many parts of our daily lives. It helps us find information online, recommends songs we might like, and even drives cars automatically.AI can understand language, recognize faces, and solve problems faster than people in some cases. However, AI still needs humans to guide it and make sure it is used safely. Many scientists believe that AI will continue to grow and improve, making our future smarter and more efficient. The key is to use it responsibly and for the benefit of everyone.",
         "Developing AI systems requires a mix of math, programming, and creativity. Engineers begin by collecting data, which helps the AI learn patterns and make predictions. They then design a model, usually using machine-learning frameworks like TensorFlow or PyTorch. After training the model, developers test it to make sure it works correctly and safely.AI development is not only about making machines smart—it also involves careful decision-making. Developers must think about privacy, fairness, and how their technology will be used. Building AI responsibly ensures that it can help people while avoiding harmful effects. As the field grows, AI developers continue to create new tools that push technology forward and open the door to future innovations.",
         "Cybersecurity is the practice of protecting computers, networks, and data from unauthorized access or attacks. In today's digital world, people store a lot of personal information online, from bank accounts to social media. Hackers can try to steal this information or cause damage.To stay safe, organizations and individuals use strong passwords, firewalls, and encryption. Regular software updates and careful behavior online are also important. Cybersecurity is not just about technology—it is about awareness and responsibility. By following good practices, we can reduce risks and keep our digital world safe.",
@@ -65,109 +376,171 @@ ZetaResult zeta(const char* q) {
         "Websites are an important part of the modern world. They can be simple pages with text and images, or dynamic websites that change content based on user input. Dynamic websites allow users to interact, shop online, or post comments. Examples include online stores, social media, and news websites.However, websites must be protected from cyber threats. Web security involves using strong passwords, secure connections (HTTPS), and regular updates to prevent hackers from stealing data or causing damage. Developers also use firewalls, encryption, and safe coding practices to keep websites safe.Dynamic websites offer many benefits, but they must be carefully maintained to ensure that users' information is secure. A well-protected website provides a safe and smooth experience for everyone online.",
         "Artificial intelligence has grown rapidly, and many AI models are helping people in different ways. ChatGPT is a language model that can chat, answer questions, and even write text like essays or code. Gemini is another AI developed for understanding language and assisting with research and creative tasks.DeepSeek focuses on analyzing large amounts of data, helping users find patterns and insights quickly. Gemma3 is designed for generating content, such as text, images, or code, making it useful for creative work. Copilot, developed for programmers, helps write code faster by suggesting lines or functions in real time.These AI models show how technology can assist humans in communication, research, and productivity. They are powerful tools, but users should always consider ethics, privacy, and responsible use when using them."
     };
-    int db_length = 8;
-    
     //Put article to db array.
-    char* raw = strdup(q);
-    toLowerCase(raw);
     
-    // Split by space
-    char** words = malloc(1000 * sizeof(char*));
-    int word_count = 0;
-    char* token_str = strtok(raw, " ");
-    while (token_str != NULL) {
-        words[word_count++] = strdup(token_str);
-        token_str = strtok(NULL, " ");
-    }
+    int db_size = 10;
+    
+    ZetaResult result;
+    result.model = (char*)malloc(strlen("zeta-xf") + 1);
+    strcpy(result.model, "zeta-xf");
+    
+    char* raw = toLowerCase(q);
+    int raw_count = 0;
+    char** raw_words = splitString(raw, &raw_count);
     free(raw);
     
-    char* res = malloc(50000);
+    if (raw_words == NULL || raw_count == 0) {
+        result.token = 0;
+        result.return_value = (char*)malloc(1);
+        result.return_value[0] = '\0';
+        return result;
+    }
+    
+    char* res = (char*)malloc(10000);
+    if (res == NULL) {
+        for (int i = 0; i < raw_count; i++) {
+            free(raw_words[i]);
+        }
+        free(raw_words);
+        result.token = 0;
+        result.return_value = (char*)malloc(1);
+        result.return_value[0] = '\0';
+        return result;
+    }
     res[0] = '\0';
+    
     int token = 0;
     
-    // Check if first word is a question word
-    if (word_count > 0) {
-        if (strcmp(words[0], "do") == 0 || strcmp(words[0], "what") == 0 || 
-            strcmp(words[0], "who") == 0 || strcmp(words[0], "which") == 0 || 
-            strcmp(words[0], "where") == 0 || strcmp(words[0], "when") == 0 || 
-            strcmp(words[0], "was") == 0 || strcmp(words[0], "were") == 0 || 
-            strcmp(words[0], "is") == 0 || strcmp(words[0], "are") == 0) {
-            free(words[0]);
-            for (int i = 0; i < word_count - 1; i++) {
-                words[i] = words[i + 1];
+    // Check if first word is in the list and remove it
+    if (raw_count > 0) {
+        const char* check_words[] = {"do", "what", "who", "which", "where", "when", "was", "were", "is", "are"};
+        if (isInArray(raw_words[0], check_words, 10)) {
+            free(raw_words[0]);
+            for (int i = 1; i < raw_count; i++) {
+                raw_words[i - 1] = raw_words[i];
             }
-            word_count--;
+            raw_count--;
             token += 1;
         }
     }
     
     // Filter out "is", "are", "the"
     const char* filter_words[] = {"is", "are", "the"};
-    int new_word_count = 0;
-    for (int i = 0; i < word_count; i++) {
-        if (!isWordInArray(words[i], filter_words, 3)) {
-            words[new_word_count++] = words[i];
+    int new_count = 0;
+    for (int i = 0; i < raw_count; i++) {
+        if (!isInArray(raw_words[i], filter_words, 3)) {
+            raw_words[new_count++] = raw_words[i];
         } else {
-            free(words[i]);
+            free(raw_words[i]);
         }
     }
-    word_count = new_word_count;
+    raw_count = new_count;
+    
+    char* keyword = (char*)malloc(strlen("nothing") + 1);
+    strcpy(keyword, "nothing");
     
-    char* keyword = malloc(256);
-    if (word_count > 0) {
-        strcpy(keyword, words[0]);
+    if (raw_count > 0 && raw_words[0] != NULL) {
+        free(keyword);
+        keyword = (char*)malloc(strlen(raw_words[0]) + 1);
+        strcpy(keyword, raw_words[0]);
+    }
+    
+    // Transform keyword
+    if (strcmp(keyword, "you") == 0 || strcmp(keyword, "your") == 0) {
+        free(keyword);
+        keyword = (char*)malloc(2);
+        strcpy(keyword, "i");
     } else {
-        strcpy(keyword, "nothing");
+        if (strcmp(keyword, "i") == 0 || strcmp(keyword, "me") == 0) {
+            free(keyword);
+            keyword = (char*)malloc(4);
+            strcpy(keyword, "you");
+        }
     }
     
-    removeNonAlphabetic(keyword);
+    // Remove non-alphabetic characters
+    char* cleaned_keyword = removeNonAlpha(keyword);
+    free(keyword);
+    keyword = cleaned_keyword;
     
-    char* catc = malloc(20000);
+    char* catc = (char*)malloc(50000);
+    if (catc == NULL) {
+        for (int i = 0; i < raw_count; i++) {
+            free(raw_words[i]);
+        }
+        free(raw_words);
+        free(keyword);
+        free(res);
+        result.token = 0;
+        result.return_value = (char*)malloc(1);
+        result.return_value[0] = '\0';
+        return result;
+    }
     catc[0] = '\0';
     
-    for (int i = 0; i < db_length; i++) {
-        if (containsSubstring(db[i], keyword)) {
+    for (int i = 0; i < db_size; i++) {
+        if (containsIgnoreCase(db[i], keyword)) {
             strcat(catc, db[i]);
             token += strlen(db[i]);
         }
     }
     
+    double math_result;
+    if (evalMath(q, &math_result)) {
+        char math_str[256];
+        sprintf(math_str, "\"%s\", the computation's answer is %g.", q, math_result);
+        strcat(catc, math_str);
+    }
+    
     sprintf(res, "%s, about %s...\n%s\n%s, a good discuss for us.", q, keyword, catc, keyword);
     token += 5;
     
-    // Clean up
-    for (int i = 0; i < word_count; i++) {
-        free(words[i]);
+    result.token = token;
+    result.return_value = (char*)malloc(strlen(res) + 1);
+    strcpy(result.return_value, res);
+    
+    // Free allocated memory
+    for (int i = 0; i < raw_count; i++) {
+        free(raw_words[i]);
     }
-    free(words);
+    free(raw_words);
     free(keyword);
     free(catc);
-    
-    ZetaResult result;
-    result.token = token;
-    strcpy(result.model, "zeta-x1-lite");
-    result.return_value = res;
+    free(res);
     
     return result;
 }
 
-// Helper function to free the result's return_value
+// Helper function to free ZetaResult
 void freeZetaResult(ZetaResult* result) {
-    if (result->return_value != NULL) {
+    if (result) {
+        free(result->model);
         free(result->return_value);
-        result->return_value = NULL;
     }
 }
 
 // Example usage
 int main() {
-    ZetaResult result = zeta("What is artificial intelligence?");
+    // Test with a question
+    ZetaResult result1 = zeta("Who are you?");
+    printf("Model: %s\n", result1.model);
+    printf("Token: %d\n", result1.token);
+    printf("Result:\n%s\n\n", result1.return_value);
+    freeZetaResult(&result1);
     
-    printf("Token: %d\n", result.token);
-    printf("Model: %s\n", result.model);
-    printf("Return:\n%s\n", result.return_value);
+    // Test with a math expression
+    ZetaResult result2 = zeta("What is 2+2*3?");
+    printf("Model: %s\n", result2.model);
+    printf("Token: %d\n", result2.token);
+    printf("Result:\n%s\n\n", result2.return_value);
+    freeZetaResult(&result2);
     
-    freeZetaResult(&result);
+    // Test with AI keyword
+    ZetaResult result3 = zeta("Tell me about AI");
+    printf("Model: %s\n", result3.model);
+    printf("Token: %d\n", result3.token);
+    printf("Result:\n%s\n", result3.return_value);
+    freeZetaResult(&result3);
     
     return 0;
-}
+}