No se como armar este while

[laulaurys]

Hola: tengo el siguiente codigo, en el que ya me han ayudado por aqui!!

Les cuento, hago un select

$sql="SELECT for_id FROM hbr_conceptos WHERE con_id='1'";
$resusql=mysql_query($sql,$dbi);
$filasql=mysql_fetch_array($resusql);
$operacion=$filasql["for_id"];

Donde $operacion es un calculo que no se cuantos terminos puede tener, por ejemplo 400+120+20 o 30*2+8

alguien me ayudo para resolver las ecuaciones y lo hace perfecto, yo le agregue un while y un acumulador para que siga recorriendo y haciendo las distintas operaciones, pero definitivamente no me funciona...por que??

if ( !is_int ( $operacion ) )
{
$operaciones = array ( '+', '-', '*', '/' );

for ( $e = 0; $e < count ( $operaciones ); $e++ )
{
if ( strpos ( $operacion, $operaciones[$e] ) )
{
$posicion = strpos ( $operacion, $operaciones[$e] );
break;
}
else
{
continue;
}
}
}
$cual_operacion = substr ( $operacion, $posicion, 1 );
$calcula = explode ( $cual_operacion, $operacion );

while ($cual_operacion!= ' ')
{

switch ( $cual_operacion )
{
case "*": $resultado= $calcula[0] * $calcula[1];
break;
case "+": $resultado= $calcula[0] + $calcula[1];
break;
case "-": $resultado= $calcula[0] - $calcula[1];
break;
case "/": $resultado= $calcula[0] / $calcula[1];
break;
}
echo $resultado;
$acumula=($acumula+$resultado);
}
echo $acumula;

Se supone que mientras haya algo en $cual_operacion, ya sea + ,- / o *, tiene que entrar en el switch.
No me tira el error correspondiente como ayuda, directamente se queda cargando infinitamente.
Ayudas??
Gracias! un beso!

[Erikfrancisco]

Hola de nuevo, la respuesta la tienes en este código:

Código PHP:

  <?php   
$operacion = "30*2+8/6"; 
$pos = 0; 
 
if ( !is_int ( $operacion ) )  
{ 
   for ( $y = 0; $y < strlen ( $operacion ); $y++ ) 
   { 
      $operaciones = array ( '+', '-', '*', '/' ); 
 
      for ( $x = 0 ; $x < count ( $operaciones ); $x++ ) 
      { 
         if ( substr ( $operacion, $pos, 1 ) == $operaciones[$x] ) 
         { 
            // si encontro una operación guardamos su posicion y la operacion 
            $op[] = $pos.",".substr ( $operacion, $pos, 1 ); 
         } 
      } 
      $pos += 1; 
   } 
 
   $contador = 1; 
   $acumula = 0; 
 
   for ( $e = 0; $e < count ($op); $e++ ) 
   { 
      $divide = explode ( ",", $op[$e] ); 
 
      if ( $e != count ( $op ) - 1 ) 
      { 
         $siguiente = explode ( ",", $op[$e + 1] ); 
         $sig_operacion = $siguiente[0] + 1; 
      } 
      else 
      { 
         $sig_operacion = strlen ( $operacion ) - ( $divide[0] + 1 ); 
      } 
 
      if ( $contador == 1 ) 
      { 
         $calcula[] = substr ( $operacion, 0, $divide[0] ); 
         $calcula[] = substr ( $operacion, $divide[0] + 1, $sig_operacion ); 
 
         switch ( $divide[1] ) 
         { 
            case '+': 
               $resultado = $calcula[0] + $calcula[1]; 
               break; 
            case '-': 
               $resultado = $calcula[0] - $calcula[1]; 
               break; 
            case '*': 
               $resultado = $calcula[0] * $calcula[1]; 
               break; 
            case '/': 
               $resultado = $calcula[0] / $calcula[1]; 
               break; 
            default: 
               echo '<p>No es una operación valida.</p>'; 
               break; 
         } 
 
         $acumula = $resultado; 
         $contador += 1; 
      } 
      else 
      { 
         $calcula = substr ( $operacion, $divide[0] + 1, $sig_operacion ); 
 
         switch ( $divide[1] ) 
         { 
            case '+': 
               $resultado = $acumula + $calcula; 
               break; 
            case '-': 
               $resultado = $acumula - $calcula; 
               break; 
            case '*': 
               $resultado = $acumula * $calcula; 
               break; 
            case '/': 
               $resultado = $acumula / $calcula; 
               break; 
            default: 
               echo '<p>No es una operación valida.</p>'; 
               break; 
         } 
         $acumula = $resultado; 
      } 
   } 
 
   echo $acumula; 
} 
else  
{  
   echo $operacion;  
} 
?>   

Nota: No se podrán hacer operaciones con cararcteres extraños, es decir, la operacion a realizar no puede estar declarada de esta forma (2*8)-6, pero si puede estar de este modo 2*8-6. ¿Me entiendes? La variable operación sólo puede contener números y las operaciones /,*,+,-.

Espero te sirva de algo o por lo menos te de una idea. Suerte

[laulaurys]

Hola Erik! me habia puesto a probar y llegue a algo parecido, ahora el problema que se me presenta es el siguiente:
Yo hice esto:

if ( !is_int ( $operacion ) )
{
$indice=1;
$operaciones = array ( '+', '-', '*', '/' );

for ( $e = 0; $e < count ( $operaciones ); $e++ )
{
if ( strpos ( $operacion, $operaciones[$e] ) )
{
$posicion = strpos ( $operacion, $operaciones[$e] );
break;
}
else
{
$indice=0;
continue;
}
}

$i=1;


$cual_operacion = substr ( $operacion, $posicion, $i );
$calcula = explode ( $cual_operacion, $operacion );
$i=($i+2);
$x=1;
$acumula=$calcula[0];
while ($calcula[$x]!='')
{

switch ( $cual_operacion )
{
case "*": $acumula= $acumula * $calcula[$x];
$indice=1;
break;
case "+": $acumula= $acumula + $calcula[$x];
break;
case "-": $acumula= $acumula - $calcula[$x];
break;
case "/": $acumula= $acumula / $calcula[$x];
break;
default:
echo " $formula";
break;
} //fin del switch
$x++;

} //fin del while [$x]

echo " $acumula";


if ($indice==0)
{
echo " $formula";
};
?></strong></td>
<?
}
else
{
echo " $formula";
$acumula=$operacion;
$acumula2=$operacion;


}

}

$acumula2=($acumula);
$acumula_=($acumula_ + $acumula );


$neto_x_legajo=($neto_x_legajo + $acumula);

Donde lo que intento es acumular el resultado final de cuando sale del while, osea.
si en un while resolvio 400+50+20, y en otro 20*3 que me lo sume.
HAGO LA igualacion $acumula=$operacion; para que cuando cuando no se cumple el if del !is_int , tambien me pueda sumar esos valores a $acumula para que me sume el resultado de 400+50+20, 20*3 y 17 suponiendo que era una entrada la cual no fue analizada en el switch.

La verdad estoy re mareadaaaaaaaa ya no me doy cuenta de nada!!
Ojala puedas ayudarme!! y graciassssss!!!

[Erikfrancisco]

Hay que utilizar la imaginación. El código que te dí definelo como una función y define las operaciones en un array, luego has un bucle donde a la función le pases cada operacion y el resultado de esta se la pasas a otra variable para que te haga el acumulado total. Ya te lo hice, mira:

Código PHP:

  <?php 
function realiza_operacion ( $cu_op ) 
{ 
   $operacion = $cu_op; 
   $pos = 0; 
 
   if ( !is_int ( $operacion ) ) 
   { 
      for ( $y = 0; $y < strlen ( $operacion ); $y++ ) 
      { 
         $operaciones = array ( '+', '-', '*', '/' ); 
 
         for ( $x = 0 ; $x < count ( $operaciones ); $x++ ) 
         { 
            if ( substr ( $operacion, $pos, 1 ) == $operaciones[$x] ) 
            { 
               // si encontro una operación guardamos su posicion y la operacion 
               $op[] = $pos.",".substr ( $operacion, $pos, 1 ); 
            } 
         } 
         $pos += 1; 
      } 
 
      $contador = 1; 
      $acumula = 0; 
 
      for ( $e = 0; $e < count ($op); $e++ ) 
      { 
         $divide = explode ( ",", $op[$e] ); 
 
         if ( $e != count ( $op ) - 1 ) 
         { 
            $siguiente = explode ( ",", $op[$e + 1] ); 
            $sig_operacion = $siguiente[0] + 1; 
         } 
         else 
         { 
            $sig_operacion = strlen ( $operacion ) - ( $divide[0] + 1 ); 
         } 
 
         if ( $contador == 1 ) 
         { 
            $calcula[] = substr ( $operacion, 0, $divide[0] ); 
            $calcula[] = substr ( $operacion, $divide[0] + 1, $sig_operacion ); 
 
            switch ( $divide[1] ) 
            { 
               case '+': 
                  $resultado = $calcula[0] + $calcula[1]; 
                  break; 
               case '-': 
                  $resultado = $calcula[0] - $calcula[1]; 
                  break; 
               case '*': 
                  $resultado = $calcula[0] * $calcula[1]; 
                  break; 
               case '/': 
                  $resultado = $calcula[0] / $calcula[1]; 
                  break; 
               default: 
                  echo '<p>No es una operación valida.</p>'; 
                  break; 
            } 
 
            $acumula = $resultado; 
            $contador += 1; 
         } 
         else 
         { 
            $calcula = substr ( $operacion, $divide[0] + 1, $sig_operacion ); 
 
            switch ( $divide[1] ) 
            { 
               case '+': 
                  $resultado = $acumula + $calcula; 
                  break; 
               case '-': 
                  $resultado = $acumula - $calcula; 
                  break; 
               case '*': 
                  $resultado = $acumula * $calcula; 
                  break; 
               case '/': 
                  $resultado = $acumula / $calcula; 
                  break; 
               default: 
                  echo '<p>No es una operación valida.</p>'; 
                  break; 
            } 
            $acumula = $resultado; 
         } 
      } 
 
      $operacion = $acumula; 
      return $operacion;  
   }  
   else   
   { 
      return $operacion; 
   } 
} 
 
$operaciones = array ( "10*5/4", "5*10-2", 10 ); // aquí mete todas las operaciones a realizar 
 
$acum_total = 0; 
 
for ( $t = 0; $t < count ( $operaciones ); $t++ ) 
{ 
   $op_resuelta = realiza_operacion ( $operaciones[$t] ); 
   echo "El resultado de la operación ".$operaciones[$t]." es: ".$op_resuelta."<br/>"; 
   $acum_total += $op_resuelta; 
} 
echo "<p>La suma total de todas las operaciones es: ".$acum_total; 
?>   

Como vez, despues de lo que ya te había hecho es muy fácil resolver tu problema, sólo tendrás que agregar todas las operaciones que quieres realizar a la variable $operaciones y ¡vuala! se resolvio tu problema. Tendrás que tomar en cuenta lo que ya se te planteo en la nota que te puse anteriormente.

Suerte

[laulaurys]

Hola Erik!! realmente muchas gracias, es verdad yo deberia tener mas imaginacion pero lamentablemente no soy buena para esto, estoy trabajando en sistemas porque es lo que hay pero no es lo mio!!

Estoy usando lo que me pasaste y me surgio el siguiente problema, espero que puedas ayudarme , realmente muchas gracias!!

Te cuento:

$resucon=mysql_query($sqlcon,$dbi);
$acumula_resultado=0;
while($filacon=mysql_fetch_array($resucon))
{ $formula=$filacon["for_id"];
$con_nombre=$filacon["con_nombre"];

De donde saco las operaciones y se las paso a $formula y en con_nombre tengo el nombre que recibe la formula.
En este caso, el while me da 6 registros, es decir que tengo 6 formulas para analizar.

Seguido de esto pongo lo siguiente:

$operacion=$formula;
y pongo la funcion que me pasaste lo unico que le cambie es al final

$operaciones = array ( $formula ); // aquí mete todas las operaciones a realizar (ahi vos me ponias las operaciones directamente, por lo que estuve comentando del codigo el problema esta ahi, pero no se cmo solucionarlo!

Lo que me hace es resolverme solo la primera formula
Perdoname que te joda tanto pero a mi esto me supera!!

Saludos y graciassssssss

[Erikfrancisco]

Lo que debes hacer despues de tu consulta es crear un bucle que a su vez cree un array para que meta las operaciones en este luego cierras el bucle y todo queda como estaba, eso es todo lo que había que hacer:

Código PHP:

  <?php 
// esta función se encargará de resolver las operaciones que se le pasen de estilo 24*3+2/8-5 (cadena) 
 
// donde $cu_op es cual operacion deseamos realizar 
function realiza_operacion ( $cu_op ) 
{   
   $operacion = $cu_op;  // definimos una variable $operacion que contendrá como valor la operación que le pasamos a la función 
   $pos = 0; // esta variable es la posición desde donde vamos a comparar, es decir desde el principio 
 
   if ( !is_int ( $operacion ) ) // si no es un número entero es decir, un número sólo como 50 hacemos las operaciones 
   {  // recorremos cada caracter de la variable $operacion para detectar que operaciones realizar (algo así como recorrer letra por letra) 
      for ( $y = 0; $y < strlen ( $operacion ); $y++ ) 
      {   
         $operaciones = array ( '+', '-', '*', '/' ); // definimos un array con las operaciones validas suma, resta, ... 
 
         for ( $x = 0 ; $x < count ( $operaciones ); $x++ ) 
         {   
            if ( substr ( $operacion, $pos, 1 ) == $operaciones[$x] ) // comparamos si el caracter es igual a una operacion de ser así lo guardamos en un array 
            {   
               // si encontro una operación guardamos su posicion y la operacion separados por coma 
               $op[] = $pos.",".substr ( $operacion, $pos, 1 );   
            }   
         }   
         $pos += 1; // aumentamos una unidad a la posición para comparar el siguiente carácter 
      }   
 
      $contador = 1; // nos indicará cuantas operaciones ya hemos realizado 
 
      // Esta variable nos servirá para ir sumando los resultados después de realizar una operacion ya que no las hará todas de un sólo jalon 
      // se irán resolviendo por pares ejemplo 5+2-1/2 primero resolverá 5+2 y luego la variable acumula contendrá ahora 7 a esto le restaremos 
      // 1 y acumula contendrá ahora 6 luego se dividirá entre 2 y finalmente acumula contendrá 3 
      $acumula = 0; 
 
      for ( $e = 0; $e < count ($op); $e++ ) // realizamos un bucle que se repetirá tantas veces como operaciones tengamos 
      {  // con esto dividimos el contenido del array $op[$e] ya que si recordamos guardamos su posicion y la operacion separados por coma 
         $divide = explode ( ",", $op[$e] ); 
         // ahora el array $divide[0] será la posición del símbolo de la operación a realizar 
         // y $divide[1] será el símbolo de la operación ( "+" por decir un ejemplo ) 
 
         if ( $e != count ( $op ) - 1 ) // si aún no es la última operación 
         {   
            $siguiente = explode ( ",", $op[$e + 1] );   
            // obtenemos la posición de la siguiente operación para así realizar la anterior, me explico, si tenemos esta operación 5+2-3 
            // vamos a realizar primero 5+2 pero para poder realizarlo debemos saber que posición ocupa la siguiente operacion en este caso 
            // el símbolo de la sig. operación se encuentra en la posición 4 (-) 
            $sig_operacion = $siguiente[0] + 1; 
         }   
         else // si es la última operación a realizar 
         {   
            $sig_operacion = strlen ( $operacion ) - ( $divide[0] + 1 ); // obtenemos la cadena restante 
         }   
 
         if ( $contador == 1 ) // es la primera operación a realizar 
         {   
            $calcula[] = substr ( $operacion, 0, $divide[0] ); // obtenemos el primer número para la operacion en el ejemplo de 5+2 obtendríamos 5 
            $calcula[] = substr ( $operacion, $divide[0] + 1, $sig_operacion ); // obtenemos el segundo num. para la operación en el ej. sería 2 
 
            switch ( $divide[1] ) // hacemos la operación correspondiente recuerda que $divide[1] es el simbolo "+" en el caso de nuestro ejemplo 
            {   
               case '+': // si $divide[1] contiene el símbolo + realizaremos una suma 
                  $resultado = $calcula[0] + $calcula[1];   
                  break;   
               case '-': // si $divide[1] contiene el símbolo - realizaremos una resta 
                  $resultado = $calcula[0] - $calcula[1];   
                  break;   
               case '*': // si $divide[1] contiene el símbolo * realizaremos una multiplicación 
                  $resultado = $calcula[0] * $calcula[1];   
                  break;   
               case '/': // si $divide[1] contiene el símbolo / realizaremos una división 
                  $resultado = $calcula[0] / $calcula[1];   
                  break;   
               default: // si $divide[1] no contiene ninguno de los símbolos mandamos un mensaje 
                  echo '<p>No es una operación valida.</p>';   
                  break;   
            }   
 
            $acumula = $resultado; // le pasamos el resultado a acumula 
            $contador += 1; // sumamos una unidad a la variable $contador para indicar que ya se hizo la primera operación 
         }   
         else // si es más de una operación a realizar 
         {   
            $calcula = substr ( $operacion, $divide[0] + 1, $sig_operacion ); // obtenemos el sig. número con el que realizar la operación 
 
            switch ( $divide[1] ) // hacemos la siguiente operación (- en caso de nuestro ejemplo) con el resultado acumulado y el sig. número ( 3 en el ejemplo ) 
            { 
               case '+':   
                  $resultado = $acumula + $calcula;   
                  break;   
               case '-':   
                  $resultado = $acumula - $calcula;   
                  break;   
               case '*':   
                  $resultado = $acumula * $calcula;   
                  break;   
               case '/':   
                  $resultado = $acumula / $calcula;   
                  break;   
               default:   
                  echo '<p>No es una operación valida.</p>';   
                  break;   
            }   
            $acumula = $resultado;   
         }   
      }   
 
      $operacion = $acumula; // le asignamos a la variable $operación el resultado final 
      return $operacion;    
   }    
   else // si es un número entero sólo lo pasamos así (No realizamos ninguna operación) 
   {   
      return $operacion;   
   }   
}  
 
// supongo que $sqlcon es la consulta y $dbi es la conexion que serían unas líneas como esta  
// $dbi = mysql_pconnect ( 'servername', 'username', 'password' );  
// mysql_select_bd ( 'basededatos' );  
// $sqlcon = "SELECT campos FROM tabla WHERE condiciones";  
 
$resucon = mysql_query ( $sqlcon, $dbi );  
 
while ( $filacon = mysql_fetch_array ( $resucon ) )  
{  
   // $formula son las operaciones a realizar, mejor definela como un array para que así se te  
   // agreguen solitas sin necesidad de ponerlas a mano así  
   $operaciones[] = $filacon["for_id"];  
   // con $operaciones[] definimos $operaciones como un array y en cada iteración del bucle while  
   // se irán agregando las operaciones dentro de este array  
}  
 
$acum_total = 0; // esta variable servirá para hacer la suma de todos los resultados de las operaciones que estaban en el array $operaciones[] 
 
for ( $t = 0; $t < count ( $operaciones ); $t++ ) 
{  // le pasamos la operación a realizar a la función realiza_operacion() y el resultado se almacenará en la variable $op_resuelta 
   $op_resuelta = realiza_operacion ( $operaciones[$t] ); 
   echo "El resultado de la operación ".$operaciones[$t]." es: ".$op_resuelta."<br/>"; // mostramos en pantalla la operación que se hizo y su resultado 
   $acum_total += $op_resuelta; // le sumamos el resultado de la operación a la variable $acum_total 
}   
echo "<p>La suma total de todas las operaciones es: ".$acum_total;   
?>   

Nota: dejo el código con comentarios para que entiendas tú y todo el que lo lea que es lo que va haciendo el código. Espero que con esto ya se entienda mejor que es lo que fui haciendo.
Suerte

[laulaurys]

Hola Erik!! muchas gracias por tu ayuda, te cuento que lo etoy probando y anda bien el hecho de que recorra y vaya asignando la distintas cadenas.

El problema que sigue teniendo es que por ejemplo esta operacion:
10+5*2 me da como resultado 30, cuando deberia dar 20. Que me sugeris?

Te dejo aparte un mensaje privado, gracias!!

[Erikfrancisco]

Iniciado por laulaurys

El problema que sigue teniendo es que por ejemplo esta operacion:
10+5*2 me da como resultado 30, cuando deberia dar 20. Que me sugeris?

Sólo una pregunta ¿De donde quieres que te de como resultado 20?. Haz la operación a mano, mira; estas de acuerdo con que 10+5 son 15 ahora, 15*2 son 30 ¿no?, digo, por leyes matemáticas el resultado es correcto. checalo se te a de haber borrado el casette por un momento y no te percataste de que operación es la que estabas realizando. Suerte

[laulaurys]

Erik amigo!! puede ser que este loca ya...
pero no deberia hacerse...10 + 5*2 ..es decir... 10 +10 ? o deberia obligar al usuario a que usen parentesis? Graciasssss, te sigo en el privado!

[Erikfrancisco]

Iniciado por laulaurys

Erik amigo!! puede ser que este loca ya...
pero no deberia hacerse...10 + 5*2 ..es decir... 10 +10 ? o deberia obligar al usuario a que usen parentesis?

Exacto, las matemáticas te dicen que si le quieres dar prioridad a una operación hay que encerrarla entre paréntesis o corchetes. En tu caso sería 10+(5*2). Pero esto no lo hace el código por dos razones que ya te había mencionado (por favor lee los comentarios del código son los que están pintados de amarillo):

1.-

Iniciado por Erikfrancisco

// Esta variable nos servirá para ir sumando los resultados después de realizar una operacion ya que no las hará todas de un sólo jalon
// se irán resolviendo por pares ejemplo 5+2-1/2 primero resolverá 5+2 y luego la variable acumula contendrá ahora 7 a esto le restaremos
// 1 y acumula contendrá ahora 6 luego se dividirá entre 2 y finalmente acumula contendrá 3

2.-

Iniciado por Erikfrancisco

Nota: No se podrán hacer operaciones con cararcteres extraños, es decir, la operacion a realizar no puede estar declarada de esta forma (2*8)-6, pero si puede estar de este modo 2*8-6. ¿Me entiendes? La variable operación sólo puede contener números y las operaciones /,*,+,-.

Espero que me entiendas. Suerte

[laulaurys]

Si amigo te entiendo perfecto!! Gracias por la aclaracion!!

[laulaurys]

Hola!!
estoy tratando de modificar lo siguiente en algunos casos:

Código PHP:

  function realiza_operacion ( $cu_op )  
{    
                    global $acum_total; 
 
   $operacion = $cu_op;  // definimos una variable $operacion que contendrá como valor la operación que le pasamos a la función  
   $pos = 0; // esta variable es la posición desde donde vamos a comparar, es decir desde el principio  
 
   if ( !is_int ( $operacion ) ) // si no es un número entero es decir, un número sólo como 50 hacemos las operaciones  
   {  // recorremos cada caracter de la variable $operacion para detectar que operaciones realizar (algo así como recorrer letra por letra)  
      for ( $y = 0; $y < strlen ( $operacion ); $y++ )  
      {    
         $operaciones = array ( '+', '-', '*', '/' ); // definimos un array con las operaciones validas suma, resta, ...  
 
         for ( $x = 0 ; $x < count ( $operaciones ); $x++ )  
         {    
            if ( substr ( $operacion, $pos, 1 ) == $operaciones[$x] ) // comparamos si el caracter es igual a una operacion de ser así lo guardamos en un array  
            {    
               // si encontro una operación guardamos su posicion y la operacion separados por coma  
               $op[] = $pos.",".substr ( $operacion, $pos, 1 );    
            }    
         }    
         $pos += 1; // aumentamos una unidad a la posición para comparar el siguiente carácter  
      }    
 
      $contador = 1; // nos indicará cuantas operaciones ya hemos realizado  
 
      // Esta variable nos servirá para ir sumando los resultados después de realizar una operacion ya que no las hará todas de un sólo jalon  
      // se irán resolviendo por pares ejemplo 5+2-1/2 primero resolverá 5+2 y luego la variable acumula contendrá ahora 7 a esto le restaremos  
      // 1 y acumula contendrá ahora 6 luego se dividirá entre 2 y finalmente acumula contendrá 3  
      $acumula = 0;  
 
      for ( $e = 0; $e < count ($op); $e++ ) // realizamos un bucle que se repetirá tantas veces como operaciones tengamos  
      {  // con esto dividimos el contenido del array $op[$e] ya que si recordamos guardamos su posicion y la operacion separados por coma  
         $divide = explode ( ",", $op[$e] );  
         // ahora el array $divide[0] será la posición del símbolo de la operación a realizar  
         // y $divide[1] será el símbolo de la operación ( "+" por decir un ejemplo )  
 
         if ( $e != count ( $op ) - 1 ) // si aún no es la última operación  
         {    
            $siguiente = explode ( ",", $op[$e + 1] );    
            // obtenemos la posición de la siguiente operación para así realizar la anterior, me explico, si tenemos esta operación 5+2-3  
            // vamos a realizar primero 5+2 pero para poder realizarlo debemos saber que posición ocupa la siguiente operacion en este caso  
            // el símbolo de la sig. operación se encuentra en la posición 4 (-)  
            $sig_operacion = $siguiente[0] + 1;  
         }    
         else // si es la última operación a realizar  
         {    
            $sig_operacion = strlen ( $operacion ) - ( $divide[0] + 1 ); // obtenemos la cadena restante  
         }    
 
         if ( $contador == 1 ) // es la primera operación a realizar  
         {    
            $calcula[] = substr ( $operacion, 0, $divide[0] ); // obtenemos el primer número para la operacion en el ejemplo de 5+2 obtendríamos 5  
            $calcula[] = substr ( $operacion, $divide[0] + 1, $sig_operacion ); // obtenemos el segundo num. para la operación en el ej. sería 2  
 
            switch ( $divide[1] ) // hacemos la operación correspondiente recuerda que $divide[1] es el simbolo "+" en el caso de nuestro ejemplo  
            {    
               case '+': // si $divide[1] contiene el símbolo + realizaremos una suma  
                  $resultado = $calcula[0] + $calcula[1];    
                  break;    
               case '-': // si $divide[1] contiene el símbolo - realizaremos una resta  
                  $resultado = $calcula[0] - $calcula[1];    
                  break;    
               case '*': // si $divide[1] contiene el símbolo * realizaremos una multiplicación  
                  $resultado = $calcula[0] * $calcula[1];    
                  break;    
               case '/': // si $divide[1] contiene el símbolo / realizaremos una división  
                  $resultado = $calcula[0] / $calcula[1];    
                  break;    
               default: // si $divide[1] no contiene ninguno de los símbolos mandamos un mensaje  
                  echo '<p>No es una operación valida.</p>';    
                  break;    
            }    
 
            $acumula = $resultado; // le pasamos el resultado a acumula  
            $contador += 1; // sumamos una unidad a la variable $contador para indicar que ya se hizo la primera operación  
         }    
         else // si es más de una operación a realizar  
         {    
            $calcula = substr ( $operacion, $divide[0] + 1, $sig_operacion ); // obtenemos el sig. número con el que realizar la operación  
 
            switch ( $divide[1] ) // hacemos la siguiente operación (- en caso de nuestro ejemplo) con el resultado acumulado y el sig. número ( 3 en el ejemplo )  
            {  
               case '+':    
                  $resultado = $acumula + $calcula;    
                  break;    
               case '-':    
                  $resultado = $acumula - $calcula;    
                  break;    
               case '*':    
                  $resultado = $acumula * $calcula;    
                  break;    
               case '/':    
                  $resultado = $acumula / $calcula;    
                  break;    
               default:    
                  echo '<p>No es una operación valida.</p>';    
                  break;    
            }    
            $acumula = $resultado;    
         }    
      }    
 
      $operacion = $acumula; // le asignamos a la variable $operación el resultado final  
      return $operacion;     
   }     
   else // si es un número entero sólo lo pasamos así (No realizamos ninguna operación)  
   {    
      return $operacion;    
   }    
}   
 
$resucon = mysql_query ( $sqlcon, $dbi );   
 
while ( $filacon = mysql_fetch_array ( $resucon ) )   
 
// $formula son las operaciones a realizar, mejor definela como un array para que así se te   
   // agreguen solitas sin necesidad de ponerlas a mano así   
   $operaciones[] = $filacon["for_id"];  
   $formu = $filacon["for_id"];  
   $con_codigo=$filacon["con_codigo"]; 
   $con_nombre=$filacon["con_nombre"]; 
   $con_descripcion=$filacon["con_descripcion"]; 
   $con_id=$filacon["con_id"]; 
   $tco_id=$filacon["tco_id"]; 
 
   // con $operaciones[] definimos $operaciones como un array y en cada iteración del bucle while   
   // se irán agregando las operaciones dentro de este array   
 
if ($con_id=='10')  
    { 
// si con_id=10 es que hay antiguedad, la voy a calcular buscando la fecha de ingreso 
$sqlantiguedad="SELECT emp_id,DATE_FORMAT(hbr_empleado.emp_fecha_ingreso, '%Y-%m-%d') AS emp_fecha_ingreso FROM hbr_empleado WHERE emp_legajo='$legajo'"; 
                        $resuantiguedad=mysql_query($sqlantiguedad,$dbi); 
                        $filaantiguedad=mysql_fetch_array($resuantiguedad); 
                        $ingreso=$filaantiguedad["emp_fecha_ingreso"]; 
                        $empleado_id=$filaantiguedad["emp_id"]; 
                                     $fecha_actual=date("Y-m-j"); 
     list($Yi, $mi, $di)=explode('-', $ingreso); 
     list($Yf, $mf, $df)=explode('-', $fecha_actual); 
     $cant_dias=((mktime ( 0, 0, 0, $mf, $df, $Yf)- mktime ( 0, 0, 0, $mi, $di, $Yi))/(60*60*24*365)); 
                         
      $operaciones[$t]=($formu * floor($cant_dias)); 
               $antiguedad=($formu * floor($cant_dias)); 
                     
                         
echo "antiguedad $antiguedad"; 
                          
             } // fin del if con_id=10 
 
for ( $t = 0; $t < count ( $operaciones ); $t++ )  
{  // le pasamos la operación a realizar a la función realiza_operacion() y el resultado se almacenará en la variable $op_resuelta  
 
 
   $op_resuelta = realiza_operacion ( $operaciones[$t] ); 
 
  // echo "operacion t realiza_operacion ($operaciones[$t])"; 
//   echo " opera $op_resuelta ";  
if ($con_id=='10') 
            {  
                $op_resuelta=$antiguedad; 
               $acum_total += $op_resuelta; 
                echo " op resue $acum_total"; 
            } 
 
//   echo "El resultado de la operación ".$operaciones[$t]." es: ".$op_resuelta."<br/>"; // mostramos en pantalla la operación que se hizo y su resultado  
 
   $acum_total += $op_resuelta; // le sumamos el resultado de la operación a la variable $acum_total  
   echo "paso 2 $acum_total"; 
} 
   echo "El resultado de la operación ".$operaciones[$t]." es: ".$op_resuelta."<br/>"; // mostramos en pantalla la operación que se hizo y su resultado  
}  
 
}   
echo "<p>La suma total de todas las operaciones es: ".$acum_total;    
?>  
  

El tema es que solamente logro que me muestre el valor de la operacion incluyendo el if ($con_id==10) antes del $acum_total += $op_resuelta;, pero de todas formas no me suma el acumulador.
es como sino se cumpliera el for para ese caso .
Tengo que asignarselo a otra variable?
Gracias!