ALTER PROCEDURE dbo.p_Reverse_Polish_Notation
(@Expression AS Varchar(MAX))
AS BEGIN
    SET NOCOUNT ON;

    IF @Expression Is Null OR @Expression = ''
        GOTO Get_Result;

    SET @Expression = REPLACE(REPLACE(REPLACE(REPLACE(@Expression,
        ' ', ''), ',', '.'), CHAR(13), ''), CHAR(10), '');

    IF @Expression LIKE '%[^0-9().*^/+-]%'
    BEGIN
        SELECT Null AS Result, 'Обнаружен неверный символ.' AS ErrorMessage;
        RETURN;
    END;

    DECLARE @Stack AS Varchar(50) = '', @Operand AS Varchar(50) = '',
            @i AS Int = 1, @Result Float;
    DECLARE @Array AS TABLE (ID Int Identity(1, 1) Primary Key,
        Operand Float, Operator Varchar(50), Del Bit);

    /*  Приоритеты:
        высокий: ^
        средний: * /
        низкий: + −
        самый низкий: ()
    */
    WHILE @i <= LEN(@Expression)
    BEGIN
        -- Число
        IF SUBSTRING(@Expression, @i , 1) NOT LIKE '[^0-9.]' OR
           (SUBSTRING(@Expression, @i , 1) LIKE '[+-]' AND LEN(@Operand) = 0)
        BEGIN
            SET @Operand = @Operand + SUBSTRING(@Expression, @i , 1);
            IF @i = LEN(@Expression)
            BEGIN
                INSERT INTO @Array (Operand)
                SELECT CAST(@Operand AS Float);
            END
        END
        -- Операторы
        ELSE
        BEGIN
            IF LEN(@Operand) > 0 AND @Operand NOT IN ('+', '-')
            BEGIN
                INSERT INTO @Array (Operand)
                SELECT CAST(@Operand AS Float);
                SET @Operand = '';
            END;
            IF SUBSTRING(@Expression, @i , 1) = '^'
            BEGIN
                SELECT @Stack = @Stack + '^';
            END
            ELSE IF SUBSTRING(@Expression, @i , 1) LIKE '[*/]'
            BEGIN
                WHILE RIGHT(@Stack, 1) LIKE '[*/^]'
                BEGIN
                    INSERT INTO @Array (Operator)
                    SELECT RIGHT(@Stack, 1);
                    SET @Stack = LEFT(@Stack, LEN(@Stack)-1);
                END;
                SELECT @Stack = @Stack + SUBSTRING(@Expression, @i , 1);
            END
            ELSE IF SUBSTRING(@Expression, @i , 1) LIKE '[+-]'
            BEGIN
                WHILE RIGHT(@Stack, 1) LIKE '[*/^+-]'
                BEGIN
                    INSERT INTO @Array (Operator)
                    SELECT RIGHT(@Stack, 1);
                    SET @Stack = LEFT(@Stack, LEN(@Stack)-1);
                END;
                SELECT @Stack = @Stack + SUBSTRING(@Expression, @i , 1);
            END
            ELSE IF SUBSTRING(@Expression, @i , 1) = '('
            BEGIN
                IF @Operand = '-'
                BEGIN
                    INSERT INTO @Array (Operand)
                    SELECT -1;
                    SELECT @Operand = '', @Stack = @Stack + '*(';
                END
                ELSE
                BEGIN
                    SELECT @Stack = @Stack + '(';
                END;
            END
            ELSE IF SUBSTRING(@Expression, @i , 1) = ')'
            BEGIN
                WHILE RIGHT(@Stack, 1) <> '('
                BEGIN
                    INSERT INTO @Array (Operator)
                    SELECT RIGHT(@Stack, 1);
                    SET @Stack = LEFT(@Stack, LEN(@Stack)-1);
                END;
                SELECT @Stack = LEFT(@Stack, LEN(@Stack)-1), @Operand = '+';
            END;
        END;

        SET @i = @i + 1;
    END;
    WHILE LEN(@Stack) > 0
    BEGIN
        INSERT INTO @Array (Operator)
        SELECT RIGHT(@Stack, 1);
        SET @Stack = LEFT(@Stack, LEN(@Stack)-1);
    END;

    -- Теперь вычисляем выражение.
    WHILE EXISTS (SELECT TOP (1) 1 FROM @Array WHERE Operand Is Null)
    BEGIN
        SELECT @i = MIN(ID) FROM @Array WHERE Operand Is Null;

        WITH A AS (SELECT ID, LEAD(Operand, 2) OVER (ORDER BY ID DESC) A,
                              LEAD(Operand, 1) OVER (ORDER BY ID DESC) B
                   FROM @Array
                   WHERE ID <= @i AND Del Is Null)
        UPDATE @Array
        SET Operand = CASE Ar.Operator
            WHEN '^' THEN POWER(A.A, A.B)
            WHEN '*' THEN A.A * A.B
            WHEN '/' THEN A.A / A.B
            WHEN '+' THEN A.A + A.B
            WHEN '-' THEN A.A - A.B END
        FROM @Array Ar, A        
        WHERE Ar.ID = A.ID AND Ar.ID = @i;

        WITH A AS (SELECT LEAD(ID, 2) OVER (ORDER BY ID DESC) ID1,
                          LEAD(ID, 1) OVER (ORDER BY ID DESC) ID2, ID
                   FROM @Array
                   WHERE ID <= @i AND Del Is Null)
        UPDATE @Array SET Del = 1 FROM @Array Ar, A
        WHERE (Ar.ID = A.ID1 OR Ar.ID = A.ID2) AND A.ID = @i;
    END;

Get_Result:
    SELECT Operand AS Result FROM @Array WHERE Del Is Null;
END;

CREATE FUNCTION dbo.f_SeparatePolinomialMember
(@Expression AS Varchar(MAX))
RETURNS @Polinomial TABLE (Coefficient Float, Member Varchar(Max))
AS BEGIN
    IF @Expression IS NULL
    RETURN;

    DECLARE @Table AS TABLE (Number Float, Letter Varchar(100), Degree Smallint);
    DECLARE @Counter Int = 1, @Slice Varchar(4000);

    WHILE @Counter != 0
    BEGIN 
        SELECT @Counter = CHARINDEX('*', @Expression);
        IF @Counter != 0
            SELECT @Slice = REPLACE(REPLACE(LEFT(@Expression, @Counter - 1), '(', ''), ')', '');
        ELSE
            SELECT @Slice = REPLACE(REPLACE(@Expression, '(', ''), ')', '');

        INSERT INTO @Table (Number, Letter, Degree)
        SELECT
            CASE WHEN ISNUMERIC(@Slice) = 1 THEN CAST(@Slice AS Float)
                 WHEN @Slice LIKE '-[A-z]%' THEN -1 END,
            CASE WHEN ISNUMERIC(@Slice) = 1 THEN Null
                 WHEN @Slice LIKE '-[A-z]%^%' THEN SUBSTRING(@Slice, 2, CHARINDEX('^', @Slice, 1)-1)
                 WHEN @Slice LIKE '[A-z]%^%' THEN LEFT(@Slice, CHARINDEX('^', @Slice, 1)-1)
                 WHEN @Slice LIKE '-[A-z]%' THEN SUBSTRING(@Slice, 2, LEN(@Slice)-1)
                 ELSE @Slice END,
            CASE WHEN ISNUMERIC(@Slice) = 1 THEN Null
                 WHEN @Slice NOT LIKE '%^%' THEN 1
                 WHEN ISNUMERIC(SUBSTRING(@Slice, CHARINDEX('^', @Slice, 1)+1, LEN(@Slice))) = 1
                 THEN CAST(SUBSTRING(@Slice, CHARINDEX('^', @Slice, 1)+1, LEN(@Slice)) AS Smallint)
                 ELSE Null END;

        SELECT @Expression = RIGHT(@Expression, LEN(@Expression) - @Counter);
        IF LEN(@Expression) = 0 BREAK;
    END;

    WITH L AS (SELECT STUFF((SELECT '*' + Letter +
                    CASE WHEN SUM(Degree) = 1 THEN ''
                         ELSE '^' + CAST(SUM(Degree) AS Varchar(MAX)) END
                  FROM @Table
                  GROUP BY Letter
                  ORDER BY Letter FOR XML PATH('')), 1, 1, '') AS Member)
    INSERT INTO @Polinomial (Coefficient, Member)
    SELECT ISNULL(EXP(SUM(LOG(CASE WHEN T.Number = 0 THEN 1 ELSE ABS(T.Number) END)))
           * POWER(-1, (SUM(CASE WHEN T.Number < 0 THEN 1 ELSE 0 END)))
           * MIN(CASE WHEN T.Number = 0 THEN 0 ELSE 1 END), 1) AS Coefficient,
           CASE WHEN L.Member LIKE '%[A-z]%' THEN L.Member ELSE '' END AS Member
    FROM @Table T, L
    GROUP BY L.Member;

    RETURN;
END;
GO
CREATE PROCEDURE dbo.p_AlgebraicExpression
(@Expression AS Varchar(MAX), @Divider AS Varchar(MAX) = Null)
AS BEGIN
    SET NOCOUNT ON;

    -- Убираем пробелы, а также заменяем запятые на точку.
    SET @Expression = REPLACE(REPLACE(REPLACE(REPLACE(@Expression,
        ' ', ''), ',', '.'), CHAR(13), ''), CHAR(10), '');

    IF @Expression Is Null OR @Expression = ''
    GOTO Get_Result;

    IF @Expression LIKE '%[^0-9A-z().*^/+-]%'
    BEGIN
        SELECT Null Result, 'Обнаружен неверный символ.' ErrorMessage;
        RETURN;
    END;
    IF @Expression LIKE '%[A-z][A-z][A-z]%'
    BEGIN
        SELECT Null Result, '3 буквы подряд не допускается.' ErrorMessage;
        RETURN;
    END;

    IF @Expression NOT LIKE '%[A-z]%'
    BEGIN
        EXECUTE dbo.p_Reverse_Polish_Notation @Expression;
        RETURN;
    END;
    IF @Expression LIKE '-[A-z]%'
        SET @Expression = STUFF(@Expression, 1, 1, '-1*');
    ELSE IF @Expression LIKE '+%'
        SET @Expression = STUFF(@Expression, 1, 1, '');

    DECLARE @Stack Varchar(MAX), @Operand Varchar(50), @Letter Varchar(100),
            @i AS Int, @Result AS Varchar(MAX), @ID0 Int, @ID1 Int, @ID2 Int, @Max Int;
    DECLARE @Array AS TABLE (ID Int Identity(1, 1) Primary Key,
        N Int INDEX Array_N, N0 Int INDEX Array_N0,
        Operand Float, Member Varchar(10), Operator Varchar(50));
    DECLARE @Members AS TABLE (N Int INDEX Members_N, Coef Float, Member Varchar(100));

    -- Для облегчения задачи попробуем убрать знак ^ для алгебраических значений со скобками.
    WHILE @Expression LIKE '%(%)^%'
    BEGIN
        SELECT @Stack = LEFT(@Expression, CHARINDEX(')^', @Expression)),
               @i = CHARINDEX(')^', @Expression),
               @Max = 0;
        WHILE @Max <> 1
        BEGIN
            SET @i = @i - 1;
            SET @Max = @Max + CASE SUBSTRING(@Expression, @i, 1)
                                   WHEN '(' THEN 1 WHEN ')' THEN -1 ELSE 0 END;
        END;
        SET @Stack = SUBSTRING(@Stack, @i, LEN(@Stack));
        SET @Operand = SUBSTRING(@Expression, CHARINDEX(')^', @Expression)+2, 50);
        WHILE ISNUMERIC(@Operand) = 0 OR LEN(@Operand) = 0
        BEGIN
            SET @Operand = LEFT(@Operand, LEN(@Operand)-1);
        END;
        IF LEN(@Operand) = 0
        BEGIN
            SELECT Null Result, 'Неверное алгебраическое выражение.' ErrorMessage;
            RETURN;
        END;
        SET @i = CAST(@Operand AS Int);
        SET @Expression = STUFF(@Expression, CHARINDEX(')^', @Expression)+1, 1+LEN(@Operand),
            CASE WHEN @i = 1 THEN '' ELSE REPLICATE('*' + @Stack, @i-1) END);
        SELECT @Stack = '', @Operand = '';
    END;
    SELECT @Stack = '', @Operand = '', @i = 1, @Letter = '';

    /* Проверка
    SELECT @Expression Expression;
    RETURN; */

    /*  Приоритеты:
        высокий: ^
        средний: * /
        низкий: + &#8722;
        самый низкий: ()
    */
    WHILE @i <= LEN(@Expression)
    BEGIN
        -- Буквы (переменные)
        IF SUBSTRING(@Expression, @i , 1) LIKE '[A-z]'
        BEGIN
            SELECT
                @Letter = CASE
                    WHEN SUBSTRING(@Expression, @i , 5) LIKE '[A-z][A-z][0-9][0-9][0-9]'
                    THEN UPPER(SUBSTRING(@Expression, @i , 5))
                    WHEN SUBSTRING(@Expression, @i , 5) LIKE '[A-z][0-9][0-9][0-9][0-9]'
                    THEN UPPER(SUBSTRING(@Expression, @i , 5))
                    WHEN SUBSTRING(@Expression, @i , 4) LIKE '[A-z][A-z][0-9][0-9]'
                    THEN UPPER(SUBSTRING(@Expression, @i , 4))
                    WHEN SUBSTRING(@Expression, @i , 4) LIKE '[A-z][0-9][0-9][0-9]'
                    THEN UPPER(SUBSTRING(@Expression, @i , 4))
                    WHEN SUBSTRING(@Expression, @i , 3) LIKE '[A-z][A-z][0-9]'
                    THEN UPPER(SUBSTRING(@Expression, @i , 3))
                    WHEN SUBSTRING(@Expression, @i , 3) LIKE '[A-z][0-9][0-9]'
                    THEN UPPER(SUBSTRING(@Expression, @i , 3))
                    WHEN SUBSTRING(@Expression, @i , 2) LIKE '[A-z][0-9]' OR
                         SUBSTRING(@Expression, @i , 2) LIKE '[A-z][A-z]'
                    THEN UPPER(SUBSTRING(@Expression, @i , 2))
                    ELSE LOWER(SUBSTRING(@Expression, @i , 1)) END,
                @i = CASE
                    WHEN SUBSTRING(@Expression, @i , 5) LIKE '[A-z][A-z][0-9][0-9][0-9]' THEN @i+4
                    WHEN SUBSTRING(@Expression, @i , 5) LIKE '[A-z][0-9][0-9][0-9][0-9]' THEN @i+4
                    WHEN SUBSTRING(@Expression, @i , 4) LIKE '[A-z][A-z][0-9][0-9]' THEN @i+3
                    WHEN SUBSTRING(@Expression, @i , 4) LIKE '[A-z][0-9][0-9][0-9]' THEN @i+3
                    WHEN SUBSTRING(@Expression, @i , 3) LIKE '[A-z][A-z][0-9]' THEN @i+2
                    WHEN SUBSTRING(@Expression, @i , 3) LIKE '[A-z][0-9][0-9]' THEN @i+2
                    WHEN SUBSTRING(@Expression, @i , 2) LIKE '[A-z][0-9]' OR
                         SUBSTRING(@Expression, @i , 2) LIKE '[A-z][A-z]' THEN @i+1
                    ELSE @i END;
            INSERT INTO @Array (Operand, Member)
            SELECT 1, @Letter;
            SET @Letter = '';
        END
        -- Число
        ELSE IF SUBSTRING(@Expression, @i , 1) LIKE '[0-9.]'
        BEGIN
            SET @Operand = @Operand + SUBSTRING(@Expression, @i , 1);
            IF @i = LEN(@Expression)
            BEGIN
                INSERT INTO @Array (Operand)
                SELECT CAST(@Operand AS Float);
                SET @Operand = '';
            END
        END
        -- Операторы
        ELSE
        BEGIN
            IF @Operand NOT IN ('+', '-') AND LEN(@Operand) > 0
            BEGIN
                INSERT INTO @Array (Operand)
                SELECT CAST(@Operand AS Float);
                SET @Operand = '';
            END;
            IF LEN(@Letter) > 0
            BEGIN
                INSERT INTO @Array (Member)
                SELECT @Letter;
                SET @Letter = '';
            END;
            IF SUBSTRING(@Expression, @i , 1) = '^'
            BEGIN
                SELECT @Stack = @Stack + '^';
            END
            ELSE IF SUBSTRING(@Expression, @i , 1) LIKE '[*/]'
            BEGIN
                WHILE RIGHT(@Stack, 1) LIKE '[*/^]'
                BEGIN
                    INSERT INTO @Array (Operator)
                    SELECT RIGHT(@Stack, 1);
                    SET @Stack = LEFT(@Stack, LEN(@Stack)-1);
                END;
                SELECT @Stack = @Stack + SUBSTRING(@Expression, @i , 1);
            END
            ELSE IF SUBSTRING(@Expression, @i , 1) LIKE '[+-]'
            BEGIN
                WHILE RIGHT(@Stack, 1) LIKE '[*/^+-]'
                BEGIN
                    INSERT INTO @Array (Operator)
                    SELECT RIGHT(@Stack, 1);
                    SET @Stack = LEFT(@Stack, LEN(@Stack)-1);
                END;
                SELECT @Stack = @Stack + SUBSTRING(@Expression, @i , 1);
            END
            ELSE IF SUBSTRING(@Expression, @i , 1) = '('
            BEGIN
                IF @Operand = '-'
                BEGIN
                    INSERT INTO @Array (Operand)
                    SELECT -1;
                    SELECT @Operand = '', @Stack = @Stack + '*(';
                END
                ELSE
                BEGIN
                    SELECT @Stack = @Stack + '(';
                END;
            END
            ELSE IF SUBSTRING(@Expression, @i , 1) = ')'
            BEGIN
                WHILE RIGHT(@Stack, 1) <> '('
                BEGIN
                    INSERT INTO @Array (Operator)
                    SELECT RIGHT(@Stack, 1);
                    SET @Stack = LEFT(@Stack, LEN(@Stack)-1);
                END;
                SELECT @Stack = LEFT(@Stack, LEN(@Stack)-1), @Operand = '+';
            END;
        END;

        SET @i = @i + 1;
    END;
    WHILE LEN(@Stack) > 0
    BEGIN
        INSERT INTO @Array (Operator)
        SELECT RIGHT(@Stack, 1);
        SET @Stack = LEFT(@Stack, LEN(@Stack)-1);
    END;
    -- Обратная польская запись завершена. Теперь приступаем к основной задаче.
    SELECT @i = 1, @ID0 = 0, @Max = ((SELECT MAX(ID) FROM @Array)-1)*0.5;
    WHILE @i Is Not Null
    BEGIN
        WITH M AS (SELECT MIN(ID) ID FROM @Array
                   WHERE Operator Is Not Null AND N0 Is Null AND ID > @ID0),
        II AS (SELECT A.ID, A.Operator,
                      CASE WHEN A.ID = M.ID THEN 1 ELSE 0 END Remark,
                      LEAD(A.ID, 1) OVER (ORDER BY A.ID DESC) ID1,
                      LEAD(A.ID, 2) OVER (ORDER BY A.ID DESC) ID2
               FROM @Array A, M
               WHERE A.ID <= M.ID AND (A.N Is Null OR (A.Operator Is Not Null AND A.N0 Is Null)))
        SELECT @ID0 = II.ID, @ID1 = II.ID1, @ID2 = II.ID2, @Stack = II.Operator
        FROM II WHERE II.Remark = 1;

        IF @ID1 Is Null OR @ID2 Is Null
        BREAK;

        UPDATE @Array
        SET N = CASE WHEN N Is Not Null THEN N ELSE @i END,
            N0 = CASE WHEN N Is Not Null THEN @i ELSE Null END
        WHERE ID IN (@ID0, @ID1, @ID2);

        IF @Stack = '^'
        BEGIN
            WITH
            A1 AS (SELECT TOP(1) COALESCE(M.Coef, A.Operand, 1) Degree
                  FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                  WHERE A.ID = @ID1)
            INSERT INTO @Members (N, Coef, Member)
            SELECT @i, POWER(A.Operand, A1.Degree) Coef,
                   CASE WHEN LEN(A.Member) > 0 THEN
                        (SELECT PM.Member FROM dbo.f_SeparatePolinomialMember
                            (STUFF(REPLICATE('*'+A.Member, A1.Degree), 1, 1, '')) PM) ELSE '' END AS Member
            FROM @Array A, A1
            WHERE A.ID = @ID2;
        END;
        ELSE IF @Stack = '*'
        BEGIN
            WITH
            A2 AS (SELECT COALESCE(M.Coef, A.Operand, 1) Coef,
                          COALESCE(M.Member, A.Member, '') Member
                  FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                  WHERE A.ID = @ID2),
            A1 AS (SELECT COALESCE(M.Coef, A.Operand, 1) Coef,
                          COALESCE(M.Member, A.Member, '') Member
                  FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                  WHERE A.ID = @ID1),
            AA AS (SELECT A2.Coef*A1.Coef Coef,
                          CASE WHEN LEN(A1.Member) = 0 AND LEN(A2.Member) = 0 THEN '' ELSE
                          (SELECT PM.Member
                           FROM dbo.f_SeparatePolinomialMember(CASE
                                WHEN LEN(A2.Member) = 0 THEN A1.Member
                                WHEN LEN(A1.Member) = 0 THEN A2.Member
                                ELSE A2.Member + '*' + A1.Member END) PM) END Member
                   FROM A2, A1)
            INSERT INTO @Members (N, Coef, Member)
            SELECT @i, SUM(AA.Coef) Coef, AA.Member
            FROM AA
            GROUP BY AA.Member
            HAVING SUM(AA.Coef) <> 0;
        END;
        ELSE IF @Stack = '/'
        BEGIN
            WITH
            A2 AS (SELECT COALESCE(M.Coef, A.Operand, 1) Coef,
                          COALESCE(M.Member, A.Member, '') Member
                  FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                  WHERE A.ID = @ID2),
            A1 AS (SELECT COALESCE(M.Coef, A.Operand, 1) Coef,
                          COALESCE(M.Member, A.Member, '') Member
                  FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                  WHERE A.ID = @ID1),
            AA AS (SELECT A2.Coef/A1.Coef Coef,
                          CASE WHEN LEN(A1.Member) = 0 AND LEN(A2.Member) = 0 THEN '' ELSE
                          (SELECT PM.Member
                           FROM dbo.f_SeparatePolinomialMember(CASE
                                WHEN LEN(A2.Member) = 0 THEN '1/(' + A1.Member + ')'
                                WHEN LEN(A1.Member) = 0 THEN A2.Member
                                ELSE A2.Member + '/' + A1.Member END) PM) END Member
                   FROM A2, A1)
            INSERT INTO @Members (N, Coef, Member)
            SELECT @i, SUM(AA.Coef) Coef, AA.Member
            FROM AA
            GROUP BY AA.Member
            HAVING SUM(AA.Coef) <> 0;
        END;
        ELSE IF @Stack = '+'
        BEGIN
            WITH AA AS (SELECT ISNULL(M.Coef, A.Operand) Coef, COALESCE(M.Member, A.Member, '') Member
                        FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                        WHERE A.ID = @ID2
                        UNION ALL SELECT ISNULL(M.Coef, A.Operand), COALESCE(M.Member, A.Member, '')
                        FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                        WHERE A.ID = @ID1)
            INSERT INTO @Members (N, Coef, Member)
            SELECT @i, SUM(AA.Coef) Coef, AA.Member
            FROM AA
            GROUP BY AA.Member
            HAVING SUM(AA.Coef) <> 0;
        END
        ELSE IF @Stack = '-'
        BEGIN
            WITH AA AS (SELECT ISNULL(M.Coef, A.Operand) Coef, COALESCE(M.Member, A.Member, '') Member
                        FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                        WHERE A.ID = @ID2
                        UNION ALL SELECT ISNULL(-M.Coef, -A.Operand), COALESCE(M.Member, A.Member, '')
                        FROM @Array A LEFT JOIN @Members M ON A.N = M.N
                        WHERE A.ID = @ID1)
            INSERT INTO @Members (N, Coef, Member)
            SELECT @i, SUM(AA.Coef) Coef, AA.Member
            FROM AA
            GROUP BY AA.Member
            HAVING SUM(AA.Coef) <> 0;
        END;

        SET @i = @i + 1;
        IF @i > @Max BREAK;
    END;

    SET @Result = '';

    UPDATE @Members SET Member = '' WHERE Member Is Null;

Get_Result:
    /* Проверка
    SELECT * FROM @Array;
    SELECT * FROM @Members; */
    
    SELECT @Result = @Result +
        CASE WHEN Member = '' OR Member Is Null THEN REPLACE(CAST(Coef AS Varchar(MAX)), '.', ',')
             WHEN Coef = 1 THEN '+' + Member
             WHEN Coef > 0 THEN '+' + REPLACE(CAST(Coef AS Varchar(MAX)), '.', ',') + '*' + Member
             WHEN Coef = -1 THEN '-' + Member
             WHEN Coef < 0 THEN REPLACE(CAST(Coef AS Varchar(MAX)), '.', ',') + '*' + Member END
    FROM @Members
    WHERE N = @Max AND Coef <> 0
    ORDER BY Member;

    SELECT CASE WHEN LEFT(@Result, 1) = '+' THEN STUFF(@Result, 1, 1, '')
                ELSE @Result END AS Result, Null AS ErrorMessage;
END;