LINUX.ORG.RU

Преобразовать полярные координаты в декартовы

 , ,


0

1

Есть довольно простой алгоритм, известный, наверное, всем со школы.

http://ru.wikipedia.org/wiki/Полярные_координаты

def polar2cart(r,phi):
    x = r*math.cos(phi)
    y = r*math.sin(phi)
    return x,y

В питоне, кстати, в модуле cmath есть даже функции rect/polar, которые в принципе делают тоже самое. Но они это делают для этого числа. А мне надо в numpy для двух одномерных векторов... и на выходе получить двумерный вектор (всех возможных вариантов, декартово произведение). Можно, конечно, сделать тупо циклом for или генератором списков.

rs = numpy.arange(0,100)
phis = numpy.arange(0,math.pi,math.pi/360)

xs = [r*math.cos(phi) for r in rs for phi in phis]
ys = [r*math.sin(phi) for r in rs for phi in phis]

Но это наверное неэффективно?.. Можно как-то тоже самое сделать векторными операциями numpy?

Пробовал

xs = rs*numpy.cos(phis)
ys = rs*numpy.sin(phis)

но ругается, что размерность неправильная... На выходе мне надо получить два двухмерных массива numpy... чтобы они были xs.shape == (rs.shape, phis.shape) (ну то есть для примера выше 100x360)

Вариант с генератором списков работает, но наверное он не Ъ, и это скажется, если я увеличу размер выборки. :)

★★★★★

Последнее исправление: BattleCoder (всего исправлений: 1)

не совсем, но близко:

python> from cmath import polar
python> polar(1+1j)                                                                                                                                                                 
(1.4142135623730951, 0.7853981633974483)
anonymous
()
Ответ на: комментарий от anonymous

я же говорю, для массива не катит =) точнее, разницы нет. могу также в генератор списков запихнуть, да. а потом на основе создать numpy.array

смысл вопроса в том, можно ли вообще такое сделать средствами только векторных операций numpy? ну вот numpy.cos/sin я могу использовать, умножать вектора (покомпонентно) но этого мало.

надо умножить как-то не «покомпонентно» - а получить двумерный вектор, состоящий из декартовых произведений... ну и перемножить каждый его элемент так.

BattleCoder ★★★★★
() автор топика
Ответ на: комментарий от anonymous

к сожалению, в numpy ни rect, ни polar, нет =) а он бы тут был кстати

BattleCoder ★★★★★
() автор топика
import nympy as np
import matplotlib.pylab as pl

R,PHI=pl.meshgrid(np.arange(0,100), np.arange(0,np.pi,np.pi/360))

X,Y=R*np.cos(PHI), R*np.sin(PHI)

Оно?

yvv ★★☆
()
Ответ на: комментарий от aedeph_

Ты, видимо, только что узнал про перемножение матриц, и всем об этом успехе хочешь рассказать. Это классно. Но ТСу это не нужно. Ему, видимо, сетка нужна для каких-то целей.

yvv ★★☆
()
Ответ на: комментарий от yvv

Такие структуры, очевидно, нахер никому не нужны.

aedeph_ ★★
()
Ответ на: комментарий от yvv

Да нет, не сегодня, причём оттуда же, откуда и ты.

aedeph_ ★★
()
Ответ на: комментарий от aedeph_

так напиши то что знаешь, хоть будет понятно что хотел сказать. А то как мартышка, ссылку скопипэйстил и бросаешь людям. Нет оснований думать что тут многие глупее тебя или менее образованные.

nokachi
()
Ответ на: комментарий от nokachi
numpy.cos(phis).reshape((len(phis),1)) * rs

Как же нет оснований, когда лично ты прекрасно это показал? А ТСу и линка могло вполне хватить.

aedeph_ ★★
()
Последнее исправление: aedeph_ (всего исправлений: 1)
Ответ на: комментарий от nokachi

Как же нашёл бы, когда он за декартовым произведением полез зачем-то?

А ты ясно всё показал, ниасилив рассчитанную даже на чрезвычайно широкую аудиторию (это эвфемизм, если что) википедийную статью.

Откуда только такое быдло берется.

Сам удивляюсь, просто технический ресурс просрали, похоже что.

aedeph_ ★★
()

Вариант с генератором списков работает, но наверное он не Ъ, и это скажется, если я увеличу размер выборки. :)

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

AIv ★★★★★
()
Ответ на: комментарий от AIv

если правильно понимаю, ленивый генератор генерирует списки/кортежи питона... а они априори медленнее numpy-массивов, так же? для массива размером 100 разницы наверное не будет...

BattleCoder ★★★★★
() автор топика
Ответ на: комментарий от yvv

спасибо, кажется, оно =) проверю результат...

BattleCoder ★★★★★
() автор топика
Ответ на: комментарий от aedeph_

спасибо, про умножение матриц я знаю ;) нюанс в том, что я не знаю, как это сюда применить. мне не надо умножать две матрицы MxN и и NxK, и из этого получить матрицу MxK. Мне надо перемножить два вектора длин M и N, и получить матрицы MxN. Да, это похожее, но это же не умножение матриц..

BattleCoder ★★★★★
() автор топика
Ответ на: комментарий от aedeph_

да, нет. очень похоже на то, что мне нужно... видимо, этот meshgrid мне и был нужен. память мне не так уж жалко :) garbage collector же.

можно сравнить на больших выборках, какой вариант будет быстрее

BattleCoder ★★★★★
() автор топика
Ответ на: комментарий от BattleCoder

M*1 x 1*N == M*N

столбец на строка ( по процедуре сумма пар стока*столбец)

qulinxao ★★☆
()
Ответ на: комментарий от aedeph_

тьфу ты... %)

реформа образования ни при чём, это всё ночные посиделки за компом :( соображаю туго. и правда ступил.

BattleCoder ★★★★★
() автор топика
Ответ на: комментарий от aedeph_

Мда, реформа образования на лицо.

Иронию вы сами подтвердили. А налицо пока лишь правота Зигги.

anonymous
()
Ответ на: комментарий от anonymous

Да, я это и сам заметил. Правда, кто на лицо Зигги, я не в курсе.

aedeph_ ★★
()
Ответ на: комментарий от BattleCoder

Он подразумевал, что возможно в зависимости от твоей задачи тебе бессмысленно изначально генерировать два массива на 36000 элементов (что квадратично будет увеличиваться, при увеличении изначальных параметров), так как информация, нужная для их построения - это всего лишь 460 элементов что (будет увеличиваться линейно), и в случае, если они не будут использоваться на постоянной основе, это позволит тебе не занимать память, и не сильно скажется на производительности.

Без задачи это конечно лишние домысли.

aedeph_ ★★
()
Ответ на: комментарий от aedeph_

действительно, проверил - то, что требовалось. и как же до меня не дошло, что мне требовалось именно это умножение «строку на столбец», которое и делается в умножении матриц...

может и правда реформы виноваты :(

BattleCoder ★★★★★
() автор топика
Ответ на: комментарий от BattleCoder

«строку на столбец»

Это скалярное произведение, которое возвращает скаляр (матрицу 1x1).

А тебе нужно «столбец на строку».

Попробуй таки выспаться.

aedeph_ ★★
()
Ответ на: комментарий от BattleCoder

Для 100 нет. Для 10**10 - ленивцы кардинально быстрее;-)))

ЗЫ. А чего, это является узким местом? Почему Вы решили что именно эту часть надо оптимизировать? Потому что для 100 что на питоне что на Сях все довольно быстро.

AIv ★★★★★
()
Последнее исправление: AIv (всего исправлений: 1)
Ответ на: комментарий от AIv

исключительно из любопытства и с целью получше разобраться с numpy. узким местом не является (используется в скрипте построени графика, работает довольно быстро)... предварительные расчёты работают куда медленнее %) и там задействован openCL

BattleCoder ★★★★★
() автор топика
Ответ на: комментарий от anonymous

По-моему, это решение гораздо лучше, потому что это именно тот вызов, который решает задачу. Моё переформатирование array'я - лишние затраты.

aedeph_ ★★
()
Вы не можете добавлять комментарии в эту тему. Тема перемещена в архив.