12월 사수자리

시력보호 USB??

12월 사수자리 — Sat, 14 Nov 2009 10:12:17 -0600

http://link.allblog.net/23630506/http://loved.pe.kr/entry/T-POWER-U-01

에 남긴 코멘트 내용..

저도 스칼라에너지에 대해선 처음 듣는것이라 생소해서 찾아봤습니다.

http://en.wikipedia.org/wiki/Scalar_field_theory_(pseudoscience)

몇가지 배운것은, scalar field 는 두개의 서로 상반된 phase 의 전자기장이 서로를 상쇄하면서 생기는 scalar bubble 때문에 시공간을 자유로이 통과할 수 있고, 3차원상의 에너지 보존 원리 (science) 를 우회함으로써 다른 차원에서 에너지를 끌어올 수 있다 (에너지 보존을 4차원의 시공간상에서 만족합니다. 이는 pseudoscience - 입증되지 않았음) 는 것이네요..

일단 해당 이론이 현재 까지는 받아들여지고 있지 않은게 맞구요. 전자기학에서는 서로 상쇄하는 전자기장을 내놓는다면 scalar bubble 이 생기는게 아니고, 그냥 서로 상쇄되고 만다.. 에너지 낭비일 뿐이다, 이렇게 설명을 하니까요.. 4차원에서의 에너지 보존도 받아들여지지 않은 내용입니다.

해당 이론에 대해서 뭐라고 하기 보다도, 제품 자체에 관해 잘 이해가 안 되는게..

1. 비디오를 보면 모니터를 통해서 스케일러 에너지가 전달이 된다고 나오는데요.. 위에 쓰신대로라면 usb 장치로 인식을 하지 않습니다. 즉, 드라이버가 컴퓨터에 없다는 것이지요. 이는 해당 장치가 컴퓨터와 커뮤니케이션 할 수 있는 방법이 없다는 것입니다. 어떻게 디스플레이의 신호를 바꿔서 스케일러 에너지가 나오게 될까요??

2. 컴퓨터에서 발생하는 전자파를 차단하고자 한다면, 컴퓨터에서 발생하는 전자파와 정확하게 파형이 반대로 되는 전자파를 발생해서 서로 상쇄해야할 텐데요, 그걸 모니터링해서 상쇄되는 파장을 발생하는 것은 불가능할 것 같네요. 아무래도 기기 자체에서 두개의 자장을 발생하는 장치가 들어 있을 것 같습니다. 그렇다면 전자파 차단 효과는 없다는....

본체 뒤에 꼽아야하는것은 안정적인 전원공급이 필요하기 때문인것 같습니다. 전자파 자체는 요즘은 다 lcd 를 사용하기 때문에 크게 문제가 되지는 않는다고 생각합니다. 다만 장시간 화면을 바라봄으로써 안구 건조증이나 시력감퇴가 더 큰 문제가 되겠지요. 이것또한 scalar energy 가 말하는 '힐링' 수준에서 치료될 수 있는게 아니라고 생각합니다.

오히려 eye strain 을 줄여주는 여러 안경류의 제품이 있으니 참고해시길 바랍니다..
http://gizmodo.com/5046530/lightning-review-gunnar-optiks-eye-strain+reducing-computer-glasses
http://gizmodo.com/5326261/wink-glasses-will-make-you-blink

DC 관광

12월 사수자리 — Wed, 22 Jul 2009 11:38:47 -0500

Lincoln Memorial 에서 바라본 Washington Monument

White house

제일 인상깊었던것은 Lincoln Memorial. 신전형태로 되어 있는것에 한번 놀라고, 안에는 오직 거대한 링컨이 모셔져 있다는 점에서 또 한번 놀랬음.

xkcd: estimation

12월 사수자리 — Sun, 19 Jul 2009 23:40:14 -0500

estimation

Too bad I almost forgot about this file copying estimation thing after switch to apple.

dropbox saved my life

12월 사수자리 — Wed, 08 Jul 2009 00:04:24 -0500

I used to be a big fan of <a href="http://www.getdropbox.com">dropbox</a>. And now I become much more than just a big fan; it just saved my life.

Basically I have a couple of computers here and there that I use everyday. I have one iMac in my computational lab, and one another iMac in my other lab office. I have a laptop that I carry everyday, and I have an iMac at home. You can easily imagine how much effort do I need to keep my files neat and accessible. I was using an rsync to do so. I had a script to do primitive syncing and duplication checking. But sometimes I just make mistake that I switched source and destination, and I had some newer files overwritten by older files, which practically drives me nuts.

And I've came across with dropbox. It is basically a web storage, however, it comes with a desktop client that monitors your filesystem and automatically sync files over the net whenever modifications are found in your file. What makes it even nicer is, it pushes the notification to all the computers that have dropbox desktop client and syncs the files. So, as soon as I change one file in my laptop, the file is get synced to all of my three iMacs plus to the web storage. It is pretty smooth.

Today, I made a mistake (yes, again); I've opened a file, which is important (yes, somehow, important files are frequently involved in mistakes), and started making changes. Over the course of editing, I realized I've deleted too many things. What can I do? If I had a time machine set up, I could go back to the older version pretty easily, but I didn't have my time machine set up in that computer. What can I do?

Like I told earlier, dropbox saved my life. It even keeps revisions!!

Dropbox is a web storage + version control. I can't imagine my life without dropbox anymore.

google app engine 체험기..

12월 사수자리 — Thu, 02 Jul 2009 00:46:36 -0500

현업에 종사하고 있지 않다 보니, 이런저런 아이디어들은 있는데, 쉽게 적용해 볼 수 있는 기회가 적다. 몇달이 넘도록 그냥 '해보고 싶은것' 목록에 남아 있는 한가지가 Google App Engine 사용해 보기 였다. 마침, 학과에서 자체 심포지움을 하는데, 나보고 발표자료의 초록 (abstract) 을 모아보도록 하였고, 이 기회에 초록 데이터베이스를, Google App Engine 을 이용해보면 좋겠다는 생각이 들었다.

Google App Engine 이 매력적인 이유는,
1. 초기 호스팅 비용이 들지 않는다. 어느정도 quota 안에서는 무료
2. appspot.com 무료 2차 도메인
3. 내가 좋아하는 Python 으로 웹프로그래밍을 할 수 있음
4. Python 웹 프레임웍인 django 와 호환이 됨

Google App Engine Launcher 라는 프로그램을 통해 기본 파일 구조를 생성하여, 로컬에서 구축/테스트 한 후, 서버로 업로드 하는 방식으로 개발이 진행된다. 기본적으로는 Google 자체 프레임웍을 사용하며, 원할 경우 수동으로 django 프레임웍을 사용할 수도 있다.

간단한 app 을 만들고 deploy 해 본 후 느낀점은,
1. 로컬 테스트 / 서버 deploy 하는 프로세스가 맘에 듦.
2. App Engine Launcher 의 데이터 베이스 도우미 및 deploy 도우미가 잘 작동함
3. 프레임웍은 아직 좀 원시적인듯
4. django 템플릿 엔진을 거의 그대로 사용하는듯

이상. 혹시 소스가 필요하신 분은 Github로..

good symfony slides

12월 사수자리 — Mon, 22 Jun 2009 01:15:56 -0500

http://www.symfonylab.com/symfony-conference-most-interesting-slides-ideas/

1. Symfony 2 by Fabien Potencier
2. Sympal – The flexible Symfony CMS by Jonathan H. Wage
3. What’s New In Doctrine by Jonathan H. Wage

sproutcore, first excercise

12월 사수자리 — Wed, 17 Jun 2009 00:06:53 -0500

Sproutcore is one of javascript MVC framework that takes care of client side UI like full-blown desktop application. So far, Sproutcore is used in Apple's otherinbox.

Ever since the library is open to public, I wanted to have an hands-on experience. And this post is about it.

I wanted to make a web-based queue checking page that takes my keyword and list all the jobs in the queue contains such keyword. Server-end is quite simple: grab output from system call "ssh server | grep keyword". However, build a front-end UI using sproutcore was little tricky. I wasn't even ambitious to make the UI fancier, but I ended up spending more than 6 hours, I guess.

One of the big drawback was lack of documentation. There are few examples available in their website, but they are just too simple, and API reference only have some obvious explanation. Sproutcore is a framework, so it works like a black box. In that sense, I think the main developer should provide comprehensive examples that shows various usage of the framework and utilities. They could also provide general overview on how things are intertwined so that a developers who use the framework can attain better insight on how to add functionality.

Javascript frameworks like Sproutcore and Cappuccino clearly draw lines between server-side backend and client-side frontend. No more template and other types of nasty distinction between view and model-controller layer in server-side language is needed once this takes off, which is a still big issue between web developers. To go there, I think, one thing is missing; visual layout editor. And people in 280north are working very hard to bring Atlas, a javascript visual layout editor for Cappuccino, public, so let's keep my hope on.

My source codes are uploaded to GitHub.

finding symmetric cycles in a graph

12월 사수자리 — Tue, 16 Jun 2009 00:57:21 -0500

So, here is a ligand for FKBP named, 1,3-DIPHENYL-1-PROPYL-1-(3,3-DIMETHYL-1,2- DIOXYPENTYL)-2-PIPERIDINE CARBOXYLATE. The thing I wanted to do was to find all symmetric cycles, so that I can restrict the rotation during my calculation. In this example, I'd like to find out two phenyl rings that have C22 and C16. The ring system that have N in it is not symmetrical, so my program should be able to discriminate this.

At first, I thought it could be done easily if I use some sort of graph library. After a quick research, I decided to try out networkx and python-graph, and finally decided to stick with networkx because it depends less amount of other library and seems more mature than ; however python-graph also looks decent and it's source code actually helped me later to figure out finding cycles in my graph.

I started read tutorial and making some testcases, and, then, realized it does not have a nice method to detecting cycles in a graph. The same was true for determining whether the cycle is symmetric or not. So, I have to come up with my own, although I've helped out by numerous discussions on the web.

Here's my version.

#!/usr/bin/env python
 
import networkx as nx
import time
import re
 
def ligand_topology(filename='testcases/sb3/sb3/sb3.rtf'):
    G = nx.LabeledGraph()
    f = open(filename, 'r')
    atm = {}
    for line in f.readlines():
        if line.startswith("ATOM"):
            entry = re.split('\s+', line)
            atm[entry[1]] = {'type': entry[2], 'charge': entry[3]}
        if line.startswith('BOND'):
            entry = re.split('\s+', line)
            G.add_node(entry[1], atm[entry[1]])
            G.add_node(entry[2], atm[entry[2]])
            G.add_edge(entry[1], entry[2])
    return G
    
def is_cycle(graph, source):
    def dfs(node):
        visited.append(node)
        for each in graph[node]:
            if (cycle):
                return 
            if graph.degree(each) < 2:
                continue
            if each not in visited:
                spanning_tree[node] = each
                dfs(each)
                nodes.append(each)
                if each != spanning_tree[source] and source in graph[each]:
                    cycle.append(each)
            if not cycle and node == source:
                while nodes: nodes.pop()
                pass
                #while cycle: cycle.pop()
                #while visited: visited.pop()
    
    visited = []
    cycle = []
    nodes = []
    spanning_tree = {}
    dfs(source)
    return nodes
 
def is_symmetric(graph, subgraph, nbunch):
    # this is not true, but i'll just skip when a ring has more than one entry point
    count = 0
    entry = None
    for n in subgraph:
        if graph.degree(n) is not subgraph.degree(n):
            count +=1
            entry = n
    if count > 1: return False
    
    # build distance list from the root element
    # TODO: currently, it only compares the atom types to determine whether it is symmetric. 
    # this is potential pot hole because if some kind of isomers are there, it will not able
    # to detect it.
    root = subgraph[entry].keys()[0]
    dist = {}
    for n in nbunch:
        if n == root: continue
        distance = nx.shortest_path_length(subgraph,root, n)
        if dist.has_key(distance): dist[distance].append(n)
        else: dist[distance] = [n]
    
    for d,nodes in dist.items():
        sub = None
        if len(nodes) < 2: continue
        for n in nodes:
            if sub == None: sub = set([x[0] for x in subgraph.neighbors(n)])
            else: 
                if sub != set([x[0] for x in subgraph.neighbors(n)]): return False
    
    return True
  
def find_all_cycles(graph, build=False):
    # remove all nodes that have only one connection
    degrees = {}
    for node in graph.nodes():
        degree = graph.degree(node)
        if degrees.has_key(degree): degrees[degree].append(node)
        else: degrees[degree] = [node]
    
    # find all cycles
    max_degree = max(degrees.keys())
    cycles = []
    for i in range(max_degree, 2, -1):
        for node in degrees[i]:
            cycle = set(is_cycle(graph, node))
            
            # uniqify cycles
            if cycle:
                uc = [node]
                for c in cycle:
                    u = set(is_cycle(graph, c))
                    if node not in u: continue
                    else: uc.append(c)
                h = G.subgraph(uc)
                s = set(nx.node_connected_component(h, node))
                if s not in cycles:
                    cycles.append(s)
    
    if build:
        tmp_cycles = []
        for cycle in cycles:
            h = nx.Graph()
            h.add_edges_from(graph.edges(cycle))
            tmp_cycles.append(h)
        cycles = tmp_cycles
                    
    return cycles
 
def find_all_sym_cycles(graph):
    cycles = find_all_cycles(graph)
    sym_cycles = []
    
    for cycle in cycles:
        h = nx.Graph()
        h.add_edges_from(graph.edges(cycle))
        is_sym = is_symmetric(graph, h, cycle)
        if is_sym:
            sym_cycles.append(h)
    
    return sym_cycles

 
if __name__ == '__main__':
    G = ligand_topology()
    # ubigraph server should already be running
    #G = nx.UbiGraph()
    
    cycles = find_all_sym_cycles(G)
    for cycle in cycles:
        print cycle.nodes()
        #['C22', 'C23', 'C26', 'C27', 'C24', 'C25', 'H32', 'H33', 'H30', 'H31', 'H34', 'C13']
        #['C20', 'C21', 'H29', 'H28', 'H25', 'H27', 'H26', 'C19', 'C18', 'C17', 'C16', 'C15']

So, basically two things:
1. find all cycles
2. determine whether the cycle is symmetric

The first one can be done by building depth-first-search (dfs) tree. If the dfs tree ended up having the root node that the tree is started from then the root node is one of element of the cycle. In my case, I've exhaustively tested each node whether the node is a component of a cycle. And I tried reduce cycles by finding intersecting nodes only. This was necessary because, for some nodes, dfs tree expanded to have non-cycle component nodes as well.

After every possible "unique" cycles are found, I needed to determine whether the cycle is symmetric. Uh, symmetric with respect to what? Right, now I need to know which edge can be used as a rotation axis. Thanks to the graph library, it has a subgraph method which returns a "connected" subgraph of given nodes. By just plugging in my cycle nodes, I got back a connected graph that have all the cyclic components plus one extra node that is not part of cycle; in fact this node is the node that connects the cycle and the rest of the graph. So the degree of the node in our overall graph and subgraph must be different, and the edge between the node and the root node can be used as a rotational axis.

Now, actual symmetry detection. I could have used a built-in method, which compares whether two graphs are isomorphic after defining graph on the left and graph on the right of the root. However, the problem is, my actual use-case is about atom, which makes two nodes identical if they are in same type (e.g. H11 node and H12 nodes are identical in that sense). So, I ended up just comparing atom types only after building a distance map starting from the root node.

Please bear with me that this is very rough work and I didn't know nothing about graph theory before. Any comments to improve this are welcome.

우리아이와 함께 만든 두번째 스크래치

12월 사수자리 — Sat, 30 May 2009 21:23:11 -0500

Learn more about this project

두번째 스크래치 프로젝트!
화면을 클릭하면 보트가 움직입니다. ^^;

p.s. 자바 애플릿이 가능한 브라우저가 필요합니다.

이미지가 Internet Explorer 에서만 안 보이는 경우..

12월 사수자리 — Sat, 30 May 2009 16:22:10 -0500

Internet Explorer 를 사용하십니까? 그렇담 위에 이미지가 보이십니까?
안보이신다구요? 그럼 firefox 로도 이 페이지를 열어보시죠.. 이미지가 보일 겁니다.

이 문제로 고민하기를 이틀..
결국 문제는 IE 의 경우 CMYK 모드로 저장된 이미지 파일을 표시하지 못 한다는 결론에 도달했습니다.
웹에 올리는 이미지는 RGB 모드로 저장합시다 (For dumbest IE...).

p.s. 혹시 크루즈 여행에 관심있으신 분은 여기로~