넘파이 배열(ndarray) 의 팬시 색인은 정수 리스트(혹은 배열)를 이용하여 여러 개를 동시에 선택하는 방식이다. 인덱싱은 항상 0으로 시작한다는 것에 유의하자. MATLAB/SCILAB/OCTAVE 에 익숙한 사용자는 인덱스가 0에서 시작된다는 것에 주의해야 한다. 이후 예제에서는 넘파이가 다음과 같이 임포트되었다고 가정한다.

>>> import numpy as np

 예를 들어서 다음과 같은 a 행렬을 고려하자.


>>> a=np.arange(24).reshape((6,4))
>>> a
array([[ 0,  1,  2,  3],
      [ 4,  5,  6,  7],
      [ 8,  9, 10, 11],
      [12, 13, 14, 15],
      [16, 17, 18, 19],
      [20, 21, 22, 23]])

여기서 특정한 행들을 선택하고 싶다면 원하는 순서대로 행번호를 적은 리스트나 배열로 인덱싱하면 된다.

>>> a[[3,0,5]]
array([[12, 13, 14, 15],
      [ 0,  1,  2,  3],
      [20, 21, 22, 23]])

>>> a[[-1,-3,2]]
array([[20, 21, 22, 23],
      [12, 13, 14, 15],
      [ 8,  9, 10, 11]])


 한 가지 주의할 점은 슬라이싱과 다르게 이런 식으로 반환되는 배열은 복사된 것이라는 점이다. 즉, 원본과 연결되지 않은 복사 객체가 반환된다. 따라서 원본의 갱신과 무관하게 된다.

 또 한 가지 유의할 점이 있는데 다음과 같이 다중으로 인덱싱을 할 경우이다.

>>> a[:,[2,3]] #(1)
array([[ 2,  3],
      [ 6,  7],
      [10, 11],
      [14, 15],
      [18, 19],
      [22, 23]])

>>>  a[[0,1],[2,3]] # (2)
array([2, 7])


여기서 (1)에서와 같이 한 쪽이 모든 요소를 나타내는 콜론(:) 이 쓰인 경우는 해석이 쉽다. 즉, a 배열의 0번 열과 1번 열을 골라내는 것이다. 그런데 (2)의 경우는 MATLAB에 익숙하던 사용자라면 좀 의아할 것이다. 다음 표와 같이 0행, 1행과 2열, 3열이 겹치는 부분인 2x2 행렬이 반환된다고 오해하기 쉽기 때문이다.

2열

3열

0행

0

1

2

3

1행

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

실제 동작은 (0,2) 요소와 (1,3)요소 두 개를 반환한다.

 MATLAB과 같이 그리드 점에 있는 요소들의 집합인 2x2 행렬을 반환하게 하려면 np.ix_() 함수에 팬시 색인을 넘겨주어야 한다.

>>> a[np.ix_([0,1],[2,3])]
array([[2, 3],
      [6, 7]])


이것은 사실 a[ [0,1] ][ :, [2,3] ] 과 같은 동작을 취한다.

 그리고 a[1,2] 와 a[1][2] 는 같은 요소를 가리킨다.

>>>  a[1,2]
6

>> a[1][2]
6


하지만 이것으로 두 인덱싱이 같은 표현법이라고 오해하면 안 된다. 사실은 전혀 다르기 때문이다. 예를 들면 다음과 같다.

>>> a[:,2] # 2번 열만 뽑아낸다.
array([ 2,  6, 10, 14, 18, 22])

>>> a[:][2] # 이것은 a[2]와 같다.
Out[41]: array([ 8,  9, 10, 11])

>>> a[ [-1,-2], 1 ]
array([21, 17])

>>> a[[-1,-2]][1]
array([16, 17, 18, 19])


마지막 예에서 a[[-1,-2]][1] 은 a[[-1,-2]] 행렬의 1번째 행을 뽑아내는 것이다. a[[-1,-2], 1] 과는 완전히 다르다.




Posted by 살레시오
,

 러플(RUR-PLE, RUR - Python Learning Environment)은 파이썬을 이용한 교용용 프로그래밍 언어 환경이다. 사용자는 명령을 통해 화면에 있는 로봇을 움직이며 프로그램잉의 개념에 대해 학습을 할 수 있다.



러플의 특징은 다음과 같다. 프로그래밍을 처음 접하는 학생들에게 추상적인 수치를 다루는 내용보다는 간단한 명령의 조합을 통해 눈에 보이는 로봇을 조작함으로써 프로그래밍을 보다 쉽게 이해할 수 있도록 한다. 사용 문법은 초보자도 쉽게 익힐 수 있을 정도로 간단하지만 강력한 기능을 지원하고 다양한 분야에 이용되는 파이썬 언어를 학습할 수 있다. 혼자서도 학습할 수 있는 튜토리얼이 많다. 파이썬을 별도로 설치하지 않아도 기본적으로 파이썬 쉘과 에디터를 제공한다.



그리고 다양한 운영체제에서 실행할 수 있는 배포판을 제공한다.


 개인적으로 스크래치와 함께 프로그래밍의 개념을 학습할 수 있는 좋은 도구라고 생각된다.



Posted by 살레시오
,

 파이썬 3.4 이상에서 표준화된 Enum객체를 지원한다. 자세한 설명은 여기에 있다. 간략한 사용법을 알아보도록 하자.


 일단 Enum 클래스를 임포트해야 한다.


>>> from enum import Enum


첫 번째로 다음과 같이 클래스를 Enum을 상속해서 생성할 수 있다.


>>> class Color(Enum):
...     red = 1
...     green = 2
...     blue = 3


이제 Color.red 또는 Color.green 과 같이 사용할 수 있다. 첫 번째 값은 보통 1부터 시작한다. (0으로 시작하면 그 필드는 False가 된다.)


 다른 방법으로 다음과 같이 더 간단히 생성할 수 있다.


>>> Color = Enum('Color', 'red green blue')


유의할 점은 인스턴스 이름과  Enum생성자의 첫 인자가 (위에서 밑줄 쳐진 두 부분) 같아야 한다. 이제 이전과 마찬가지로 Color.red 또는 Color.green 과 같이 사용할 수 있다.


enum 필드는 name과 value를 가진다. 예를 들어 Color.blue 의 name 은 'blue' value 는 3 이다.


>>> Color.blue.name
'blue'

>>> Color.blue.value
3

>>> type(Color.blue)
<enum 'Color'>



Posted by 살레시오
,

 파이썬에서 심볼릭 (symbolic) 수학을 지원하는 sympy 라는 모듈이 있다. winPython을 사용한다면 기본적으로 설치되어 있으므로 사용하고 싶다면


>>> import sympy as sp

라고 하면 된다. 흥미로운 것은 수학 계산식을 LaTex 스타일로 깔끔하게 표시할 수 있다. 이를 위해서는 다음과 같은 이 모듈 내의 함수를 호출하면 된다.

>>> sp.init_printing() # 수식을 LaTex 스타일로 표시한다.


만약 배경색을 검은 색으로 사용하고 있다면 다음과 같이 글자색을 흰색으로 지정해 줄 수 있다.


>>> sp.init_printing(forecolor='White')

이 함수를 맨 처음 실행시킬 때는 별도의 패키지를 인스톨하라는 대화창이 뜨며 한 번만 인스톨해주면 된다. 이렇게 하면 이후에 수학식이 LaTex 스타일로 굉장히 깔끔하게 표시된다. 예를 들면 아래와 같다.


유니코드를 사용하여 수식을 표시하는 함수로 pprint()가 있다. 만약 아스키코드로만 표시하고 싶다면 use_unicode = False 옵션을 주면 된다.


>>> expr = sp.sqrt(x/(x**2+1))+sp.pi
>>> sp.pprint(expr) # 유니코드를 이용하여 수식 표시
         ________    
       ╱   x        
     ╱  ──────  + π
   ╱    2         
╲╱    x  + 1     
>>> sp.pprint(expr,use_unicode=False) #아스키코드로 수식 표시
    ________     
   /   x         
  /  ------  + pi
 /    2          
\/    x  + 1      


 그런데 sympy 에는 init_session() 이라는 함수가 있는데 이 함수의 옵션으로 ipython=True 를 주면 sympy 모듈이 전역 공간으로 임포트되며 LaTeX 모드가 활성화된다.

init_session()함수를 호출하면 내부에서 from sympy import * 가 수행되므로 이 모듈의 모든 함수/변수가 전역 공간에 올라온다. 따라서 이후에는 ipython 콘솔을 sympy 위주의 쉘로 활용할 수 있다.

다른 방법으로 위와 같이 명령어로 입력하지 않고 설정창에서 지정해 줄 수 있다.


만약 sympy 위주로 쉘을 사용하고 싶다면 이 옵션을 지정해 주는 것도 좋을 것이다.

하지만 sympy 도 다른 모듈들(numpy 등)과 구분하여 사용하고 싶다면 맨 처음에 소개한 명령어를 사용하는 것이 좋다.

>>> import sympy as sp
>>> sp.init_printing() # LaTex 스타일로 수식 표시

 ipython의 매직 명령어인 %matplotlib inline 이라고 하면 ipython 창에 그래프를 그려준다.


>>> %matplotlib [gui]


여기서 [gui] 옵션으로 inline, gtk4, qt4 등을 줄 수 있으며 inline 을 주면 ipython 창 내부에 그래프를 도시해 준다. 이후에 예를 들어 sympy.plot() 함수 등을 사용하면 ipython 내부 창에 그래프를 띄워준다.

 만약 초기에 이러한 설정으로 시작하고 싶다면 옵션으로 지정하여 ipython 창이 생성될 때 자동으로 설정되도록 할 수 있다. 아래 그림과 같이 Support for graphics (Matplotlib) 항목 내의 Active support 를 체크하면 ipython 이 시작될 때 그래프 기능을 활성화시킨다.

단 이 옵션은 자동으로 numpy 와 matplotlib.pyplot 모듈을 np, plt 이름으로 임포트시킨다. 이것은 dir() 명령으로 확인할 수 있다.


 두 번째 항목인 automatically load pylab 은 비활성화시키기를 권장한다. pylab 은 내부에서 numpy와 matplotlib.pyplot 등의 모듈들을 전역공간으로 임포트하여 함수들을 관리하는데 혼동을 주기 때문이다.



Posted by 살레시오
,

1. 개요

 상미분방정식(이하 상미방)의 수치 적분을 수행하기 위해서 scipy.integrate.odeint 함수의 사용법에 대해서 알아보도록 하겠다. scipy.integrate 클래스는 적분을 수행하는 다양한 함수들이 모여 있는데 그 중 연립 상미방의 수치적분을 구하는 ode, odeint, complex_ode 함수들이 마련되어 있다.

 

  • odeint             : 상미방의 수치적분

  • ode                : 상미방의 수치적분 (generic interface class)

  • complex_ode  : 복소 상미방의 수치적분

 

이중 odeint 는 내부적으로 FORTRAN 라이브러리인 odepack 의 'lsoda'를 사용하여 상미방을 풀어내는 함수이다. 이 함수는 (연립) 상미분 방정식

  • y' = f ( y, t )

의 수치해를 구해주며 stiff ode 와 non-stiff ode 모두에 적용된다.

2. 기본 문법


 일단 레퍼런스의 함수 문법은 다음과 같다.


y, infodic = scipy.integrate.odeint (
   func,# callable(y, t, ...) : 시간 t 에서 y(t)의 미분값을 구할 수 있는 함수
   y0,  # array_like : y 의 초기 조건 (벡터도 된다.)
   t,   # array_like : y(t)값을 구할 t 점들. 초기값의 시간이 이 배열의 첫 요소여야 함.
   args=()  # 튜플 : func() 에 넘길 추가적인 인수들
   Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None,
   tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12,
   mxords=5, printmessg=0
)

 

여기서 필수적인 인수는 func, y0, t 세 개이며 각각 ODE함수, 초기값, 시간(벡터)이다. 나머지 인수들은 모두 선택적으로 지정해 줄 수 있으며 지정하지 않으면 설정값이 사용된다. 그리고 y0와 t는 리스트, 튜플, ndarray (이것들을 묶어서 array_like 라고 한다.) 등이 될 수 있다.

 이 함수를 사용하기 전에 먼저 상미방을 기술하는 함수를 먼저 정의해야 한다. 이 함수는 array_like 를 반환해야 하며 ndarray y와 시간 t 를 받아서 그 미분을 구하는 함수이다.

 odeint() 함수의 출력 y는 배열(ndarray) 이고 shape 이 ( len(t), len(y0) ) 이며 2차 배열이다. 입력으로 넘어온 t 배열의 각 점에서의 y값들을 갖는다. 두 번째 출력인 infodict 는 full_output== True 로 지정되었을 경우 추가적인 정보가 넘어오게 된다.

3. 간단한 1차 ode 예제

 다음과 같이 가장 간단한 1차 미방을 시간 구간 [0, 5] 에서 수치해를 구하는 예제를 해 보도록 하겠다.


  • y' =  -2y, y(0)=1

위 예제에서는 pylab 모듈에 numpy가 포함되어 있으므로 따로 numpy는 import하지 않았다.

4. 2차 ode : 조화진동자

  조화 진동자 방정식은 2차 상미방으로서 x''(t) = -x(t) 이다. 2차 방정식은 두 개의 1차 방정식으로 분해할 수 있다. 즉, y(t) = [ x(t) ; x'(t) ] =: [y1(t); y2(t)] 라고 정의하면

              y'(t) = [x'(t); -x(t)] = [y2(t); -y1(t)]

와 같이 기술할 수 있다. 초기값이 [0; 1] 일 경우 시간 [0, 5]에 대해서 이 상미방을 풀면 다음과 같다. 이 예제에서는 ode1()함수의 반환값도 튜플이고 odeint()함수의 초기값도 튜플로 주었다.


Posted by 살레시오
,

 기울기 센서는 디지털형과 아날로그형으로 나뉜다. 디지털형은 일정한 각도 이상으로 기울어지면 신호가 바뀌는 것이고 (저가형 아두이노 모듈이 많이 있다.) 아날로그형은 기울어진 각도를 얻을 수 있는 소자이다.

 아날로그형 기울기센서 중에 SCA61T-FA1HiG 라는 모델명의 센서를 사 둔 것이 있었는데 꺼내서 비글본블랙(이하 BBB)의 아날로그핀에 물려서 실험을 해 보았다.

   

[그림 1] 기울기 센서의 외형과 핀 기능

이 그림에서 보듯 8핀 소자인데 5V를 입력으로 받는다. SPI 통신 또는 아날로그 전압값(7번 핀) 두 가지를 모두 얻을 수 있는데 아날로그 전압은 0도 일 경우 2.5V를 내고 각도에 따라서 0V~5V 사이의 전압값을 가진다.

[그림 2] 센서의 동작 방식


그런데 한 가지 문제가 있는데 BBB의 아날로그 핀은 1.8V 가 최대 허용 전압이므로 직결해서 사용할 수는 없다. 그래서 저항 두 개로 이루어진 간단한 전압 분배 회로를 이용하였다.

[그림 3] 전압 분배 회로


이 그림에서 7번 핀이 5V 즉, 최대 전압일 때 AIN0 단자가 1.8V 이도록 저항 x, y가 선택되어야 한다. 이것을 공식을 세워보면 다음과 같다.

이 식에서 저항 x, y의 관계식이 얻어진다. 먼저 x=910 으로 먼저 선정한 후 이 식에 의해서 y=510오옴으로 선택했다. 저항은 소모 전력을 고려하여 선정해야 한다. 이 경우 OUT핀이 5V일 때 5/(910+510)  = 3.5 mA 정도가 흐르게 된다.

 파이썬 코드는 0.01초(10ms)마다 한 번씩 ADC를 수행해서 화면에 보여주도록 하는 간단한 프로그램이다. PyBBIO 모듈을 이용하였다.


from bbio import *
import time
bbio_init()
while True:
   print(analogRead(AIN0))
   time.sleep(0.01)
bbio_cleanup()

analogRead()함수는 ADC된 전압을 mV 단위로 반환한다. 예를 들면 1.8V 일때는 1800을, 0.9V 일때는 900을 반환한다. 이 값을 읽어서 스케일링을 하면 기울어진 각도를 계산할 수 있다.

실험 동영상을 만들어 보았다.



Posted by 살레시오
,

 만약 x, y가 심볼로 등록이 되어 있다면 함수 y(x)의 x에 대한 미분은 sympy에서 다음과 같이 표현할 수 있다.


  • y(x) : 독립 변수 x에 대한 함수 y

  • y(x).diff() 혹은 y(x).diff(x,1) : 1차 미분

  • y(x).diff(x,2) : 2차 미분

  • y(x).diff(x,3) : 3차 미분


이것을 이용하면 상미분식을 표현할 수 있다. 예를 들면 다음과 같다.


[표 1] 미분식의 심파이 표현식 예

수식

심파이 표현식

y(x).diff() - cos(x)

y(x).diff(x,2) + 9*y(x) - exp(-2*x)

y(x).diff()-1-y(x)**2


함수를 표현할 때 y(x)와 같이 독립변수도 반드시 표기해야 함을 유의하자.


 dsolve()함수는 미분방정식을 풀어주는 sympy의 기본 함수이다. 첫 번째 인자로 미분식을, 두 번째 인자로 구할 함수를 적어주면 된다. 예를 들어서 다음과 같은 1차 상미방을 푼다고 가정하자.



이 미분방정식의 우변을 0으로 만들면 다음과 같다.



이제 dsolve 함수의 첫 번째 인자로 위 식의 좌변을 넣어주고 두 번째 인자로 y(x)를 인가하면 된다.



여기서 C1은 상수이다.  다른 미분 방정식을 풀어보자.



이 방정식도 우변을 먼저 0으로 만들어야 한다.



이제 이 식의 좌변을 dsolve()함수의 첫 번째 인자로 넣어준다.



2차 미분방정식도 입력할 수 있다. 예를 들어



을 풀려면 다음과 같이 하면 된다.



만약 함수의 미분표현식을 매번 입력하기 번거롭다면 다음과 같이 새로 정의하여 사용하면 된다.



이렇게 정의해 놓으면 이후부터는 y(x).diff() 대신 dy를, y(x).diff(x,2) 와 같이 긴 표현식 대신 ddy를 사용하면된다.



여기서 C1과 C2는 상수이다. 이것이 dsolve()함수를 이용한 미분방정식을 푸는 가장 기본적인 방법이다.



Posted by 살레시오
,

 심파이에서 행렬객체에 수행할 수 있는 선형대수 관련 연산을 다음 표에 정리하엿다.


[표 1] 선형대수 연산

연산

기능

A.T

A.H

A.D

전치행렬(transposition)

복소전치행렬(hermite conjugation)

Dirac transposition

A.rank()

행렬의 랭크(rank)

A.det()

행렬식 (determinant)

A.inv()

역행렬 (inverse matrix)

A.LUsolve(b)

행렬방정식 Ax=b 를 푼다.

A.norm()

norm을 구한다.

A.eigenvals(**flags)

A.eigenvects(**flag)

행렬의 고유값을 구한다.

행렬의 고유값과 고유벡터를 구한다.

A.evalf()

행렬 각 요소의 실수 근사값을 구한다.

A.applyfunc(f)

행렬 각 요소에 함수 f를 적용한다.


숫자로만 이루어진 행렬뿐만 아니라 대수 기호가 포함된 행렬에 대한 연산도 수행 가능하다.


>>> x=symbols('x') # x 를 기호로 설정
>>> C=Matrix([[x,2],[1,x]])
>>> D=ones(2)*x

>>> C
[x  2]
[1  x]

>>> D
[x  x]
[x  x]

>>> C.det()
2    
x  - 2

>>> C*D
[  2             2   ]
[x  + 2*x  x  + 2*x  ]
[   2           2    ]
[ x  + x    x  + x   ]


만약 대수 기호 대신에 숫자를 입력하고 싶다면 subs() 메쏘드를 이용한다.


>>> C.subs(x,11)
[11  2 ]
[1   11]

>>> y=symbols('y')

>>> D.subs(x,y**2+1)
[ 2       2    ]
[y  + 1  y  + 1]
[ 2       2    ]
[y  + 1  y  + 1]

>>> D.subs(x,sqrt(y))
[  ___    ___     ]
[\/ y     \/ y    ]
[  ___    ___     ]
[\/ y     \/ y    ]




Posted by 살레시오
,

 행렬 간 산술 연산은 +, -, *, ** 연산자로 수행할 수 있다. *은 행렬 간 곱셈을, **은 거듭제곱을 수행한다.


[표 1] 행렬의 기본 연산

연산

기능

A+B, A-B

행렬간 덧셈, 뺄셈

A*B

행렬간 곱셈 (A의 열 수와 B의 행 수가 같아야 한다.0

A**k

행렬 A의 k 거듭 제곱

v1.dot(v2)

벡터 v1과 v2의 내적(dot product)


덧셈과 곱셈은 두 행렬의 크기가 같아야 하고 행렬 간 곱셈은 차수 조건에 맞아야 한다. 즉, 첫 번째 행렬의 열 수와 두 번재 행렬의 행 수가 같아야 곱셈이 성립한다.


>>> A=randMatrix(3,4)
>>> B=randMatrix(4,2)

>>> A
[2   48  28  60]
[2   9   18  88]
[79  14  17  25]

>>> B
[10  49]
[47  95]
[18  67]
[60  59]

>>> A*B   
[6380  10074]
[6047  7351 ]
[3254  7815 ]

>>> B*A # 오류발생


 파이썬에서 **가 거듭제곱 연산자이므로 심파이에서도 행렬의 거듭제곱은 ** 연산자로 수행한다. 거듭제곱을 수행하려면 행렬이 정방행렬이어야 한다.


>>>  A=Matrix([[1,2],[2,3]])
⎡1  2⎤
⎣2  3⎦

>>> A**10
⎡514229  832040 ⎤
⎣832040  1346269⎦



Posted by 살레시오
,

  행렬 객체에 대해서 파이썬 인덱싱과 슬라이싱도 사용할 수 있다. 주의할 점은 수학의 행렬은 1행, 1열부터 시작하지만 Matrix객체는 인덱스가 0으로 부터 시작한다는 점이다. 따라서 첫 번째 행(열)의 인덱스는 0이고 두 번째 행(열)의 인덱스는 1이다.


>>> M = Matrix(2, 3, [1,2,3,4,5,6])
>>> M
[1 2 3]
[4 5 6]

>>> M[4] # 5
>>> M[1,2] # 6
>>> M[0,0] # 1
>>> M[1,1] # 5

>>> M[0:2, 0:2] # 2x2 부분 행렬
>>> M[1:2, 2]
>>> M[:,2] # 3열 전체


특정한 행이나 열을 뽑아내고 싶다면 row(n), col(n) 멤버 함수를 이용한다.


>>> M.row(0)
>>> M.col(2)
>>> M.row(-1) # 마지막 행을 뽑아낸다.


행렬 M의 복사본을 생성하고 싶다면 다음과 같이 하면 된다.


>>> M2 = M[:,:]
>>> M2[0,0]=100
>>> M


이와 같이 M2를 변경해도 M에는 영향을 미치지 않는다.


>>> M = Matrix(4,4,range(1,17))
⎡1   2   3   4 ⎤
⎢5   6   7   8 ⎥
⎢9   10  11  12⎥
⎣13  14  15  16⎦

>>> M[2,2] = M[0,3] = 0
>>> M
⎡1   2   3   0 ⎤
⎢5   6   7   8 ⎥
⎢9   10  0   12⎥
⎣13  14  15  16⎦

>>> M[2:, 2:] = zeros(2,2)
>>> M
⎡1   2   3  4⎤
⎢5   6   7  8⎥
⎢9   10  0  0⎥
⎣13  14  0  0⎦


행렬의 특정 행이나 열을 삭제하고 싶을 경우는 row_del(), col_del() 멤버함수를 이용하면 된다.


>>> M.row_del(0) # 첫 번째 행을 삭제한다.
>>> M.col_del(1) # 첫 번째 열을 삭제한다.


반대로 특정한 행이나 열을 끼워 넣고 싶다면 row_insert(n), col_insert(n) 을 이용한다. 이 경우 기존 행렬의 요소들을 밀어내고 그 위치에 입력한 행이나 열을 끼워 넣게 된다.


 그리고 A.row_join(B) 는 A행렬의 오른편에 B행렬을 병합시키고 A.col_join(B)는 A행렬의 하단에 B행렬을 병합시킨다.


>>> A=eye(3)
>>> A
⎡1  0  0⎤
⎢0  1  0⎥
⎣0  0  1⎦

>>> B=Matrix(3,2,range(11,17))
>>> B
⎡11  12⎤
⎢13  14⎥
⎣15  16⎦

>>> A.row_join(B)
⎡1  0  0  11  12⎤
⎢0  1  0  13  14⎥
⎣0  0  1  15  16⎦

>>> A.col_join(B.T)
⎡1   0   0 ⎤
⎢0   1   0 ⎥
⎢0   0   1 ⎥
⎢11  13  15⎥
⎣12  14  16⎦


또한 행렬객체의 메쏘드 중에 extract()라는 함수가 있다. 이것을 이용해서 원하는 부분을 뽑아낼 수 있다.


>>> A.extract(rowsList, colsList)


예를 들면 다음과 같다.


>>> M=Matrix(4,3,range(12))
>>> M
⎡0  1   2 ⎤
⎢3  4   5 ⎥
⎢6  7   8 ⎥
⎣9  10  11⎦

>>> M.extract([0,1,3],[0,1])
⎡0  1 ⎤
⎢3  4 ⎥
⎣9  10⎦


이 예를 보면 [0행, 1행, 3행] 과 [0열, 1열]이 겹치는 부부만 뽑아져 나온 것을 알 수 있다. 해당 행과 열에 선을 그어서 선이 겹치는 부분을 확인해 보면 쉽게 이해할 수 있을 것이다.



Posted by 살레시오
,