Use the Proper Compiler Flags

There are several issues here that could be caught using the proper compiler flags.

Using C++ from Visual Studio 2022

1>C:\CodeReview\Givens\Givens\main.cpp(97,38): warning C4101: 'sol4': unreferenced local variable
1>C:\CodeReview\Givens\Givens\main.cpp(97,26): warning C4101: 'sol2': unreferenced local variable
1>C:\CodeReview\Givens\Givens\main.cpp(97,20): warning C4101: 'sol1': unreferenced local variable
1>C:\CodeReview\Givens\Givens\main.cpp(97,32): warning C4101: 'sol3': unreferenced local variable
1>C:\CodeReview\Givens\Givens\main.cpp(186,12): warning C4101: 'max': unreferenced local variable
1>C:\CodeReview\Givens\Givens\main.cpp(185,12): warning C4101: 'min': unreferenced local variable
1>C:\CodeReview\Givens\Givens\main.cpp(250): error C4700: uninitialized local variable 'extreme2' used
1>C:\CodeReview\Givens\Givens\main.cpp(250): error C4700: uninitialized local variable 'extreme1' used
1>C:\CodeReview\Givens\Givens\main.cpp(299): error C4700: uninitialized local variable 't' used
1>C:\CodeReview\Givens\Givens\main.cpp(306): error C4700: uninitialized local variable 'z' used

Using gcc on Ubuntu with the following compiler flags: -Wall -Wextra -pedantic -Werror

main.cpp: In function ‘void buildU(double**, double**, int, int, int, double)’:
main.cpp:93:12: error: unused variable ‘x’ [-Werror=unused-variable]
   93 |     double x = sin(t) / cos(t);
      |            ^
main.cpp:97:20: error: unused variable ‘sol1’ [-Werror=unused-variable]
   97 |     double s1, s2, sol1, sol2, sol3, sol4;
      |                    ^~~~
main.cpp:97:26: error: unused variable ‘sol2’ [-Werror=unused-variable]
   97 |     double s1, s2, sol1, sol2, sol3, sol4;
      |                          ^~~~
main.cpp:97:32: error: unused variable ‘sol3’ [-Werror=unused-variable]
   97 |     double s1, s2, sol1, sol2, sol3, sol4;
      |                                ^~~~
main.cpp:97:38: error: unused variable ‘sol4’ [-Werror=unused-variable]
   97 |     double s1, s2, sol1, sol2, sol3, sol4;
      |                                      ^~~~
main.cpp: In function ‘void traspU(double**, double**, int, int, int)’:
main.cpp:115:65: error: unused parameter ‘j’ [-Werror=unused-parameter]
  115 | void traspU(double** matrixUt, double** matrixU, int order, int j, int i)
      |                                                             ~~~~^
main.cpp:115:72: error: unused parameter ‘i’ [-Werror=unused-parameter]
  115 | void traspU(double** matrixUt, double** matrixU, int order, int j, int i)
      |                                                                    ~~~~^
main.cpp: In function ‘int main()’:
main.cpp:185:12: error: unused variable ‘min’ [-Werror=unused-variable]
  185 |     double min;
      |            ^~~
main.cpp:186:12: error: unused variable ‘max’ [-Werror=unused-variable]
  186 |     double max;
      |            ^~~
main.cpp:250:27: error: ‘extreme1’ may be used uninitialized [-Werror=maybe-uninitialized]
  250 |                 val_random(order, extreme1, extreme2, i);
      |                 ~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.cpp:250:27: error: ‘extreme2’ may be used uninitialized [-Werror=maybe-uninitialized]
main.cpp:299:31: error: ‘t’ may be used uninitialized [-Werror=maybe-uninitialized]
  299 |                         buildU(matrixU, matrixA, order, i, j, t);
      |                         ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.cpp:306:26: error: ‘z’ may be used uninitialized [-Werror=maybe-uninitialized]
  306 |                     prodd(matrixA2, matrixA1, matrixUt, matrixU, matrixA, order, j, i, z);
      |                     ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Please note that in this section of code j is uninitialized in the call to diagonalize() because the call is outside the for loop where j is defined. That line corresponds to the warning/error message for line 311 above.

        while (true)   //overwrite the identity matrix with sines and cosines
        {
            for (int i = 0; i != order - 1; ++i) //cosine1
                for (int j = i + 1; j != order; ++j) //cosine2
                {

                    if (matrixA[i][j] == 0) continue;
                    else
                        buildU(matrixU, matrixA, order, i, j, t);


                    traspU(matrixUt, matrixU, order, i, j); // transpose of U                                                                            
                    cout << "the transpose of U is " << '\n';
                    stamp(matrixUt, order);

                    prodd(matrixA2, matrixA1, matrixUt, matrixU, matrixA, order, j, i, z);

                }
            cout << "the final matrix \n";
            stamp(matrixA2, order);
            if (diagonalize(matrixA2, order, i, j, norm)) break;
        }

Avoid using namespace std;

If you are coding professionally you probably should get out of the habit of using the using namespace std; statement. The code will more clearly define where cout and other identifiers are coming from (std::cin, std::cout). As you start using namespaces in your code it is better to identify where each function comes from because there may be function name collisions from different namespaces. The identifiercout you may override within your own classes, and you may override the operator << in your own classes as well. This stack overflow question discusses this in more detail.

Declare the Variables as Needed

In the original version of C back in the 1970s and 1980s variables had to be declared at the top of the function. That is no longer the case, and a recommended programming practice to declare the variable as needed. In C++ the language doesn't provide a default initialization of the variable so variables should be initialized as part of the declaration. For readability and maintainability each variable should be declared and initialized on its own line.

DRY Code

There is a programming principle called the Don't Repeat Yourself Principle sometimes referred to as DRY code. If you find yourself repeating the same code multiple times it is better to encapsulate it in a function. If it is possible to loop through the code that can reduce repetition as well.

Here is some of the code repetition in main() that can be fixed with a function:

        double** matrixA = new double* [order];
        for (i = 0; i < order; ++i)
        {
            matrixA[i] = new double[order];
        }

        double** matrixU = new double* [order];
        for (i = 0; i < order; ++i)
        {
            matrixU[i] = new double[order];
        }

        double** matrixUt = new double* [order];
        for (i = 0; i < order; ++i)
        {
            matrixUt[i] = new double[order];
        }

        double** matrixA1 = new double* [order];
        for (i = 0; i < order; ++i)
        {
            matrixA1[i] = new double[order];
        }

        double** matrixA2 = new double* [order];
        for (i = 0; i < order; ++i)
        {
            matrixA2[i] = new double[order];
        }

        double** matrixAf = new double* [order];
        for (i = 0; i < order; ++i)
        {
            matrixAf[i] = new double[order];
        }

In the previous code a function could be created that allocates the memory for the matrix.

Complexity

The main() function is 140 lines of code and comments. A general good practice in programming is to keep every function to one screen in the IDE or editor so that anyone that needs to maintain the code can easily understand the function. One screen in an IDE or editor is generally less than 60 lines, so the main() function is 1.5 screens too large.

The function main() is too complex (does too much). As programs grow in size the use of main() should be limited to calling functions that parse the command line, calling functions that set up for processing, calling functions that execute the desired function of the program, and calling functions to clean up after the main portion of the program.

There is also a programming principle called the Single Responsibility Principle that applies here. The Single Responsibility Principle states:

that every module, class, or function should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by that module, class or function.

In addition to the function suggested in the DRY Code section above create a function for the outer while (true) loop, then break that function into smaller functions with only one task per function.

Memory Leaks

There are 6 matrices with memory allocated, none of these matrices are every de-allocated. If this was part of a larger longer running program there would definitely be memory leaks and the process could possibly run out of memory at some point.