Update index.cpp

index.cpp

@@ -1,20 +1,184 @@
-#include <iostream>
 #include <string>
 #include <vector>
 #include <algorithm>
+#include <regex>
 #include <cctype>
 #include <sstream>
-#include <regex>
+#include <cmath>
+#include <stdexcept>
+#include <limits>
 
-// Structure to hold the return value
+// Return type structure for zeta function
 struct ZetaResult {
     int token;
     std::string model;
-    std::string returnValue;
+    std::string return_value;
 };
 
+// Helper function to convert string to lowercase
+std::string toLowerCase(const std::string& str) {
+    std::string result = str;
+    std::transform(result.begin(), result.end(), result.begin(),
+                   [](unsigned char c) { return std::tolower(c); });
+    return result;
+}
+
+// Helper function to split string by delimiter
+std::vector<std::string> split(const std::string& str, char delimiter) {
+    std::vector<std::string> tokens;
+    std::stringstream ss(str);
+    std::string token;
+    while (std::getline(ss, token, delimiter)) {
+        if (!token.empty()) {
+            tokens.push_back(token);
+        }
+    }
+    return tokens;
+}
+
+// Helper function to evaluate mathematical expressions
+double evalMathExpression(const std::string& expr) {
+    std::string cleanExpr = expr;
+    // Remove spaces
+    cleanExpr.erase(std::remove_if(cleanExpr.begin(), cleanExpr.end(), ::isspace), cleanExpr.end());
+    
+    // Simple recursive descent parser for basic arithmetic
+    class ExprParser {
+    private:
+        std::string expr;
+        size_t pos;
+        
+        double parseNumber() {
+            size_t start = pos;
+            if (pos < expr.length() && (expr[pos] == '-' || expr[pos] == '+')) {
+                pos++;
+            }
+            while (pos < expr.length() && (std::isdigit(expr[pos]) || expr[pos] == '.')) {
+                pos++;
+            }
+            if (start == pos) {
+                throw std::runtime_error("Expected number");
+            }
+            return std::stod(expr.substr(start, pos - start));
+        }
+        
+        double parseFactor() {
+            if (pos < expr.length() && expr[pos] == '(') {
+                pos++; // skip '('
+                double result = parseExpression();
+                if (pos >= expr.length() || expr[pos] != ')') {
+                    throw std::runtime_error("Expected ')'");
+                }
+                pos++; // skip ')'
+                return result;
+            }
+            return parseNumber();
+        }
+        
+        double parsePower() {
+            double left = parseFactor();
+            while (pos < expr.length() && expr[pos] == '^') {
+                pos++; // skip '^'
+                double right = parseFactor();
+                left = std::pow(left, right);
+            }
+            return left;
+        }
+        
+        double parseTerm() {
+            double left = parsePower();
+            while (pos < expr.length() && (expr[pos] == '*' || expr[pos] == '/')) {
+                char op = expr[pos];
+                pos++;
+                double right = parsePower();
+                if (op == '*') {
+                    left *= right;
+                } else {
+                    if (right == 0) {
+                        throw std::runtime_error("Division by zero");
+                    }
+                    left /= right;
+                }
+            }
+            return left;
+        }
+        
+        double parseExpression() {
+            double left = parseTerm();
+            while (pos < expr.length() && (expr[pos] == '+' || expr[pos] == '-')) {
+                char op = expr[pos];
+                pos++;
+                double right = parseTerm();
+                if (op == '+') {
+                    left += right;
+                } else {
+                    left -= right;
+                }
+            }
+            return left;
+        }
+        
+    public:
+        ExprParser(const std::string& e) : expr(e), pos(0) {}
+        
+        double parse() {
+            double result = parseExpression();
+            if (pos < expr.length()) {
+                throw std::runtime_error("Unexpected character");
+            }
+            return result;
+        }
+    };
+    
+    try {
+        ExprParser parser(cleanExpr);
+        return parser.parse();
+    } catch (...) {
+        throw;
+    }
+}
+
+// evalMath function equivalent
+std::pair<bool, double> evalMath(const std::string& input) {
+    std::regex pattern("[\\d+\\-*/()^.]+");
+    std::smatch match;
+    
+    if (!std::regex_search(input, match, pattern)) {
+        return {false, 0.0};
+    }
+    
+    std::string expr = match[0].str();
+    
+    // Replace ^ with ** (handled in parser as ^)
+    // expr already contains ^, our parser handles it
+    
+    try {
+        // Check if expression contains only valid characters
+        std::regex validChars("^[\\d+\\-*/().\\s*]+$");
+        std::string checkExpr = expr;
+        // Replace ^ with empty for validation (we'll handle it in parser)
+        std::string exprForCheck = expr;
+        std::replace(exprForCheck.begin(), exprForCheck.end(), '^', '*');
+        
+        if (!std::regex_match(exprForCheck, validChars)) {
+            return {false, 0.0};
+        }
+        
+        double result = evalMathExpression(expr);
+        
+        if (std::isfinite(result)) {
+            return {true, result};
+        }
+        return {false, 0.0};
+    } catch (...) {
+        return {false, 0.0};
+    }
+}
+
 ZetaResult zeta(std::string q) {
     const std::vector<std::string> 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.",
@@ -25,74 +189,77 @@ ZetaResult zeta(std::string q) {
         "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."
     };
     //Put article to db array.
-    std::string raw = q;
-    
-    // Convert to lowercase
-    std::transform(raw.begin(), raw.end(), raw.begin(),
-                   [](unsigned char c) { return std::tolower(c); });
-    
-    // Split by spaces
-    std::vector<std::string> rawWords;
-    std::istringstream iss(raw);
-    std::string word;
-    while (iss >> word) {
-        rawWords.push_back(word);
-    }
     
+    std::string raw = toLowerCase(q);
+    std::vector<std::string> rawWords = split(raw, ' ');
     std::string res = "";
     int token = 0;
     
-    // Check if first word is a question word and remove it
+    // Check if first word is one of the specified words
     if (!rawWords.empty()) {
-        if (rawWords[0] == "do" || rawWords[0] == "what" || rawWords[0] == "who" || 
-            rawWords[0] == "which" || rawWords[0] == "where" || rawWords[0] == "when" || 
-            rawWords[0] == "was" || rawWords[0] == "were" || rawWords[0] == "is" || 
-            rawWords[0] == "are") {
+        std::string firstWord = rawWords[0];
+        if (firstWord == "do" || firstWord == "what" || firstWord == "who" || 
+            firstWord == "which" || firstWord == "where" || firstWord == "when" || 
+            firstWord == "was" || firstWord == "were" || firstWord == "is" || 
+            firstWord == "are") {
             rawWords.erase(rawWords.begin());
             token += 1;
         }
     }
     
-    // Filter out common words
-    std::vector<std::string> filteredWords;
-    for (const auto& w : rawWords) {
-        if (w != "is" && w != "are" && w != "the") {
-            filteredWords.push_back(w);
-        }
-    }
-    rawWords = filteredWords;
+    // Filter out "is", "are", "the"
+    rawWords.erase(
+        std::remove_if(rawWords.begin(), rawWords.end(),
+                      [](const std::string& word) {
+                          return word == "is" || word == "are" || word == "the";
+                      }),
+        rawWords.end()
+    );
     
-    // Get keyword (first word or "nothing")
     std::string keyword = rawWords.empty() ? "nothing" : rawWords[0];
     
-    // Remove non-alphabetic characters
-    keyword = std::regex_replace(keyword, std::regex("[^a-zA-Z\\s]"), "");
+    if (keyword == "you" || keyword == "your") {
+        keyword = "i";
+    } else {
+        if (keyword == "i" || keyword == "me") {
+            keyword = "you";
+        }
+    }
+    
+    // Remove non-alphabetic characters (keep spaces)
+    keyword.erase(
+        std::remove_if(keyword.begin(), keyword.end(),
+                      [](char c) {
+                          return !std::isalpha(c) && !std::isspace(c);
+                      }),
+        keyword.end()
+    );
     
     std::string catc = "";
     
-    // Search through database
     for (size_t i = 0; i < db.size(); i++) {
-        std::string dbLower = db[i];
-        std::transform(dbLower.begin(), dbLower.end(), dbLower.begin(),
-                       [](unsigned char c) { return std::tolower(c); });
-        
-        if (dbLower.find(keyword) != std::string::npos) {
+        std::string dbLower = toLowerCase(db[i]);
+        std::string keywordLower = toLowerCase(keyword);
+        if (dbLower.find(keywordLower) != std::string::npos) {
             catc += db[i];
             token += db[i].length();
         }
     }
     
-    // Build result string
+    std::pair<bool, double> mathResult = evalMath(q);
+    if (mathResult.first != false) {
+        catc += "\"" + q + "\", the computation's answer is " + std::to_string(mathResult.second) + ".";
+    }
+    
     res += q + ", about " + keyword + "...\n";
     res += catc + "\n";
     res += keyword + ", a good discuss for us.";
     token += 5;
     
-    // Return struct
     ZetaResult result;
     result.token = token;
-    result.model = "zeta-x1-lite";
-    result.returnValue = res;
+    result.model = "zeta-xf";
+    result.return_value = res;
     
     return result;
-}
+}