@FoggyFinder Да

static Expr[] SolveSimpleRoot(Expr variable, Expr expr)
{
    Expr simple = Algebraic.Expand(Rational.Numerator(Rational.Simplify(variable, expr)));
    Expr[] coeff = Polynomial.Coefficients(variable, simple);
    switch (coeff.Length)
    {
        case 1:
            return new[] { Expr.Zero.Equals(coeff[0]) ? variable : Expr.Undefined };
        case 2:
            return new[] {
                Rational.Simplify(variable, Rational.Expand(-coeff[0] / coeff[1])) };
        case 3:
            {

использование:

            var x = Expr.Symbol("x");

            Expr aleft = Infix.ParseOrThrow("x + y");
            Expr aright = Infix.ParseOrThrow("2");
            var roots = SolveSimpleRoot(x, aleft - aright);
            foreach (var root in roots)
                Console.WriteLine(Infix.Format(root));

@Philippe ^

@FoggyFinder Работает, спасибо!

@Philippe обращайтесь, к слову - на F# код смотрелся бы более органично, так как сама библиотека написана на F#

@FoggyFinder Работает, спасибо!

@FoggyFinder Никогда не пробовал F#. Кстати, если я использую SolveSimpleRoot с одной переменной, это сработает с функциями типа sin / cos / sqrt?

@Philippe если правильно понял вопрос, то нет, для каждого вида уравнений нужно писать свою функцию, для сложных соответственно - композицию. Но если покажите пример смогу сказать точнее

F# на самом деле очень удобен для математических вычислений, обработки данных - чуть позже перепишу SolveSimpleRoot на F# чтобы нагляднее продемонстрировать разницу

@FoggyFinder Ну, SolveSimpleRoot (метод, который вы мне надвно отправили) с легкосью решит что-то типа x + 4 = 2. Но решит ли он, если я напишу что-то вроде sin(60) * x + 4 = 2?

@Philippe конечно

но результат будет в виде - -2/sin(60)

если нужно получать конкретные значение, то можно вначале сделать проверку на наличие в выражение символьных переменных и в том случае, если их нету отобразить приблизительное значение Approximate или более точное через Evaluate

переписал на F#:

let solveSimpleRoot variable expr =
    let coeff =
        (variable, expr)
        ||> Rational.simplify
        |> Rational.numerator
        |> Algebraic.expand
        |> Polynomial.coefficients variable
    match coeff.Length with
    | 1 when coeff.[0] = Expression.Zero -> [ variable ]
    | 2 ->
        [ (-coeff.[0] / coeff.[1])
          |> Rational.expand
          |> Rational.simplify variable ]
    | 3 ->
        let D = coeff.[1] * coeff.[1] - 4 * coeff.[0] * coeff.[2]
        [ (-coeff.[1] + Operators.sqrt (D)) / (2 * coeff.[2])

@FoggyFinder Привет )) Вы, случаем, с aes шифрованием не работали ?

@Lolidze Привет, не уверен. А что конкретно нужно? Шифрование довольно интересная тема

я столкнулся с проблемой ru.stackoverflow.com/questions/685757/…

@FoggyFinder самое интересное, что если файл превышает 1 мб, то все нормально

@FoggyFinder нашел ответ, т.к я добавлял соль в файл, то перед расшифровкой надо было соль удалить из файла.

@Lolidze хм, а почему тогда файл размером больше 1Мб расшифровывало правильно?

@FoggyFinder для меня это тоже загадка, но как только удалил соль, то расшифровывалось без ошибок. Если файл больше 1мб, то она соль не трогала и в результате соль оставалась без изменений

@FoggyFinder щас еще проблема вышла : после расшифровки, в конец добавляет рандомные байты, около 16

@Lolidze странно