Calcular fórmulas con C++

Agregar fórmulas y calcular resultados

Aspose.Cells tiene un motor de cálculo de fórmulas incorporado. No solo puede recalcular fórmulas importadas de plantillas de diseñador, sino que también soporta calcular los resultados de fórmulas añadidas en tiempo de ejecución.

Aspose.Cells soporta la mayoría de las fórmulas o funciones que forman parte de Microsoft Excel (Lee una lista de las funciones soportadas por el motor de cálculo). Estas funciones pueden usarse a través de las APIs o hojas de cálculo de diseñador. Aspose.Cells soporta un conjunto enorme de fórmulas matemáticas, de cadenas, booleanas, de fecha/hora, estadísticas, de bases de datos, de búsqueda y referencia.

Utiliza las propiedades GetFormula o los métodos SetFormula(…) de la clase Cell para agregar una fórmula a una celda. Al aplicar una fórmula, siempre comienza la cadena con un signo igual (=) como cuando creas una fórmula en Microsoft Excel y usa una coma (,) para delimitar los parámetros de la función.

Para calcular los resultados de fórmulas, el usuario puede llamar al método CalculateFormula de la clase Workbook, que procesa todas las fórmulas incrustadas en un archivo de Excel. O, el usuario puede llamar al método CalculateFormula de la clase Worksheet, que procesa todas las fórmulas incrustadas en una hoja. O, el usuario puede también llamar al método Calculate de la clase Cell, que procesa la fórmula de una celda.

#include <iostream>
#include "Aspose.Cells.h"
using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source directory path
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");

    // Output directory path
    U16String outDir(u"..\\Data\\02_OutputDirectory\\");

    // Create a new workbook
    Workbook workbook;

    // Add a new worksheet to the workbook
    int sheetIndex = workbook.GetWorksheets().Add();

    // Get the reference of the newly added worksheet
    Worksheet worksheet = workbook.GetWorksheets().Get(sheetIndex);

    // Add values to cells
    worksheet.GetCells().Get(u"A1").PutValue(1);
    worksheet.GetCells().Get(u"A2").PutValue(2);
    worksheet.GetCells().Get(u"A3").PutValue(3);

    // Add a SUM formula to cell A4
    worksheet.GetCells().Get(u"A4").SetFormula(u"=SUM(A1:A3)");

    // Calculate the results of formulas
    workbook.CalculateFormula();

    // Get the calculated value of cell A4
    U16String value = worksheet.GetCells().Get(u"A4").GetStringValue();

    // Save the Excel file
    workbook.Save(outDir + u"output.xls");

    std::cout << "Excel file saved successfully!" << std::endl;

    Aspose::Cells::Cleanup();
}

Importante saber para las Fórmulas

La propiedad GetFormula y los métodos SetFormula(…) de la clase Cell funcionan de manera diferente a los métodos Calculate de las clases Workbook, Worksheet y Cell. La propiedad GetFormula y los métodos SetFormula(…) simplemente agregan la fórmula a una celda pero no calculan el resultado en tiempo de ejecución. Para obtener el resultado de las fórmulas, por favor llama a los métodos Calculate.

Cálculo directo de fórmulas

Aspose.Cells tiene un motor de cálculo de fórmulas incorporado. Además de calcular las fórmulas importadas de un archivo de diseñador, Aspose.Cells puede calcular directamente los resultados de las fórmulas.

A veces, necesitas calcular los resultados de una fórmula directamente sin agregarla a una hoja de cálculo. Los valores de las celdas usadas en la fórmula ya existen en una hoja de cálculo, y todo lo que necesitas es encontrar el resultado de esos valores en base a alguna fórmula de Excel sin añadir la fórmula en una hoja.

Puedes usar las APIs del motor de cálculo de fórmulas de Aspose.Cells para Worksheet a calculate los resultados de esas fórmulas sin agregarlas a la hoja de cálculo:

#include <iostream>
#include "Aspose.Cells.h"

using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source directory path
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");

    // Output directory path
    U16String outDir(u"..\\Data\\02_OutputDirectory\\");

    // Create a workbook
    Workbook workbook;

    // Access first worksheet
    Worksheet worksheet = workbook.GetWorksheets().Get(0);

    // Put 20 in cell A1
    Cell cellA1 = worksheet.GetCells().Get(u"A1");
    cellA1.PutValue(20);

    // Put 30 in cell A2
    Cell cellA2 = worksheet.GetCells().Get(u"A2");
    cellA2.PutValue(30);

    // Calculate the Sum of A1 and A2
    Aspose::Cells::Object results = worksheet.CalculateFormula(u"=Sum(A1:A2)");

    // Print the output
    std::cout << "Value of A1: " << cellA1.GetStringValue().ToUtf8() << std::endl;
    std::cout << "Value of A2: " << cellA2.GetStringValue().ToUtf8() << std::endl;
    std::cout << "Result of Sum(A1:A2): " << results.ToString().ToUtf8() << std::endl;

    Aspose::Cells::Cleanup();
}

El código anterior produce la siguiente salida:

Value of A1: 20
Value of A2: 30
Result of Sum(A1:A2): 50.0

Cómo calcular fórmulas repetidamente

Cuando hay muchas fórmulas en el libro de trabajo y el usuario necesita calcularlas repetidamente modificando solo una pequeña parte de ellas, puede ser útil para el rendimiento habilitar la cadena de cálculo de fórmulas: FormulaSettings.GetEnableCalculationChain().

#include <iostream>
#include <chrono>
#include "Aspose.Cells.h"

using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source directory path
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");

    // Load the template workbook
    Workbook workbook(srcDir + u"book1.xls");

    // Print the time before formula calculation
    auto start = std::chrono::system_clock::now();
    std::time_t start_time = std::chrono::system_clock::to_time_t(start);
    std::cout << "Start time: " << std::ctime(&start_time);

    // Set the CreateCalcChain as true
    workbook.GetSettings().GetFormulaSettings().SetEnableCalculationChain(true);

    // Calculate the workbook formulas
    workbook.CalculateFormula();

    // Print the time after formula calculation
    auto end = std::chrono::system_clock::now();
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);
    std::cout << "End time: " << std::ctime(&end_time);

    // Change the value of one cell
    workbook.GetWorksheets().Get(0).GetCells().Get(u"A1").PutValue(u"newvalue");

    // Re-calculate those formulas which depend on cell A1
    workbook.CalculateFormula();

    Aspose::Cells::Cleanup();
    return 0;
}

Importante saber

Por defecto, la cadena de cálculo está deshabilitada. Porque crear la cadena también requiere tiempo adicional, la primera vez que se calculan fórmulas (Workbook.CalculateFormula(…)) puede consumir más tiempo de procesamiento de CPU y memoria en comparación con calcular fórmulas sin una cadena. Si el usuario no necesita calcular fórmulas repetidamente, el comportamiento predeterminado (calcular la fórmula directamente sin crear una cadena de cálculo) debería ser la mejor opción.

Temas Avanzados

Administrar datos de archivos de Excel con C++ Administrar comentarios y notas con C++