C/Visual C - Analizador de funciones matematicas

 
Vista:

Analizador de funciones matematicas

Publicado por Nuwanda (5 intervenciones) el 12/10/2001 07:53:58
Amigos mios, ocupo una funcion en C que me permita dar como parametro una cadena conteniendo una funcion f(x) matematica y un numero Re para evaluar la funcion en el, intuyo que se hace con pilas para checar agrupacion y con arboles para analizar la función, solo que no tengo la menor idea de como comenzar, de antemano agradecere la ayuda proporcionada...
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Evaluación de una función matemática desde una cadena

Publicado por Alejandro (913 intervenciones) el 16/10/2024 22:48:29
Nuwanda, para evaluar una función matemática dada como una cadena, puedes usar una combinación de pilas y árboles. Aquí te muestro un enfoque básico para implementar esto en C.

Pasos generales



1. Parsear la cadena: Convertir la cadena de la función en una estructura que puedas evaluar. Esto puede implicar el uso de una pila para manejar la notación infija y convertirla a notación postfija (o notación polaca inversa).

2. Construir un árbol de expresión: Usar la notación postfija para construir un árbol de expresión.

3. Evaluar el árbol: Recorrer el árbol para evaluar la función en el valor dado.

Ejemplo de implementación



A continuación, te muestro un ejemplo simplificado que evalúa expresiones matemáticas básicas. Este código no maneja todos los casos, pero te dará una base sobre la que puedes construir.

Estructuras y funciones básicas



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
 
typedef struct Node {
    char op; // Operador o número
    struct Node* left;
    struct Node* right;
} Node;
 
// Función para crear un nuevo nodo
Node* createNode(char op) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->op = op;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}
 
// Evaluar el árbol de expresión
double evaluate(Node* root, double x) {
    if (!root) return 0;
 
    // Si es un número, retorna su valor
    if (isdigit(root->op)) {
        return atof(&(root->op));
    }
 
    // Evaluar los subárboles
    double leftVal = evaluate(root->left, x);
    double rightVal = evaluate(root->right, x);
 
    // Evaluar el operador
    switch (root->op) {
        case '+': return leftVal + rightVal;
        case '-': return leftVal - rightVal;
        case '*': return leftVal * rightVal;
        case '/': return leftVal / rightVal;
        case 'x': return x; // Variable x
        case 's': return sin(leftVal); // Función seno
        case 'c': return cos(leftVal); // Función coseno
        // Agrega más funciones según sea necesario
    }
    return 0;
}
 
// Aquí puedes agregar funciones para parsear la cadena y construir el árbol
 
int main() {
    // Ejemplo de uso
    Node* root = createNode('+'); // Ejemplo: x + 2
    root->left = createNode('x'); // Variable x
    root->right = createNode('2'); // Número 2
 
    double result = evaluate(root, 3.0); // Evaluar en x = 3
    printf("Resultado: %f\n", result); // Debería imprimir 5.0
 
    // Liberar memoria y otros detalles
 
    return 0;
}

Explicación del código



1. Estructura `Node`: Representa un nodo en el árbol de expresión. Puede ser un operador o un número.

2. Función `createNode`: Crea un nuevo nodo.

3. Función `evaluate`: Evalúa el árbol de expresión. Si el nodo es un número, lo convierte a un valor. Si es un operador, evalúa los subárboles y aplica el operador.

4. Ejemplo en `main`: Crea un árbol simple que representa la expresión `x + 2` y evalúa la expresión en `x = 3`.

Consideraciones



- Parseo de la cadena: Necesitarás implementar una función para parsear la cadena de entrada y construir el árbol de expresión. Esto puede ser complicado y requerirá manejar la precedencia de los operadores y los paréntesis.
- Manejo de errores: Asegúrate de manejar errores, como divisiones por cero o entradas inválidas.
- Funciones adicionales: Puedes agregar más funciones matemáticas y operadores según sea necesario.

Este es un punto de partida básico.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar