Форум dkLab и Denwer

Александр Михалицын · Posted: Fri May 29, 2009 4:48 pm () Post subject:

М

Выделено из темы «"Решалка" квадратичных уравнений»,
расположенной в форуме Разное :: JavaScript (08 Июня 2009, 13:30).

Юрий Насретдинов

dimagolov wrote:

даже с учетом того, что мои личные воспоминания об этом курсе вообще и предмете в частности весьма смутные, никто не отменял вот это: tinyurl.com/lungdd

Представляю себе круглые глаза человека, впервые узнавшего о концепции комплексных чисел и увидевшего формулу для корня порядка N из комплексного числа :).

dimagolov

Quote:

А теперь, если ты каждый метод опишешь (как он работает) будет вообще супер. =)

Что там описывать? это просто арифметика комплексных чисел, если Юрий не накосячил (я просто не проверял), то Вы по его коду можете выучить ее. Комплексное число у него представлено массивом - 0-й элемент это действительная часть, 1-й это комплексная.

Quote:

Мне интересно значть что вы тм в ТФКП проходили... =)

Если есть время и желание, то даже 8-й класс не станет проблемой: tinyurl.com/llzu4m
Правда, придется многое чего подучить, я вот не помню когда изучаются тригонометрические ф-ии. На самом деле комплексные числа это просто - вместо числовой прямой это можно представить как плоскость. Правда, уже ф-я комплексной переменной создает некоторые трудности в воображении, так как график такой ф-ии придется рисовать в 4-х мерном пространстве

dimagolov

кстати, первой программой, которую я самостоятельно написал были именно решалка квадратных уравнений. написана она была на Basic для Искра 226, был в свое время такой персональный компьютер (невероятно компактный, помещался на одном столе даже вместе с приводами 8-дюймовых флопов)...
странно, мне казалось, что квадратные уравнения изучались много раньше, чем в 8-м классе, если считать с 6-и лет (хотя тогда ходили в школу с 7-ми) то по идее в 6-м, если даже не в 5-м?

Rumata

Хотя реализация комплексных чисел на js (как мне кажется) не представляет практического интереса, но ради интереса можно попытаться воплотить большинство математических действий для комплексных чисел. Конечно, перегрузка операций в js невозможна, но даже этот недостаток частично можно обойти, например, с помощью функций-методов. Последнее я представляю примерно так:

Code (JavaScript):	скопировать код в буфер обмена
// z1 = 1 + i z1 = new Complex(1, 1); // z2 = 1 - i z2 = new Complex(1, -1); // z3 = z1 + z2 z3 = a1.add(z2);

Опять же повторюсь, практического значения у данной реализации мало - данное решение интересно лишь с учебной точки зрения. Медленно и отсутствие поддержки перегрузки операторов со стороны языка.

Александр Михалицын

Rumata,
угу. Как только я разберусь с комплексными числами, обязательно напишу подобные объекты, именно в целях обучения.
Спасибо всем, кто подсказал и помог с кодом. [+]ы. ;-)

Rumata

ru.wikipedia.org/wiki/Комплексное_число
en.wikipedia.org/wiki/Complex_number

Информация не самая полная, но для начала должно хватить.
Пишите. Хотелось бы увидеть ваше решение. Я уже приготовил каверзных вопросов (-:

Александр Михалицын

Rumata,

Quote:

Пишите.

Мы на "ты". ;-)

Quote:

Я уже приготовил каверзных вопросов (-:

Отлично... =)

Александр Михалицын

Code (JavaScript):

скопировать код в буфер обмена

/*
function Complex(a, b)
{
this.a = a; //
this.b = b; //

/*
this.sum = function(complex) //
{
return new Complex(this.a + complex.a, this.b + complex.b);
}

/*
this.diff = function(complex) //
{
return new Complex(this.a - complex.a, this.b - complex.b);
}

/*
this.multi = function(complex) //
{
var a = this.a;
var c = complex.a;

var b = this.b;
var d = complex.b;

return new Complex(a * c - b * d, b * c + a * d);
}

/*
this.division = function(complex) //
{
var a = this.a;
var c = complex.a;

var b = this.b;
var d = complex.b;

var new_complex_a = (a * c + b * d) / (c * c + d * d);
var new_complex_b = (d * c - a * d) / (c * c + d * d);

return new Complex(new_complex_a, new_complex_b);
}

/*
this.compare = function(complex) //
{
if (this.a == complex.a && this.b == complex.b)
{
return true;
} else {
return false;
}
}

/*
this.modules_compare = function(complex)
{
var module_this_z = Math.sqrt(this.a * this.a + this.b * this.b);
var module_complex_z = Math.sqrt(complex.a * complex.a + complex.b * complex.b);

if (module_this_z > module_complex_z)
{
return true; //
} else if (module_this_z < module_complex_z) {
return false; //
} else {
return null; //
}
}

this.toString = function()
{
return this.a + (this.b + 'i');
}
}

Жду критики. :)

Юрий Насретдинов

Хм, ну да, и мой вариантик, + решалка квадратных уравнений, переписанная под использование класса комплексных чисел.

Code (JavaScript):

скопировать код в буфер обмена

Александр Михалицын

Да уж... С такими темпами нам надо открыть доп. форум "Математика". (-:

Юрий Насретдинов,
классно... Что уж тут сказать...

Rumata

Александр Михалицын
Юрий Насретдинов
Есть несколько замечаний. Что-то мне подсказывает, что некоторые места в ваших алгоритмах не оптимальны. Непонятно, почему никто из вас не воспользовался другими формами представления комплексных чисел. А методы - pow, pow2 и log - от чего такие страшные вычисления? Можно же проще.
Я ни в коем случае не придираюсь. Не такая уж серьезная задача ставилась. Но все-таки...

Александр Михалицын

Rumata,

Quote:

Непонятно, почему никто из вас не воспользовался другими формами представления комплексных чисел.

А что может быть оптимальнее объекта? (-:
Массив? Тоже объект -- насколько мне кажется, даже более "не оптимальный". (-:

Quote:

А методы - pow, pow2 и log - от чего такие страшные вычисления? Можно же проще.

Давай-ка изложишь тут или мне в ICQ? Интересно будет послушать (зачеркнуто) почитать...

Quote:

Я ни в коем случае не придираюсь.

Да можно и попридираться... (-:

Юрий Насретдинов

Rumata wrote:

Непонятно, почему никто из вас не воспользовался другими формами представления комплексных чисел.

Для вычисления степени как раз осуществляется переход к экспоненциальной форме записи :).

А проще вряд ли можно сделать, потому что извлечение корня степени n из числа является многозначной функцией, поэтому необходимо такие ситуации обрабатывать правильно и возвращать массив ответов :).

Для логарифма количество возвращаемых значений счётно, поэтому возвращается только главное значение логарифма :). К тому же, я не очень понял, чего ты сложного увидел в реализации pow2 и логарифма?

Last edited by Юрий Насретдинов on Sun Jun 07, 2009 7:02 pm; edited 2 times in total

Александр Михалицын · Posted: Sun Jun 07, 2009 6:56 pm (спустя 5 минут) Post subject:

М

Тему скоро надо будет порезать... Как закончим обсуждение -- сделаю.
А то тут уже и решение квадратичных уравнений и комплексные числа... Осталось только тригонометрические функции обсудить. (-:

Rumata

Александр Михалицын
Я имел ввиду тригонометрическую форму представления

Code (any language):	скопировать код в буфер обмена
z = r * (cos(f) + isin(f))

Юрий Насретдинов
Я видел перевод из алгебраической в тригонометрическую, но почему же так много строк в методе pow? К чему лишние проверки? К вопросу о многозначности результатов вычисления корней. Мне кажется, что pow - функция "общего назначения" для вычисления степени вообще. Не понятен смысл pow и pow2. По моему одна из них повторяет алгоритм другой. А умножение, деление - разве не проще выполнять в тригонометрической форме?

Rumata

Юрий Насретдинов wrote:

К тому же, я не очень понял, чего ты сложного увидел в реализации pow2 и логарифма?

Я понимаю, что там предусмотрено вычисление произвольного логарифма, мне кажется, это можно было бы вынести за пределы. Но я это не оспариваю. Много кода чтобы вычислить логарифм числа

Code (any language):	скопировать код в буфер обмена
log(z) = log(r) + i f

. Что может быть проще чем

Code (JavaScript):	скопировать код в буфер обмена
Complex.prototype.log = function() { return new Complex(this.abs(), this.arg()); };

Что характерно, в классе описан метод вычисления модуля Complex.abs(), но практически не используется.

Юрий Насретдинов

Rumata wrote:

Что характерно, в классе описан метод вычисления модуля Complex.abs(), но практически не используется.

На самом деле, совсем не используется...

Rumata wrote:

Complex.prototype.log = function()
{
return new Complex(this.abs(), this.arg());
};

Ну, во-первых, ты забыл самое главное, а именно, логарифм взять от модуля :).
К тому же, я думаю, ты мог заметить, что основную часть кода составляет проверка основания логарифма и выполнение соответствующих действий для различных оснований.
Ну и последнее, твой код вряд ли будет сильно эффективнее, поскольку вычислений будет на самом деле произведено ровно столько же, просто они запрятаны в методы, некоторых из которых к тому же не существует (к примеру, аргумента :)).

Rumata

Конечно я заметил, что ведется большая проверка на корректность входных данных. И твой метод log позволяет вычислить произвольный логарифм для большинства случаев действительных оснований. Для этого и нужны были проверки. Но так ли необходимо такое усложнение? Приводя в качестве примера свое видение метода log я хотел только показать, что некоторые вычисления можно было бы вынести в отдельные методы. Можно даже провести самые тщательные проверки и показать, что мой вариант, возможно, будет слегка проигрывать по скорости. А возможно и нет. Я говорю не об эффективности. Я говорю о красоте кода :)

Юрий Насретдинов

Эм, ну все же проверки на корректность должны быть в коде, от этого никуда не деться. А вот с остальным, в том числе и с использованием .abs() и .arg() я пожалуй соглашусь и постараюсь доделать :).

Rumata

Неточно выразился. Я имел ввиду так ли необходима универсальность, например, того же метода log? Кстати

Code (any language):	скопировать код в буфер обмена
ln(z) = ln(r) + i f lg(z) = lg(r) + i f lg(e)

то есть

Code (JavaScript):	скопировать код в буфер обмена
Complex.prototype.log = function(base) { ... var r = this.abs(); var x = Math.log(r); var y = this.arg(); if ( base ) { var lg = Math.log(base); x /= lg; y /= lg; } return new Complex(x, y); };

Юрий Насретдинов

Нда, со сменой основания у логарифма немного лоханулся :). Конечно, надо еще и мнимую часть преобразовывать также... Наверное действительно лучше все же выкинуть поддержку другого основания у логарифма (в принципе, особой необходимости в этом нет).

Юрий Насретдинов

А pow() отличается от pow2() тем, что pow2() рассматривает число, как рациональное, а не вещественное, и соотвественно возвращает n корней вместо одного (в функции pow() считается, что если n или 1/n не являются целыми, то число, подающееся на вход, вещественное, и надо вернуть только 1 результат (как раз то, о чем ты говорил).

Александр Михалицын

М

Сейчас дообсуждаем, допилим -- можно будет в "склад".

[off]Я еще строилку графиков писал =) Тоже выложу потом.
А то, к сожалению, в разделах JavaScript'a большинство новых тем
из серии "Памагите!!!".[/off]

Так с логарифмом, я так понимаю проблема решена? Вариант от Rumata верный?

Last edited by Александр Михалицын on Thu Aug 19, 2010 4:54 pm; edited 1 time in total

Rumata

Добавлю свое видение задачи. Оно в принципе не отличается от варианта, предложенного Юрием Насретдиновым. Особенностью модуля является вычисление всех частей (вещественной, мнимой, модуля и аргумента) комплексного числа на момент его создания. Это ни прибавляет, ни отнимает скорости вычислений, но оптимизирует некоторые вычисления (например, при вычислениях в алгебраической или полярной формах). Описаны арифметические операции, основные функции над комплексными числами (возведение в степень, логарифм, степенная функция, экспонента, квадратный корень и вычисление всех корней). Арифметические операции расширены для операций над несколькими числами. То есть

Code (JavaScript):	скопировать код в буфер обмена
var x = new Complex(1, 1); var y = x.add(new Complex(2, 0)).add(new Complex(3, 0)); // Расширение var y = x.add(new Complex(2, 0), new Complex(3, 0));

Определены методы вычисления частей комплексного числа - вещественной re(), мнимой im(), модуля abs() и аргумента arg() комплексного числа, а также вычисление сопряженного комплексного числа conj() и его отрицательного значения neg(). Функция строкового преобразования Complex.prototype.toString позволяет отобразить комплексное число как в алгебраической, так и в полярной формах. Добавлены одноименные методы объекту Number для упрощения совместной работы с комплексными и реальными числами. То есть предыдущий пример можно записать еще короче

Code (JavaScript):	скопировать код в буфер обмена
var y = x.add(2, 3);

n-ные корни чисел вычисляются все. Результатом является как массив корней комплексных чисел (по умолчанию), так и массив аргументов комплексных чисел и общий модуль как свойство abs результирующего массива (аргументы корней определены на интервале от -pi до +pi):

Code (JavaScript):	скопировать код в буфер обмена
var x = -2; // var carte = x.roots(2); // var polar = x.roots(2, true);

В общем, никому ненужный модуль. Баловство одно.

Code (JavaScript):

скопировать код в буфер обмена

/**
* Constructor of the complex in the cartesian coordinates (x, y)
* z = x + iy
*
*/
function Complex()
{

var self = this;

// Cartesian notation
// z = x + iy
var x;
var y;

// Polar notation
// z = r (cos(f) + i sin(f))
// z = r exp(if)
var r;
var f;

// Initialization
x = Number(arguments[0]) || 0;
y = Number(arguments[1]) || 0;

if ( arguments.callee.caller == Complex.construct ) {
r = Number(arguments[2]);
f = Number(arguments[3]);
} else {
r = Math.sqrt(x * x + y * y);
f = Math.atan2(y, x);
}

// Normalization within the left-opened interval (-pi +pi]
if ( f > Math.PI || f <= -Math.PI ) {
var pi2 = 2 * Math.PI;

f += Math.PI;
f -= Math.floor(f / pi2) * pi2;
f -= Math.PI;
}

/**
* Comparison of complex
*
*/
self.equals = function(z)
{
return x == z.re() && y == z.im();
};

/**
* True if the complex is real
*
*/
self.isReal = function()
{
return y == 0;
};

/**
* Re(z) = x
*
*/
self.re = function()
{
return x;
};

/**
* Im(z) = y
*
*/
self.im = function()
{
return y;
};

/**
* Module (absolute value) of z
* |z| = sqrt(x^2 + y^2)
*
*/
self.abs = function()
{
return r;
};

/**
* Argument of z
* Arg(z) = arctg(y / x)
*
*/
self.arg = function()
{
return f;
};

/**
* Complex conjugate
* z = x + iy
* z' = x - iy
*
*/
self.conj = function()
{
return Complex.construct(x, -y, r, -f);
};

/**
* Complex negative
*
*/
self.neg = function()
{
return Complex.construct(-x, -y, r, r ? f + Math.PI : 0);
};

/**
* Add
*
*/
self.add = function()
{
var x1 = x;
var y1 = y;
for (var i = 0; i < arguments.length; i++) {
var z = arguments[i];
x1 += z.re();
y1 += z.im();
}
return new Complex(x1, y1);
};

/**
* Substract
*
*/
self.sub = function()
{
var x1 = x;
var y1 = y;
for (var i = 0; i < arguments.length; i++) {
var z = arguments[i];
x1 -= z.re();
y1 -= z.im();
}
return new Complex(x1, y1);
};

/**
* Multiply
*
*/
self.mul = function()
{
var r1 = r;
var f1 = f;
for (var i = 0; i < arguments.length; i++) {
var z = arguments[i];
r1 *= z.abs();
f1 += z.arg();
}
return Complex.fromPolar(r1, f1);
};

/**
* Divide
*
*/
self.div = function()
{
var r1 = r;
var f1 = f;
for (var i = 0; i < arguments.length; i++) {
var z = arguments[i];
r1 /= z.abs();
f1 -= z.arg();
}
return Complex.fromPolar(r1, f1);
};

/**
* Degree z^n
*
*/
self.pow = function(n)
{
n = Number(n) || 0;
return Complex.fromPolar(Math.pow(r, n), f * n);
};

/**
* Returns the list of n-th roots
*
*/
self.roots = function(n, toPolar)
{
n = Number(n);

if ( n - Math.floor(n) ) {
return Number.NaN;
}

var nr = Math.pow(r, 1 / n);
var nf = [];

var fi = f / n;
var d = Math.PI * 2 / n;

n = Math.abs(n);
var i = n;
while ( i-- ) {
nf.push(fi);
fi += d;
};

if ( toPolar ) {
nf.abs = nr;
return nf;
}

var z = [];
for (var i = 0; i < n; i++) {
z.push(Complex.fromPolar(nr, nf[i]));
}

return z;
};

/**
* Square root of z
*
*/
self.sqrt = function()
{
return Complex.fromPolar(Math.sqrt(r), f / 2);
};

/**
* Exponential exp(z)
*
*/
self.exp = function()
{
return Complex.fromPolar(Math.exp(x), y);
};

/**
* Natural logarithm ln(z)
*
*/
self.log = function()
{
return new Complex(Math.log(r), f);
};

/**
* Creates a new complex from itself
*
*/
self.z = function()
{
return Complex.construct(this.re(), this.im(), this.abs(), this.arg());
};

var eps = function(x)
{
return Math.abs(x) <= Complex.ZERO_THRESHOLD ? 0 : x;
};

/**
* String presentation of the complex number
* If toPolar is true then this method returns the (r, f) pair
* Otherwise the (x, y) pair
*
*/
self.toString = function(toPolar)
{
if ( toPolar ) {
return [eps(r), eps(f)].join(' ');
}

if ( ! eps(y) ) {
return '' + eps(x);
}

return [eps(x), y].join('i');
};

};

/**
* Zero displaying threshold
* ZERO_THRESHOLD = 1e-15
*/
Complex.ZERO_THRESHOLD = 1e-15;

/**
* Internally used method
*
*/
Complex.construct = function(x, y, r, f)
{
return new Complex(x, y, r, f);
};

/**
* Creates a complex from polar coordinates (r, f)
* z = r (cos(f) + isin(f))
* z = r exp(if)
*
*/
Complex.fromPolar = function()
{
var r = Number(arguments[0]) || 0;
var f = Number(arguments[1]) || 0;

var x = r * Math.cos(f);
var y = r * Math.sin(f);

return Complex.construct(x, y, r, f);
};

/**
* Creates a complex from a real
*
*/
Complex.re = function()
{
if ( arguments[0] && arguments[0].constructor != Number ) {
throw new TypeError();
}

var n = Number(arguments[0]) || 0;
return n.z();
};

/**
* Creates imaginary number
*
*/
Complex.im = function()
{
if ( arguments[0] && arguments[0].constructor != Number ) {
throw new TypeError();
}

var y = Number(arguments[0]) || 1;
var f = Math.PI / 2;
return Complex.construct(0, y, Math.abs(y), y < 0 ? -f : f);
};

/**
* Clones new complex without calculation of internal variables
*
*/
Complex.z = function(x, y)
{
return new Complex(x, y);
};

/**
* Methods for compatibility of Number with Complex
*
*/
Number.prototype.equals = function(z)
{
return this == z.re() && z.im() == 0;
};

Number.prototype.isReal = function()
{
return true;
};

Number.prototype.re = function()
{
return this;
};

Number.prototype.im = function()
{
return 0;
};

Number.prototype.abs = function()
{
return Math.abs(this);
};

Number.prototype.arg = function()
{
return this >= 0 ? 0 : Math.PI;
};

Number.prototype.conj = function()
{
return this.z();
};

Number.prototype.neg = function()
{
return (-this).z();
};

Number.prototype.add = function(z)
{
return this.z().add.apply(this, arguments);
};

Number.prototype.sub = function(z)
{
return this.z().sub.apply(this, arguments);
};

Number.prototype.mul = function(z)
{
return this.z().mul.apply(this, arguments);
};

Number.prototype.div = function(z)
{
return this.z().pow.apply(this, arguments);
};

Number.prototype.pow = function(n)
{
return this.z().pow(n);
};

Number.prototype.roots = function(n, toPolar)
{
return this.z().roots(n, toPolar);
};

Number.prototype.sqrt = function()
{
return this.z().sqrt();
};

Number.prototype.exp = function()
{
return Math.exp(this).z();
};

Number.prototype.log = function()
{
return this.z().log();
};

Number.prototype.z = function()
{
return Complex.construct(this.re(), this.im(), this.abs(), this.arg());
};

Last edited by Rumata on Sun Jun 21, 2009 1:57 pm; edited 6 times in total

Юрий Насретдинов

Rumata wrote:

self.neg = function()
    {
        return Complex.construct(-x, -y, r, -f);
    };

Кажется, тут всё-таки ошибка.
К примеру: есть число 1. У него аргумент = 0. После того, как взяли его с обратным знаком (-1), согласно этой формуле аргумент всё равно остаётся 0. А должен быть аргумент PI (ну или -PI). Поэтому, правильная формула должна выглядеть примерно так:

Code (JavaScript):	скопировать код в буфер обмена
self.neg = function() { return Complex.construct(-x, -y, r, f>0 ? Math.PI-f : Math.PI-f - 2*Math.PI); };

Rumata

И то верно. Юрий Насретдинов, спасибо за подсказку. Издержки копи-паста. Вот верный вариант:

Code (JavaScript):	скопировать код в буфер обмена
self.neg = function() { return Complex.construct(-x, -y, r, r ? -f \|\| Math.PI : 0); };

Учитывает действительные числа и "комплексные нули", так что аргументы чисел лежат в интервале (-pi, +pi], а ноль он по всем параметрам ноль.

Last edited by Rumata on Sat Jun 13, 2009 4:31 pm; edited 1 time in total

Александр Михалицын

Rumata,
[+] За хорошую реализацию.

М

Я думаю самое время переместить эти классы в "склад". Не так ли?
Что решим? Оба ваших класса туда выставить?

Юрий Насретдинов

Сильно измененная версия, по-максимуму избавленная от непонятных и сложных операций (кроме метода .toString(), который сделан «умным»).

Также изменено название класса с Complex на Z для краткости, а также новый способ передачи аргументов функциям: если указывается 2 аргумента, а не 1, то они трактуются как компоненты комплексного числа.

Пример:

Code (JavaScript):	скопировать код в буфер обмена
var a = new Z(1,2); alert( a.mul(0,1) ); // выведет -2+i // эквивалентно следующему: alert( a.mul( new Z(0,1) ) ); // выведет то же самое

Код:

Code (JavaScript):

скопировать код в буфер обмена

Last edited by Юрий Насретдинов on Tue Jun 16, 2009 3:31 pm; edited 11 times in total

Юрий Насретдинов

Rumata wrote:

self.neg = function()
    {
        return Complex.construct(-x, -y, r, x || y ? -f || Math.PI : 0);
    };

И всё равно «не то»...

Сравните:

Code (JavaScript):	скопировать код в буфер обмена
var a = new Z(1,1.5); var b = new Complex(1,1.5); alert(a.neg().toString(true) + ' vs. ' + b.neg().toString(true)); // выведет 1.8027756377319946exp(-i2.158798930342464) vs. 1.8027756377319946 -0.982793723247329

Лучше в таком случае просто Math.atan2() используйте напрямую:

Code (JavaScript):	скопировать код в буфер обмена
self.neg = function() { return Complex.construct(-x, -y, r, Math.atan2(-y,-x)); };

Простая же задача, вот смотрите:

-1 = exp(i*PI) = exp(-i*PI)
-1*r*exp(i*f) = exp(-i*PI)*r*exp(i*f) = r*exp(i*(f-PI));

Откуда у Вас берется просто «-f»??

Rumata

Юрий Насретдинов wrote:

Также изменено название класса с Complex на Z для краткости, а также новый способ передачи аргументов функциям: если указывается 2 аргумента, а не 1, то они трактуются как компоненты комплексного числа.

Очень понравилась идея с аргументами. А также можно массив двух элементов трактовать как комплексное число, и т.д (-:. Немного спорно переименование, но, в-целом, тоже нравится.

Мне больше нравится "сливать" всякие вычисления в eval, например:

Code (JavaScript):	скопировать код в буфер обмена
eval.equ2 = fucntion(a, b, c) ... var x = eval.equ2(1, 1, -1);

Rumata

Юрий Насретдинов wrote:

И всё равно «не то

А-а-а! Шайтан!

Юрий Насретдинов

Rumata wrote:

eval.equ2 = fucntion(a, b, c)
...

var x = eval.equ2(1, 1, -1);

Да, идея прикольная :).

Rumata wrote:

А также можно массив двух элементов трактовать как комплексное число, и т.д (-:.

И т.д., к сожалению, лень, но вот про массив из двух элементов добавил :).

Юрий Насретдинов

Rumata wrote:

self.neg = function()
    {
        return Complex.construct(-x, -y, r, r ? f + Math.PI : 0);
    };

Хехе :). А если f > 0, то у Вас получится, что новый аргумент выходит за границы (-pi, pi], что как бы не очень здорово (а при извлечении корня так вообще губительно).

Rumata

Юрий Насретдинов wrote:

И всё равно «не то»...

Я всячески не хотел делать вычисления компонентов (корни, квадраты, арктангенсы), поэтому у меня вылезло -f, когда надо было f+PI или f-PI. Или опять ошибка?

Юрий Насретдинов wrote:

если f > 0, то у Вас получится, что новый аргумен

Не выходит. Учтено изначально в Complex.construct.

Юрий Насретдинов

Rumata wrote:

Я всячески не хотел делать вычисления компонентов (корни, квадраты, арктангенсы), поэтому у меня вылезло -f, когда надо было f+PI или f-PI. Или опять ошибка?

Да, вроде бы теперь нормально, с учетом проверки в конструкторе.
В моем классе таких проблем чисто в принципе не возникло, потому что у меня в конструкторе значения r и f в основном синтезируются на основе x и y, а не считаются вручную :).

Rumata

Да. Когда я начал реализовывать свой класс, у меня возникла мысль, что неплохо бы вычислять сразу все части числа, тогда код усложняется ненамного, а преимущества видны сразу - инициализация объекта комплексного числа готовыми полями для исключения некоторых вычислений (например, при умножении используются модули и аргументы перемножаемых чисел). Насколько это оправдано, сказать сложно. Оба представления (x, y) и (r, f) - равнозначны и при выборе только одного представления неизбежна операция перевода из одного в другое. Ну а эта путаница - conj() и neg() была создана бездумным копированием и исправлением первого из второй.

Юрий Насретдинов

Rumata
«Но и это ещё не всё» ©

Нормализация аргумента сделана тоже некорректно :) (я это заметил, когда добавил нормализацию аргумента в свой конструктор)!

Смотрите:

Code (JavaScript):	скопировать код в буфер обмена
var a = new Z(0,0,1,2.5Math.PI); alert(a.toString(true)); var b = Complex.fromPolar(1,2.5Math.PI); alert( b.toString(true) );

Аргумент (правильный) должен быть PI/2. А в Вашей реализации это -PI/2, что соответствует смене знака у числа :). Я, поэтому, некоторую хитрость добавил:

Code (JavaScript):	скопировать код в буфер обмена
// normalize argument if(Math.abs(f) >= Math.PI) { f+=Math.PI; f-=Math.floor(f/2/Math.PI)2Math.PI; f-=Math.PI; }

Т.е. для нормализации сначала переводится к интервалу [0; 2*PI], потом аргумент нормализуется в таком интервале, а потом интервал возвращается обратно к [-PI, PI]. Границы эта вещь не учитывает, но ИМХО они не настолько важны, особенно в вычислительной технике.

Юрий Насретдинов

Добавил в класс также проверку на дифференцируемость функции комплексного переменного, а также на подсчет производной от этой функции в случае её дифференцируемости.

Пример:

Code (JavaScript):	скопировать код в буфер обмена
Z.prototype.tan = function() { return this.sin().div( this.cos() ); } var tp = new Z(3,5); // test point alert( tp.deriv('tan') + ' vs. ' + Z.ONE.div( tp.cos().pow(2,0) ) ); // ( tan(z) )' = 1 / (cos(z))^2 alert('Is complex conjugation differentiable: '+tp.is_diff('conj'));

Если Вы попытаетесь посчитать производную от функции, которая не дифференцируема в этой точке, выпадет исключение наподобие (Error: Cauchy-Riemann conditions for conj are not met (ux-vy=2, uy+vx=0) или The function ux of some_func is non-differentiable (left_der - right_der = ..., left_der = ..., right_der = ...) ). Готов выслушать ваши мнения по этому поводу :).

Rumata

Юрий Насретдинов wrote:

Но и это ещё не всё

	Разное :: JavaScript :: Форум dkLab и Denwer Forum Index	All times are GMT + 3 Hours Goto page 1, 2 Next
Page 1 of 2		Email to a Friend.