Magical Dorothy

방학은 알차게..

(dr.Dorothy) — Wed, 01 Jul 2009 01:54:14 +0900

방학동안 놀면 뭐하나..
공부나 해야지~

이번 방학의 목표는..!!
저 두권 먼저 마스터..ㅋㅋㅋㅋ

아~ 요리 후 먹는 밥은 너무 맛있는 듯..ㅎㅎ

이제 음식에 걸맞는 식기랑 담는 기법들좀 같이 공부해야지..ㅎㅎ
(다이어트 중인 현실의 모습은 우선순위를 아주 조금 내려놔야 겠당..ㅋ)

생각해보니..
어디서 상자좀 구해다가 새싹이나 좀 길러볼까..!?
매번 사러 나가기도 귀찮고...
농약 걱정 안해도 되니 더 좋은건가!?..(꼼꼼히 씻기가 귀찮어..ㅜ_ㅜ)

방학 시작은 무난히..

(dr.Dorothy) — Tue, 23 Jun 2009 01:04:32 +0900

허허허...
SP도 끝나고..
이제 기분좋게 방학을 시작.. ㅠ_ㅠ (감동..)

숙제 다한 기념 스샷 한방....

흠.. 토탈 라인수 4203줄... ㅡ_ㅡ.......
어쩐지.. 손가락이 아프더라..
손가락 찜질이라도 해야징..

Neural Net을 이용한 숫자인식 프로그램

(dr.Dorothy) — Wed, 17 Jun 2009 14:41:30 +0900

인공지능 마지막 숙제...

NumberSet.h

NeuralNet.c

Neural Net.hwp

뭔가 새로운 분야였지만...
막상.. 어찌 응용을 해야할지 ㅡ_ㅡ;;......
이것과 시스템은 어떻게 연결 할 수 있을까 ㅡ_ㅡ.........

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

#include "NumberSet.h"
TRAININGSET g_trainingSet[MAX_DATA]; // 트레이닝 데이터

// 전체 뉴런 개수 설정
#define INPUT_NEURON		32
#define HIDDEN_NEURON		20
#define OUTPUT_NEURON		10

// 인풋에서 히든, 히든에서 출력 레이어 그래프 (바이어스도 포함)
double g_weight_i2h[INPUT_NEURON+1][HIDDEN_NEURON];
double g_weight_h2o[HIDDEN_NEURON+1][OUTPUT_NEURON];

/* 내부 그래프용 노드 */
double g_inputs[INPUT_NEURON]  = {0,};
double g_hidden[HIDDEN_NEURON] = {0,};
double g_desire[OUTPUT_NEURON] = {0,};
double g_output[OUTPUT_NEURON] = {0,};

/* Unit Errors */
double g_err_output[OUTPUT_NEURON] = {0,};
double g_err_hidden[HIDDEN_NEURON] = {0,};

// 학습률 - c값
#define LEARN_RATE		0.2

// 시그모이드 함수 & 편미분 함수
double sigmoid( double val )           { return (1.0 / (1.0 + exp(-val))); }
double sigmoidDerivative( double val ) { return ( val * (1.0 - val) ); }

// 랜덤한 가중치 부여
void RandomWeight( void ) {
	int hidden, input, out;
	#define RAND_WEIGHT	(((float)rand() / (float)RAND_MAX) - 0.5)

	for (input=0; input < INPUT_NEURON+1; input++)
		for (hidden=0; hidden < HIDDEN_NEURON; hidden++)
			g_weight_i2h[input][hidden] = RAND_WEIGHT;

	for (hidden = 0 ; hidden < HIDDEN_NEURON+1 ; hidden++)
		for (out = 0 ; out < OUTPUT_NEURON ; out++)
			g_weight_h2o[hidden][out] = RAND_WEIGHT;
}

// 각 뉴럴의 실제 계산 및 전달 (현재 뉴럴의 최종 아웃풋이 g_output에 저장됨)
void feedForward( void )
{
	double sum;
	int input, hidden, out;

	// 인풋에서 히든레이어 계산
	for (hidden=0; hidden < HIDDEN_NEURON; hidden++)
	{
		// 각 뉴런의 inputs * weight의 총 합을 계산
		for (sum=.0, input=0; input < INPUT_NEURON; input++)
			sum += g_inputs[input] * g_weight_i2h[input][hidden];

		sum += g_weight_i2h[INPUT_NEURON][hidden]; // 바이어스
		g_hidden[hidden] = sigmoid(sum); // 시그모이드 함수 적용
	}

	// 히든에서 출력레이어 계산
	for (out=0; out < OUTPUT_NEURON; out++)
	{
		// 각 뉴런의 hidden * weight의 총 합을 계산
		for (sum=.0,hidden=0; hidden < HIDDEN_NEURON; hidden++)
			sum += g_hidden[hidden] * g_weight_h2o[hidden][out];

		sum += g_weight_h2o[HIDDEN_NEURON][out]; // 바이어스
		g_output[out] = sigmoid( sum ); // 시그모이드 함수 적용
	}
}

// 오차 수집후 가중치 조율
void backPropagate( void )
{
	int input, hidden, out;

	// 출력의 에러 콜렉팅
	for (out=0; out < OUTPUT_NEURON; out++)

		// Desire 값과 실제 나온 값의 차를 결과의 미분값으로 곱함
		g_err_output[out] = (g_desire[out] - g_output[out]) * sigmoidDerivative(g_output[out]);

	// 히든의 에러 콜렉팅
	for (hidden=0; hidden < HIDDEN_NEURON; hidden++)
	{
		g_err_hidden[hidden] = .0;

		// 먼저 출력의 에러를 가중치를 곱하여 모두 합산
		for (out=0; out < OUTPUT_NEURON; out++)
			g_err_hidden[hidden] += g_err_output[out] * g_weight_h2o[hidden][out];

		// 출력에서와 같은 방식으로 합산된것을 히든의 결과값의 미분값을 넣음
		g_err_hidden[hidden] *= sigmoidDerivative( g_hidden[hidden] );
	}

	// 출력의 가중치 조정
	for (out=0; out < OUTPUT_NEURON; out++)
	{
		// 새로운 가중치는 출력의 에러에 히든의 값을 곱하여 LEARN RATE 만큼 적용하여 더함
		for (hidden=0; hidden < HIDDEN_NEURON; hidden++)
			g_weight_h2o[hidden][out] += LEARN_RATE * g_err_output[out] * g_hidden[hidden];

		g_weight_h2o[HIDDEN_NEURON][out] += LEARN_RATE * g_err_output[out]; // 바이어스
	}

	// 히든의 가중치 조정
	for (hidden=0; hidden < HIDDEN_NEURON; hidden++)
	{
		// 출력과 동일 히든의 에러에 실제넣은값을 곱하여 LEARN RATE 만큼 적용하여 더함
		for (input=0; input < INPUT_NEURON; input++)
			g_weight_i2h[input][hidden] += LEARN_RATE * g_err_hidden[hidden] * g_inputs[input];

		g_weight_i2h[INPUT_NEURON][hidden] += LEARN_RATE * g_err_hidden[hidden]; // 바이어스
	}
}

// 가장 정답에 가까운거 집어내기
int select( double *array )
{
	int i, index=0;
	double max = array[index];

	for (i=1; i < OUTPUT_NEURON; i++) // 답은 찾아야 할테니..
		if (array[i] > max)
			max = array[i], index = i;

	return index;
}

// 실제 프로그램 시작
int main(void)
{
	double err;
	int i,j, training=0, loop=0;
	unsigned int temp;
	char test[33] = " 11 1  11  1   1   1  1  1  1111"; // 임의의 문자..

	srand( (unsigned) time(NULL) );
	RandomWeight(); // 랜덤한 가중치 부여

	// 트레이닝 데이터 초기화
	for (i=0; i<10; i++) {
		for (j=0; j<MAX_TYPES; j++) {
			g_trainingSet[i*MAX_TYPES+j].RealNum = i;
			g_trainingSet[i*MAX_TYPES+j].data = char2bit(Number[i][j]);
			for (temp=0; temp<INPUT_NEURON; temp++)
				g_trainingSet[i*MAX_TYPES+j].desire[temp] = (temp == i) ? 1 : 0;
		}
	}

	// 훈련 시작
	for (loop=0; loop < 0x0000ffff; loop++)
	{
		// 한바퀴 돌았으면 트레이닝 데이터 섞기
		if (++training == MAX_DATA)
			for (training=0, i=MAX_DATA-1; i>0; i--)
				swap(&g_trainingSet[i], &g_trainingSet[rand()%i]);

		for (i=0,temp=g_trainingSet[training].data; i<INPUT_NEURON; i++,temp>>=1)
			g_inputs[i] = temp & MASK1; // 인풋 비트 연결

		for (i=0; i<OUTPUT_NEURON; i++) // 원하는 출력값 설정
			g_desire[i] = g_trainingSet[training].desire[i];

		feedForward(); // 계산 시작
		backPropagate(); // 가중치 재계산

		// 에러율 계산 (필요하면 최종 err를 쓰면 됨)
		for (err=.0, i=0; i < OUTPUT_NEURON; i++)
			err += pow(g_trainingSet[training].desire[i] - g_output[i], 2);
		err *= 0.5;
	}

	for (temp= char2bit(test), i=0; i<INPUT_NEURON; i++, temp >>= 1)
		g_inputs[i] = temp & MASK1; // 입력값 연결

	feedForward();
	printf("실제값: %d, 추정값: %d\n", 2, select(g_output));
	return 0;
}

쓰레기 File Lock 구현..

(dr.Dorothy) — Sat, 13 Jun 2009 13:17:37 +0900

SP 과제의 내용중 하나인....
File Lock 구현하라는거.. ㅡ_ㅡ....
(세마포어는 찝찝해서 안쓰긴 했지만....... 통지메세지 걸어버리는것도 반칙인가 ㅡ_ㅡ?!..)
코드에 시그널 처리부분을 날림제작해서.. 레이스 컨디션이 생기지만.. 일단 패스..
(시연시 문제 없었으니 조용히 넘어가면 되는거임 ㅡ_ㅡ......)

그리고.. goto가 얼마나 편리한데.. PL시간엔 자꾸 욕을하니.. ㅡ_ㅡ..
(그래도 사용하는 센스..)

#define _GNU_SOURCE
#include <stdio.h>
#include <dirent.h>

#include "db.h"

// 시그널 부분 초기화
void db_lock_init( void )
{
	struct sigaction	act;

	// SIGIO 처리
	act.sa_sigaction = VoidHandler;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	sigaction(SIGIO, &act, NULL);

	// SIGALRM 처리 (혹시모를 상황에 대비 - 0 이면 사용 안함)
#if DB_LOCK_TIMEOUT > 0
	act.sa_sigaction = VoidHandler;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	sigaction(SIGALRM, &act, NULL);
#endif
}

// Lock을 실제로 거는 부분
int db_lock( IN char *path, DWORD offset, DWORD size )
{
	pid_t			pid;
	DIR				*pDir;
	struct dirent	*pDirInfo;
	char			buffer[64];
	int				fd; // Lock 풀린거 감지용

	DWORD			offset_i, size_i;

	// 오프셋별 접근을 막기 위한 초기 작업
	sprintf(buffer, "%s.lck", path);
	mkdir(buffer, 0700);
start:
	if ((pDir=opendir(buffer)) == NULL)
		return -1;

	sprintf(buffer, "%s/%d_%d", buffer, offset, size);

	// 만일 이미 파일이 있다면.. 누군가 쓰는거..
	if ((fd=open(buffer, O_WRONLY | O_CREAT | O_EXCL, 0600)) == -1) {
		closedir(pDir);
		goto Lock;
	}

	// 파일이 없어도 겹치는 부분이 있는지 확인해 봐야함
	// Lock의 범위 검증 시작
	while ((pDirInfo = readdir(pDir)) != NULL)
	{
		// 디렉토리 건너뛰고
		if (strcmp(pDirInfo->d_name, ".") == 0 ||
			strcmp(pDirInfo->d_name, "..") == 0)
			continue;

		sscanf(pDirInfo->d_name, "%u_%u", &offset_i, &size_i);

		//  방금 만든것도 건너뛰고
		if (offset_i == offset && size_i == size)
			continue;

		// 범위가 겹친다면 문제가 좀 있죠..
		if ( (offset_i <= offset && offset < offset_i + size_i) ||
			 (offset_i <= offset+size-1 && offset+size-1 < offset_i + size_i) )
		{
			closedir(pDir);
			close(fd);
			unlink(buffer);
			goto Lock;
		}
	}

	// Lock이 성공적으로 걸림
	// 만일 프로세스가 Lock을 걸어버리고 죽는다면..
	// pid 확인해서 Lock 정리 작업	
	closedir(pDir);
	pid = getpid();
	write(fd, &pid, sizeof(pid_t));
	return close(fd);

Lock: // Lock이 걸린 경우에 대한 처리 (Lock이 풀림을 기다림)
      // 반드시 생각해야 하는것..!! fd는 제한되어있으니 관리바람

	sprintf(buffer, "%s.lck", path);
	fd = open(buffer, O_RDONLY);
	fcntl(fd, F_NOTIFY, DN_DELETE);

	// 타임아웃이 설정되어 있다면 알람으로 강제로 깨움
#if DB_LOCK_TIMEOUT > 0
	alarm(DB_LOCK_TIMEOUT);
#endif

	pause();
	close(fd);

	goto start; // 깨어나면.. 다시 Lock을 시도
}

// Lock을 해제
int db_unlock( IN char *path, DWORD offset, DWORD size )
{
	int		fd;
	pid_t	pid;
	char	buffer[64];

	fprintf(stderr, "[DB] File unlocking 시작.\n");
	sprintf(buffer, "%s.lck/%d_%d", path, offset, size);

	if (access(buffer, F_OK) != 0)
		return -1;

	if ((fd=open(buffer, O_RDONLY)) == -1)
		return -1;

	if (read(fd, &pid, sizeof(pid_t)) != sizeof(pid_t)) {
		close(fd);
		return -1;
	}

	close(fd);

	if (pid != getpid())
		return -1;

	return unlink(buffer);
}

지하철 최단경로

(dr.Dorothy) — Sat, 06 Jun 2009 16:14:41 +0900

그냥 정확하게 숙제의 요구조건만 맞춘것.. ㅡ_ㅡ..
다익스트라 알고리즘으로 최단경로의 시간 계산만 함..
교수님이 아예 복잡한 상황을 만들어내는 인풋은 안준다고 했으니..
고런 인풋은 쌩깜.. (대략 허접함..)

숏코딩 할까말까 고민하다가..
결국 이상한 코드가 되어버림 ㅡ_ㅡ.....

#include <stdio.h>
#include <string.h>
#include <malloc.h>

#define BYTE unsigned char
#define WORD unsigned short

// 태그를 넣으면 인덱스 나옴
#define TTOI(tag) IndexTag[tag]

WORD *IndexTag; // 바로 참조 가능하도록한 인덱스

typedef union Tag {
	WORD val;
	struct {
		WORD Line:4;
		WORD stNo:6;
		WORD junk:6;
	};
} Tag;
Tag* SetTag(Tag *t, int l, int n) { t->Line=l;t->stNo=n;t->junk=0x00;return t; }

BYTE** CreateSubwayMap(int IndexSize, int LineSize, Tag* Line, int TranSize, Tag** Tran, int weight)
{
	int i, j;
	Tag tag1, tag2;
	BYTE** a; // 만들어질 공간

	// 배열 공간 잡기 (실제 존재하는 노선에 대해서만 생성됨)
	a = (BYTE**) malloc(sizeof(BYTE*) * IndexSize);
	for (i=0; i<IndexSize; i++)
	{
		a[i] = (BYTE*) malloc(sizeof(BYTE) * IndexSize);
		memset(a[i], 0xFF, IndexSize); a[i][i] = 0x00;
	}

	// 배열에 기본 링크 연결하기 (같은 노선)
	for (i=0; i<LineSize; i++) // 일단은 라인수 만큼
	{
		for (j=1; j<Line[i].stNo; j++) // 역 개수 만큼..
		{
			tag1 = tag2 = Line[i];
			tag1.stNo = j; tag2.stNo = j-1;
			a[TTOI(tag2.val)][TTOI(tag1.val)] = a[TTOI(tag1.val)][TTOI(tag2.val)] = 1;
		}
	}

	// 환승역 연결하기
	for (i=0; i<TranSize; i++)
		a[TTOI(Tran[i][0].val)][TTOI(Tran[i][1].val)] = a[TTOI(Tran[i][1].val)][TTOI(Tran[i][0].val)] = weight;

	return a;
}

// 편리한 참조를 위한 인덱싱 배열 생성
void CreateIndexTable(int TagSize, int LineSize, Tag* Line)
{
	Tag tag;
	int i, j, k;

	IndexTag = (WORD*) calloc(TagSize, sizeof(WORD));

	for (k=0, i=0; i<LineSize; i++) // 일단은 라인수 만큼
		for (j=0; j<Line[i].stNo; j++) // 역 개수 만큼..
			IndexTag[SetTag(&tag, Line[i].Line, j)->val] = k++;	// 이렇게 하면 Tag를 넣으면 인덱스가 나옴
}

int main(void)
{
	int TotalLines, TotalTransfer, TotalInput, weight;
	int IndexSize=0, TagSize=0;
	int i, j, k, p, t1, t2, start, min;
	int *leng, *Y; // 정점까지의 거리 및 확정 노드

	Tag tag1, tag2;
	Tag *LineInfo, **TranInfo; // 파일로 부터 읽어들인 기본자료들..
	BYTE** graph; // 전역 작업 공간

	FILE *fp = fopen("input.txt", "rt");

	// 일단은 노선 정보 먼저 읽어놓고 작업크기 계산
	fscanf(fp, "%d", &TotalLines);
	LineInfo = (Tag*) calloc(TotalLines, sizeof(Tag));

	for (i=0; i<TotalLines; i++)
	{
		fscanf(fp, "%d %d", &t1, &t2);
		SetTag(&LineInfo[i], t1-1, t2);
		IndexSize += t2;

		if (TagSize < LineInfo[i].val)
			TagSize = LineInfo[i].val;
	}

	// 환승역 정보 보관 (다익스트라 사용시 그래프 구조가 바뀌게 되어서 기본정보 저장)
	fscanf(fp, "%d", &TotalTransfer);
	TranInfo = (Tag**) calloc(TotalTransfer, sizeof(Tag*));

	for (i=0; i<TotalTransfer; i++)
	{
		TranInfo[i] = (Tag*) calloc(2, sizeof(Tag));
		fscanf(fp, "%d %d", &t1, &t2);
		TranInfo[i][0] = *SetTag(&tag1, t1-1, t2-1);
		fscanf(fp, "%d %d", &t1, &t2);
		TranInfo[i][1] = *SetTag(&tag2, t1-1, t2-1);
	}

	// 인덱스 생성해두고
	CreateIndexTable(TagSize, TotalLines, LineInfo);

	fscanf(fp, "%d", &TotalInput);
	for (i=0; i<TotalInput; i++)
	{
		fscanf(fp, "%d", &weight); // 환승 가중치

		fscanf(fp, "%d %d", &t1, &t2);
		start = TTOI(SetTag(&tag1, t1-1, t2-1)->val);

		// 작업공간을 만들기
		graph = CreateSubwayMap(IndexSize, TotalLines, LineInfo, TotalTransfer, TranInfo, weight);

		// 보조 작업용 배열 선언 및 초기화 (다익스트라 알고리즘의 시작)
		Y = (int*) calloc(IndexSize, sizeof(int));
		leng = (int*) malloc(sizeof(int)*IndexSize);
		for (j=0; j<IndexSize; j++) leng[j] = 0xff;

		// 실제 다익스트라 알고리즘 시작
		for (leng[start]=0, j=0; j<IndexSize; j++)
		{
			for (min=0xff, k=0; k<IndexSize; k++)
				if (Y[k]==0 && leng[k]<min)
					min = leng[p=k];

			Y[p]=1; // 최소인 정점을 확정한다

			// p를 경유해서 k에 이르는 거리가 지금까지의 최단경로보다 작으면 갱신
			for (k=0; k<IndexSize; k++)
				if ((leng[p]+graph[p][k]) < leng[k])
					leng[k] = leng[p] + graph[p][k];
		}

		fscanf(fp, "%d %d", &t1, &t2);
		printf("%d\n", leng[TTOI(SetTag(&tag1, t1-1, t2-1)->val)]);
		for (j=0; j<IndexSize; j++) free(graph[j]); free(graph); free(leng); free(Y);
	}

	return 0;
}

Lock 만들기 성공

(dr.Dorothy) — Tue, 26 May 2009 00:44:32 +0900

멀쩡히 쓰라고 만들어둔 Lock을 왜 쓰지 말란거지 ㅡ_ㅡ.....
세마포어로 하려다가......
왠지 안배운거 쓰면 점수 안줄거 같아서........
최대한 책에 있는것만 써서 구현......OTL....

뮤텍스 처럼 여러게가 접근하면..
나머지는 대기하다가.. Lock이 풀리는 순간 다른 Lock함수가 작동하게끔 구현..
무식 무한루프가 아니라.. cpu 점유도 안하니 착하군....

Offset 참조해서 영역 겹쳐서 Lock이 걸린 경우까지 처리 완료...b
Timeout도 줘서.. 설정해둔 시간 이상으로 Lock 안풀리면 재시작 과정도 추가..
비정상적인 Lock 설정후 죽어버리는 프로세스들을 위한..
메인 DB에서 Lock의 검증을 하는 루틴도 추가 완료.......ㅠ_ㅠ

완전...... 노가다자나......ㅜ_ㅜ
(그냥 세마포어 쓸껄......ㅜ_ㅜ)

언제나 배고픈 현실

(dr.Dorothy) — Sun, 24 May 2009 17:21:56 +0900

배고파..ㅡ_ㅜ
냉장고에 먹을거 없나 찾다가..
새우나 구워먹음..

간단하게 소금구이에..
전복 개우랑 고추씨기름으로 마무리 굽기 한것..
(생각보다 맛있군..)

집이 새우냄새로 뒤덥혔어......

SP 아주 미치겠다

(dr.Dorothy) — Mon, 18 May 2009 23:12:13 +0900

쓰레드를 쓰지 말라니....!!!!!
이건 무슨 날벼락 같은 소리인가..!!!!!!!!
구조 새로 짜라는거임 뭐임....ㅠ_ㅠ
진작 예기해 주던가...ㅠ_ㅠ........

아놔 이거 어떻게해....!!!!!
ㅅㅂㄹㅁ..........
입출력 동시 진행은 이미 쓰레드로 마음을 굳혔는데...ㅠ_ㅠ......
아놔아놔아놔!!!!..............................

주말동안 한게 없군

(dr.Dorothy) — Sun, 17 May 2009 21:22:23 +0900

매일 책좀 읽어야지 라고 생각하지만..
주말엔 이상하게 극도로 나태해지내 ㅡ_ㅡ..
(하긴 주중에도 나태하지만.. 빈둥빈둥..)

하루종일 우분투 테스트하고..
SP작업폴더와 Window사이의 연동때문에 죽어라 고생하고..
(뭔가 해결은 됬지만..... 그래도..... 완벽하지 않아..ㅠ_ㅠ)

실제로 프로그램 구현하다보니...
복병들이 다수 출현중이고.....
(아무래도.. 뭔가 통신의 공통 인터페이스를 하나 만들어야 할듯)
C++을 쓰지 말라고 한게.. 가장 충격이지만..
(이렇게 구조가 커지면 관리가 안되자나..ㅠ_ㅠ)

아무튼.. 주말은 그냥 날라감..
한것도 없고.. 공부도 안하고..
수요일은 퀴즈인데.. 공부도 안하고..
(그나마 금요일에 알고리즘 지하철 프로그램을 다 짜둔게 위안이 되는군..)

이거라도 다해둔게 어디야.. ㅠ_

자기전에 TCP공부나 하자... OTL..

월요일부터는 도서관에 출석도장 100% 찍을꺼야..ㅠ_ㅠ
(그동안은 학생증이 없어서 안간거야..!! <- 임시학생증은 폼이냐..)

우분투 9.04 나왔군

(dr.Dorothy) — Sun, 17 May 2009 12:07:32 +0900

로그인 화면도 좀 바뀌었는데...
뭔가...... 이상해 ㅡ_ㅡ;;..

대략.. 큰 변화는 못느끼겠고..
어찌됬든.. SP때문에라도 이제부터는 리눅스 작업이 많아지겠군.. ㅜ_ㅜ
Cygwin, MSYS 는 왜 시스템 프로그래밍을 완벽 지원하지 못하냐고..ㅠ_ㅠ....
윈도에도 있는 개념들인데...ㅜ_ㅜ

얼마나 아팠을까

(dr.Dorothy) — Fri, 15 May 2009 22:34:23 +0900

몇년전에.. 탁구 대회에서 찍은 동영상..
대략 4년도 더 전임..

그런데..

얼마나 아팠을까..ㅡ_ㅜ..ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

아놔.. 여자분껜 죄송 ㅡ_ㅡ..
누구신진 모르겠지만 ㅡ_ㅡ..ㅋㅋㅋㅋㅋㅋ

Merry Christmas Mr. Lawrence -FYI

(dr.Dorothy) — Thu, 14 May 2009 10:20:31 +0900

I give you my heart
Hold on let me sign it
Your senorita A.K.A your best friend
Hereby, let it be known
Love like never before
I'm always at your service
You just have to holler at me

NYC, NYC (what, what?)
Tokyo, Tokyo (what, what?)
Send it off from the streets to the highest
To the highest, high

MP3, MP3, players
Work it out, work it out, hustler
Oh, my name got him there
Mmm, mmm, mmm

You know why
I'm gonna be yours tonight
We're gonna ooh~ aah~
F.Y.I
We're gonna be up all night
I'll see you later
Call me, you know my number

Like Captain Richard
I'm chilling and flossing
It's 7 o'clock
I issue the warning

That's right, we're stealing the show
Damn right, letting him know
We're sipping chardonnay from 2 PM on our working day

Chinga-ling Chinga-ling, what, what
Chinga-ling Chinga-ling, what, what
Take me down to the fields where the grass is
Where the grass is

MP3, MP3, players
Work it out, work it out, hustler
Oh, my name got him there
Mmm, mmm, mmm

You know why
I'm gonna be yours tonight
We're gonna ooh~ aah~
F.Y.I
We're gonna be up all night
I'll see you later
Call me, you know my number

See if I don't need a freak
No, damn right
No, I don't want to feel no terror
If you want a piece of this stuff
Got to give, got to give something

You know why
I'm gonna be yours tonight
We're gonna ooh~ aah~
F.Y.I
We're gonna be up all night
I'll see you later
Call me, you know my number

You know why
I'm gonna be yours tonight
We're gonna ooh~ aah~
F.Y.I
We're gonna be up all night
I'll see you later
Call me, you know my number

슬럼프

(dr.Dorothy) — Tue, 12 May 2009 21:49:57 +0900

요즘들어 점점더.. 컴퓨터가 싫어진다..
그냥 내 적성에 맞지 않는듯 하다..

내가 만든 코드를 보면.. 애착보다는..
무미건조한 삭막함이 느껴진다..

사진속 모습처럼..
편안한 색상의 조화..
그저 평범한 녹색뿐이라도 아름답게..
자연스러움이 느껴지게 만들고 싶었다..

내가 현실세계에 무언가를 만들지 못하기에..
가상공간 안에서 나마 무언가에게..
창조적 아름다움을 부여하고 싶었다..

한편의 시.. 글을 쓰듯.. 나만의 색채로..
아름답다고 말할 수 있는 문장을 만들고 싶었던 것이다..

무의미하고.. 오직 자기 만족을 위한..
어설픈 잡기술로 점철된 쓰래기..
이것이 현실이다.. 실패한 것이다..

어디선가 본 내용을 그대로 배끼고선..
스스로가 만든 것인 양 우쭐거리기나 하는.. 우스운 모습 따윈..
이미 스스로가 묻어버리고자한 과거의 답습일 뿐..

가슴으로 느낄 수 있는 무언가가 필요하다..
정말 진실된 창조란것을 해보고 싶다..
내가 진심으로 뿌듯해 할 수 있는 것을 만들고 싶다..

그런데..

그것이 프로그래밍은 아닌것만 같다..

인공지능 발표용 자료 (최종)

(dr.Dorothy) — Fri, 08 May 2009 09:12:53 +0900

인공지능.exe

신은 나에게 ppt만드는 재주를 주심을 깜박하셨다.. ㅡ_ㅡ
이건 뭐.. 거의 발로 만든 수준이군 ㅡ_ㅡ;;...
앞으로 ppt 만드는건 최대한 피해야지 ㅡ_ㅡ..

15-Puzzle은 IDA*
Rubik's Cube는 Best First Search..

Optimal Binary Search Tree

(dr.Dorothy) — Thu, 07 May 2009 23:48:52 +0900

알고리즘 과제#3
OBST 만들기..!!

#include <stdio.h>
#include <malloc.h>

typedef struct NODE
{
	int key; // Key의 확률 자체임
	struct NODE* left;
	struct NODE* right;
} NODE; // 트리 생성을 위한 구조체

int **R, *p; // 트리 구축을 위한 배열 R과 빈도수 배열 p

void _free(int** T, int n) { int i; for (i=0; i<n+2; i++) free(T[i]); free(T); }
int** _malloc(int n) {  // 작업 공간 배열을 잡아주는 함수
	int i, **T = (int**) malloc(sizeof(int*) * (n+2));
	for (i=0; i<=n+1; i++) T[i] = (int*) calloc(n+1, sizeof(int));
	return T; // 작업공간을 반환 (삭제는 _free를 통해서 하면됨)
}

int minimum(int** A, int i, int j, int* k2) { // 해당 구간의 최소값
	int k1, min = 0x7fffffff;
	for (k1=i; k1<=j; k1++)
		if (A[i][k1-1] + A[k1+1][j] < min) // 최소가 되는 k를 저장
			min = A[i][k1-1] + A[k1+1][j], *k2 = k1;
	return min;
}

int sigma(int p[], int i, int j) { // p배열에서 구간의 합
	int k, sum=0; 
	for (k=i; k<=j; k++) sum += p[k];
	return sum;
}

void preorder(NODE* tree) {
	if (tree != NULL) { // 전위 순회를 통한 key값 출력
		printf("%d ", tree->key);
		preorder(tree->left);
		preorder(tree->right);
	}
}

int optsearchtree(int n, int p[], int** R) // 트리 구축 자료 생성
{
	int i, j, minavg, diagonal;
	int** A = _malloc(n);

	for (i=1; i<=n; i++)             // 배열 전체가 0으로 이미 초기화됨
		A[i][i] = p[i], R[i][i] = i; // 나머지 0으로 초기화 작업 생략

	for (diagonal=1; diagonal<=n-1; diagonal++)
		for (i=1; i<=n-diagonal; i++)
			j = i+ diagonal, // R의 위치에 minimum Key값을 바로 반영
			A[i][j] = minimum(A, i, j, &R[i][j]) + sigma(p, i, j);

	minavg = A[1][n];
	_free(A, n); // 메모리 누수 방지
	return minavg; // 반환값으로 평균 확률 반환
}

NODE* tree(int i, int j) // 트리 구축 함수
{
	int k;
	NODE* pNode;

	if ((k = R[i][j]) == 0) return NULL;  // 0일경우 끝
	pNode = (NODE*) malloc(sizeof(NODE)); // 그 이외엔 노드 생성
	pNode->key = k;
	pNode->left = tree(i, k-1);  // 계속 재귀를 통해서
	pNode->right = tree(k+1, j); // 단말노드로 부터 이어나감
	return pNode;
}

int main(void)
{
	int loop, i, size;
	FILE* fp = fopen("input.txt", "rt");

	for (fscanf(fp,"%d",&loop); loop && fscanf(fp,"%d",&size); loop--)
	{	// 전체 자료수 만큼 루프를 돌며 처리 시작
		R =  _malloc(size);
		p = (int*) calloc(size+1,sizeof(int));

		for (i=1; i<=size; i++)
			fscanf(fp, "%d", p+i); // Key 확률 입력받기

		optsearchtree(size, p, R); // 먼저 트리구축 자료를 생성하고
		preorder(tree(1, size)); // 트리를 전위 순회로 화면에 출력
		putchar('\n');
		_free(R, size); free(p); // 작업공간은 다시 초기화		
	}

	return 0;
}

읽고 있는 책

(dr.Dorothy) — Tue, 05 May 2009 19:50:47 +0900

이책.. 뭔가 좀 어렵다 ㅡ_ㅡ;;..
앞부분은 일반 리눅스 프로그래밍이라 그냥저냥 읽혔는데.......
뒤에가면 인공지능때 나오는 에이젼트 구조 나오고.............
병렬적으로 분할 방법에 대해 나오는데..............................
어떻게 적용해야 하는거지 ㅡ_ㅡ;;........................................

뭔가.. 뭔가.. 내 뇌가 다시 작동을 멈춘듯 ㅡ_ㅡ;;...............

병렬과 분산에 대한 개념이 없어서 그런가 ㅡ_ㅡ;;...................
좀더 깊이 알아봐야겠군......................................................

인공지능, 시스템프로그래밍, 알고리즘 모두 끝

(dr.Dorothy) — Sun, 03 May 2009 16:31:55 +0900

으하하하... ㅡ_ㅡ....
앞으로 3개만 더 하면된다... ㅜ_ㅡ

5월 5일은 놀러가자!!.... (제발..ㅠ_ㅠ)

인공지능 숙제 하나 완료 ㅡ_ㅡ

(dr.Dorothy) — Sun, 26 Apr 2009 22:32:10 +0900

내 주말을 반납하고......

Puzzle Solver.exe

열심히 노가다해서........
인공지능 15-Puzzle 푸는 프로그램은 완성.....

그냥 Best-First-Search로는 엄청난!! 시간과 메모리가 필요하기에..
이리저리 책 뒤져보고.. 공부해본 결과..
IDA*의 개념에 끌려서 바로 적용했음..

뭐.. A* 알고리즘이란게.. h*(n) > h() 만 성립하면 되는거자나 ㅡ_ㅡ.....
자료구조를 멀 쓰던...... 맞겠지?;;;....

이제 시스템 프로그래밍 레포트 써야지.. ㅡ_ㅜ

안정을 찾은 책상의 모습

(dr.Dorothy) — Sat, 25 Apr 2009 14:28:59 +0900

시험 끝나고 드디어 책상이 좀 사람 사는 집 같아짐..
한바탕 태풍이 휩쓴 자리 원상복구 성공.. ㅡ_ㅡ..

드디어 그림 도착..

(dr.Dorothy) — Thu, 23 Apr 2009 21:34:31 +0900

그림 도착...ㅎㅎㅎㅎㅎㅎㅎㅎ
아.. 이 그림 너무 멋진거 같어.. ㅠ_ㅠ..
좀 엉성하게 잘리긴 했지만..
색감이 좋아서 굿... 이쁘기도..ㅎㅎ
어디에 걸어둘까 고민해 봐야겠군..

(사실 가장 가지고 싶은건 원본인데...ㅜ_ㅜ)
현재 전 세계에서 가장 비싼 그림이라.........
원본은 무리겠지..ㅠ_ㅠ

1억 3천 5백만 달러라고 하던데.. ㅠ_ㅠ.........
지금 가격으로 1800억원이군..............
(위의 사진과 가격차이가 멋지군..... 깨갱인데.......)

..1:900000..

이 그림 나한테 사주는 사람 이뻐해 줄텐데.. ㅠ_ㅠ

명환 in 홍대 탁구장 (09.04.03)

(dr.Dorothy) — Thu, 23 Apr 2009 21:12:46 +0900

내 휴대폰 속에 찍어 둔게 있길래 한번 올려봄..
동영상 보니.. 다현이 좀 시끄러운듯 ㅡ_ㅡ..
너 시집못간다!?..ㅉㅉㅉ..

그냥 뭐.. 적당한 짜증과 허탈의 조우..

(dr.Dorothy) — Wed, 22 Apr 2009 22:22:31 +0900

상큼한 4월 예감..

월요일 - 시프
최근에 손코딩을 안하고.. 디버거 의존률이 100% 가 되더니.. 기초 디버깅 능력 상실..

화요일 - 인공지능 컴구
나에겐 단기 기억 뇌가 없음을 실감..
억지로 머리 굴려서 데이터 패스 다 외우고 멀티패스 FSM 외웠더니..
데이터패스는 그려주고.. 싱글의 Control 시그널이 나와주는 센스..

수요일 - 프언 (오늘....ㅜ_ㅜ)
나의 뇌엔 기억소가자 없음을 깨달았다.. 게다가 어제 잠도 못자서 만신창이..

목요일 - 알골
그나마 오픈북.. 외우는건 없을테니.. 그나마 희망의 빛 한줄기가.. ㅡ_ㅜ..
대신.. 망치면 난 세벽 3시경에 옥상 올라 갈꺼임..

금요일 - 컴네
알골의 상황에 따라 시험을 못칠 확률도 다분.. ㅡ_ㅡ..

다음주..

월요일 - 시프 프언
레포트 제출............................................!!

금요일까지.. 인공지능...........
15-Puzzle 과 3*3*3 Cube의 베스트 솔루션 찾는 프로그램 제작..

..........
.......
....
..
.

전역하면 보통 성적이 잘나온다던데..........
난 어디서 부터 잘못된걸까 ㅡ_ㅡ.........
다음주 부터 닥치고 도서관 직행예정..

그래도 복학생이자나.. ㅠ_ㅠ..
어느정도 리즈너블한 학점님이 나와줘야 체면이 있자나.. ㅠ_ㅠ..
신이시어... 날 버리지 마소서.. ㅠ_ㅠ..
제게 왜 기억력을 안주시었나이까.. ㅜ_ㅜ..
뭐라도 잘하는거좀 주시지.. ㅠ_ㅜ

D-Story #6 감동을 주지 못하는 현실..

(dr.Dorothy) — Fri, 17 Apr 2009 18:28:58 +0900

소소한 현실.. 그것은 과거가 되고..
그리움이 되어 나를 자극하는군..

편안했던 생활이 그리워지고..
잡생각이 드는것도 이러한 이유 때문일까??..

...

인간의 욕심과, 군중심리란 마술과도 같아서..
모두들 맹목적으로 무언가를 자신의 목표로 잡고선..
서로의 경쟁을 요구하는건 왜일까..

분위기에 휩쓸리고..
현 사회가 만들어 놓은 틀안에서..
무언가의 목표를 이루기 위해 발버둥 치는 모습..

태어나서 세상물정 모르는 아이들..
시대의 흐름은 그들에게 무거운 삶의 짐을 던져주고..
그렇게.. 그것을 당연하게 받아들인 그들은.. 더한 짐을 그들의 자손에게 전해주고..
과거로 부터 반복되어온 이 거대한 것..
이것이 우리에게 지금의 말도 안되는 복잡한 삶을 만들어 낸건 아닐까?..

뭐.. 길을 걷다가.. 그냥 갑자기 이런 생각이 떠올랐다..

더욱 우수한..!! 더욱 훌륭한..!!
따라 잡을 수 없을.. 대단한..!!
광기에 찬 눈으로..
맹목적으로 최고를 향해가는 인간의 모습이..
의미있는 삶을 찾아가는 것이라 하지만..
삶의 의미를 선택한건 과연.. 나 자신일까!?..
아니면 주변 환경에 휩쓸린 감정?..
또는, 그것에 역행하려는 반발은 아닐까?..
그것이 정말 진심으로 자신이 원했던 것이라 할 수 있을까!?..

자신의 선택에 후회를 남기지 않으려고..
자신에게 거는 최면은 아닌지..

하늘에 흐르는 작은 구름을 지켜보는 여유..
마른 가지에서 나올 상큼한 푸른 빛에 대한 기대..
비오는 날.. 그리움을 살짝 머금은.. 바람에 실려온 땅의 향기..
소소한 자연의 아름다움을 느낄 수 있는 이 마음..
사실은 이것들도.. 사회가 우리에게 주입한 무언가는 아닐까?..

차에 치인 사람의 그로테스크한 모습..
길가에 흩뿌려진 붉은 피.. 비릿한 내음..
이리저리 나뒹구는 인체의 조각들..
이것을 현 사회가 예술이라 정의하면..
사람들은 그것을 감상하지 않을까!?..

일단 현재의 내 궁금증에 대한 답은..
닥치고 공부나 하라는 결론이 나와야 하는 안타까움이란..
내 머리를 더 아프게만 하는구나..

Makefile

(dr.Dorothy) — Sat, 11 Apr 2009 18:08:53 +0900

Makefile

09.04.11

이번 SP 숙제하면서 급 다른 기능이 필요해서 수정..
디버그모드 릴리즈모드 구분하고, 프로파일 분석루틴 추가..
실행파일명은 현재 작업중인 폴더명으로 자동 컴파일됨..

CC ?= cc CFLAGS = -W -Wall #-std=c99 DFLAGS = -O0 -g3 -pg -DDEBUG RFLAGS = -O3 DBG_SUFFIX = _dbg PROFILE = --flat-profile --brief APPS = $(word $(words $(subst /, ,$(shell pwd))), $(subst /, ,$(shell pwd))) OBJS = $(patsubst %.c, %.o, $(wildcard *.c)) OBJS_d = $(patsubst %.o, %.o$(DBG_SUFFIX), $(OBJS)) .SUFFIXES: .o .c .c.o: $(CC) $(CFLAGS) $(RFLAGS) -c -o $@ $< .SUFFIXES: .o$(DBG_SUFFIX) .c .c.o$(DBG_SUFFIX): $(CC) $(CFLAGS) $(DFLAGS) -c -o $@ $< all: release debug release: $(OBJS) $(CC) $(CFLAGS) $(RFLAGS) -o $(APPS) $? debug: $(OBJS_d) $(CC) $(CFLAGS) $(DFLAGS) -o $(APPS)$(DBG_SUFFIX) $? analysis: @gprof $(PROFILE) $(APPS)$(DBG_SUFFIX) clean: @rm -rf *.o *.o$(DBG_SUFFIX) $(APPS) $(APPS)$(DBG_SUFFIX) gmon.out run: @-./$(APPS)

MRU vs. LRU

(dr.Dorothy) — Sat, 11 Apr 2009 17:58:35 +0900

SP 과제...

A411069_김명환_결과보고서.hwp

발로쓴 결과 보고서

먼저 입력값을 그룹별로 나눠야 할 필요성이 있기에.. 크게 3가지 그룹으로 분리..

1. 랜덤한 인풋

입력값 분포

입력 순서

그럼 성능 비교 시작..

이런 이런.. 별반 차이가 없군..
그냥 최대 허용 노드수만 늘리면 장땡..

2. 순차적 인풋

입력값 분포

입력 순서

입력

성능은 뭐가 더 좋을까나!?..

그렇군열~ MRU 승..
간단히 머리 굴려보면..
계속해서 다른 수가 들어오는 것이 아니라, 어느 정도 들어온 다음에 다시 이전의 값에서부터 시작하고, MRU로 자료를 유지했다면 앞부분의 자료만 변했기에, 다시 예전의 값에서 시작할 때 Update가 호출되기땜시 승.. LRU면.. 예전께 남아 있을리 만무..

3. 말로 표현하기 힘든 인풋.. (펄스는 아니고.. 뭐라고 하지 ㅡ_ㅡ??..)

입력값 분포

입력 순서

인력

성능비교 시작..

이번엔 LRU 승..
빈번하게 들어오는 입력값이 많으니..
기존 리스트에 있는 Data에 대한 Update 함수의 호출이 많아질 것이고..
Update 함수를 자주 사용한다면, 빈번히 호출되는 자료를 리스트의 앞쪽에 보관하게 될꺼고..
상대적으로 적게 사용되는 것들을 끝으로 밀어서 새로운 자료가 들어왔을 때..
안쓰는 것들을 지워야 효율적일테고..
위의 말 종합하면..LRU 쓰삼이란 뜻이고..
그래서 LRU의 승리고..
뭐.. 그렇고 그런 이야기 ㅡ_ㅡ..

그럼.. 코드 구현은 어떻게!??..

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>

#ifndef TABLESIZE
#define TABLESIZE	10
#endif
#define HASH(a) ((a) % TABLESIZE)

typedef struct Node {
	int data;
	struct Node *right;
	struct Node *next;
} Node;

Node *head, HashTable[TABLESIZE];
int MaxItem, ItemCounter;

int _Insert(int data);
int Insert(int data, char* policy);
Node* Search(int data, Node** end);
void Update(Node* node);
void func_select(char* policy, Node* p);
void UnlinkMRU(Node* temp);
void UnlinkLRU(Node* temp);
void Delete(Node* node);
char* print(Node* p)
{
	static char buf[1024], t[16];
	for (	memset(buf,'\0',sizeof(char) * 1024);
		p != NULL;
		sprintf(t, "%d ", p->data), strcat(buf, t), p=p->right ) ;
	return buf;
}

void printTable()
{
	int i;
	Node* p;
	for (i=0; i<TABLESIZE; i++)
	{
		printf("HashTable[%d] : ", i);
		for (p = HashTable[i].next; p!=NULL; p=p->next)
			printf("%d ", p->data);
		putchar('\n');
	}
}
int main(int argc, char* argv[])
{
	int data, ret;
	char mode[4];
	FILE* fp;

	if (argc != 3) exit(1);
	if ((MaxItem = atoi(argv[1])) == 0) exit(1);
	if ((fp = fopen(argv[2],"r")) == NULL) exit(1);

	memset((head=(Node*) malloc(sizeof(Node))), 0x00, sizeof(Node));

	while (!feof(fp) && fscanf(fp, "%3s %d", mode, &data))
	{
#ifdef DEBUG
		printf("input : %3s, %d\n", mode, data);
		printf("before entity list : %s\n", !ItemCounter ? "empty" : print(head->right));
#endif
		ret = Insert(data, mode);
#ifdef DEBUG
		printf("%d is %s in the list.\n", data, ret ? "missing" : "found");
		printf("after entity list : %s\n", print(head->right));
		printTable();
		putchar('\n');
#endif
	}

	printf("final entity list : %s\n", print(head->right));
	printTable();
	return 0;
}
// 실제 데이터를 리스트에 추가
int _Insert(int data)
{
	Node* temp;
	memset((temp = (Node*) malloc(sizeof(Node))), 0x00, sizeof(Node));

	temp->data = data; // 해시 테이블 연결부
	temp->next = HashTable[HASH(data)].next;
	HashTable[HASH(data)].next = temp;

	temp->right = head->right; // 우선순위 리스트 연결부
	head->right = temp;

	return ++ItemCounter;
}
// 선택적 삽입을 위한 분기점
int Insert(int data, char* policy)
{
	Node *temp, *end;

	if ((temp = Search(data, &end)) == NULL && ItemCounter < MaxItem)
		return _Insert(data); // 없는 자료 & 공간 존재

	else if (temp == NULL && ItemCounter >= MaxItem)
	{
		func_select(policy, end);
		return _Insert(data); // 없는 자료 & 공간 무
	}

	else // 이미 있는 자료일때
		return Update(temp), 0;
}
// 자료를 찾아서 존재한다면 바로 전 노드를 반환 (해시 테이블)
Node* Search(int data, Node** p)
{	// p 포인터는 RefCount를 줄여보기 위한 발악
	for (*p=HashTable+HASH(data); (*p)->next != NULL; *p=(*p)->next)
		if ((*p)->next->data == data)
			return (*p)->next;

	return NULL;
}
// 넘어온 노드의 우선순위리스트 전까지 이동해서 수정 (우선순위 리스트)
void Update(Node* node)
{
	Node *p, *target;
	if (head->right == node)
		return ;

	for (p=head; p->right != node; p=p->right) ;
	target = p->right;

	p->right = p->right->right;
	target->right = head->right;
	head->right = target;
}
// Delete 방법 호출 판단 및 레퍼런스 카운트 줄이기 대작전
void func_select(char* policy, Node* p) // 우선순위 리스트의 값
{
	static void (*fp[2])(Node*) = { &UnlinkLRU, &UnlinkMRU };
	int mode = !strcmp(policy, "MRU");
	if (!mode && p->right == NULL)
		p = (p->right != NULL && p->right->next != NULL) ? p->right : head;

	(fp[mode])(p);
}
// 앞의 노드를 삭제 -- 해시 테이블도 조절해야함 (우선순위 리스트)
void UnlinkMRU(Node* temp)
{	//여기 temp는 안씀
	temp = head->right;
	head->right = head->right->right;
	Delete(temp);
}
// 넘어오는 p의 위치에서 부터 찾도록 수정 (우선순위 리스트)
void UnlinkLRU(Node* p)
{	// 그나마 처음부터 검색하지 않게 하기 위함
	for (; p->right!=NULL; p=p->right)
		if (p->right->right == NULL)
			break;

	Delete(p->right);
	p->right = NULL; // 윗쪽에 1번 더 카운팅 되기에 여기선 안함
}
// 넘어오는노드 전까지 이동해서 삭제 (해시테이블)
void Delete(Node* node)
{
	Node *p;
	for (p=HashTable+HASH(node->data); p->next != node; p=p->next) ;
	p->next = p->next->next;
	free(node);
}

더블 리스트 쓰지 말라니.. 닥치고 쓰지 말아야지 ㅡ_ㅡ..
말을 참 잘 듣는 착한 학생..

소팅 시간 비교 Merge vs. Quick

(dr.Dorothy) — Fri, 03 Apr 2009 08:59:04 +0900

안타깝게도..
쉘 스크립트 하나 만들다가..
루트가 날라가버리는 불상사 발생..
온 세상이 새하얀 색으로 바뀌는 멋진 광경을 보게 됬다..ㅠ_ㅠ

블로그에라도 코드 백업좀 해놔야겠어..ㅠ_ㅠ
이기회에 내 블로그랑 학교서버의 폴더랑 동기화 시키는 프로그램이라도 하나 작성 해야겠군..
암튼..
이번 알고리즘 숙제인 시간측정코드..

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <time.h>

// 매우 큰 배열 테스트 (INT보다 더 큰 숫자 테스트를 위해서)
#define TYPE		unsigned

// 함수 prototype
void ExchangeSort(TYPE low, TYPE high);
void MergeSort(TYPE low, TYPE high);
void Merge(TYPE low, TYPE mid, TYPE high);
void QuickSort(TYPE low, TYPE high);
void partition(TYPE low, TYPE high, TYPE *Pivot);

void swap(TYPE* a, TYPE* b);
void sort(void (*)(TYPE, TYPE), TYPE, TYPE, TYPE*, TYPE*, TYPE*);

TYPE *RandomArray; // 랜덤한 수의 배열
TYPE *WorkingSet; // 실 작업 공간

TYPE SwpCount;
TYPE CmpCount;

int main(void)
{
	void (*fp[3])(TYPE, TYPE) = { &ExchangeSort, &MergeSort, &QuickSort };

	FILE *file = fopen("input.txt", "r");
	TYPE out[10][4];

	TYPE i,j;
	TYPE LoopCnt;

	// 입력값으로 내부 변수 초기화
	srand((unsigned) time(NULL));
	fscanf(file, "%u", &LoopCnt);
	for (i=0; i<4; i++)
		fscanf(file, "%u", &out[0][i]);

	// 입력하는 데이터를 4개로 가정
	for (i=0; i<4; i++)
	{
		// 작업 공간 잡기
		if ((RandomArray = (TYPE*) malloc(out[0][i] * sizeof(TYPE))) == NULL) break;
		if ((WorkingSet = (TYPE*) malloc(out[0][i] * sizeof(TYPE))) == NULL) break;

		// 랜덤한 순열 생성
		for (j=0; j<out[0][i]; j++) RandomArray[j] = j;
		if (i != 0)
			for (j=out[0][i]-1; j>0; j--)
				swap(&RandomArray[j], &RandomArray[(rand()*time(NULL))%j]);

		// 각 함수별 측정
		for (j=0; j<3; j++)
			sort(fp[j], out[0][i], LoopCnt, &out[j*3+1][i], &out[j*3+2][i], &out[j*3+3][i]);

		free(RandomArray);
		free(WorkingSet);
	}

	// 결과 출력
	printf(
		"                             N=%-5d     R=%-5d     R=%-5d     R=%-5d\n\n"
		"               Compare    %10d  %10d  %10d  %10d\n"
		"Exchange Sort  Exchange   %10d  %10d  %10d  %10d\n"
		"               Exe. Time  %10d  %10d  %10d  %10d\n\n"
		"               Compare    %10d  %10d  %10d  %10d\n"
		"Merge Sort     Exchange   %10d  %10d  %10d  %10d\n"
		"               Exe. Time  %10d  %10d  %10d  %10d\n\n"
		"               Compare    %10d  %10d  %10d  %10d\n"
		"Quick Sort     Exchange   %10d  %10d  %10d  %10d\n"
		"               Exe. Time  %10d  %10d  %10d  %10d\n",

		out[0][0], out[0][1], out[0][2], out[0][3],
		out[1][0], out[1][1], out[1][2], out[1][3],
		out[2][0], out[2][1], out[2][2], out[2][3],
		out[3][0], out[3][1], out[3][2], out[3][3],
		out[4][0], out[4][1], out[4][2], out[4][3],
		out[5][0], out[5][1], out[5][2], out[5][3],
		out[6][0], out[6][1], out[6][2], out[6][3],
		out[7][0], out[7][1], out[7][2], out[7][3],
		out[8][0], out[8][1], out[8][2], out[8][3],
		out[9][0], out[9][1], out[9][2], out[9][3]);

	return 0;
}

// 각 소팅함수별 측정 자동화
void sort(void (*fp)(TYPE,TYPE), TYPE size, TYPE LoopCnt, TYPE* AvgCompare, TYPE* AvgSwap, TYPE* AvgTime)
{
	TYPE i, j;
	TYPE start;

	*AvgCompare = *AvgSwap = *AvgTime = 0;

	for (i=0; i<LoopCnt; i++)
	{
		// 준비작업
		SwpCount = CmpCount = 0;
		memcpy(WorkingSet, RandomArray, size*sizeof(TYPE));

		// 시간 측정 시작
		start = clock();
		(fp)(0, size-1);
		*AvgTime += clock()-start;

		// 정렬된 데이터의 검증
		for (j=0; j<size; j++)
			if (WorkingSet[j] != j)
				puts("Error!!"),exit(1);

		*AvgCompare += CmpCount;
		*AvgSwap += SwpCount;
	}

	// 평균내기
	*AvgTime /= LoopCnt;
	*AvgCompare /= LoopCnt;
	*AvgSwap /= LoopCnt;
}

// 교환정렬
void ExchangeSort(TYPE low, TYPE high)
{
	TYPE i, j;

	for (i=0; i<high-low; i++)
		for (j=high-low; j>i; j--)
			if (++CmpCount && WorkingSet[j] < WorkingSet[j-1])
				swap(WorkingSet+j, WorkingSet+j-1);
}

// 머지소트
void MergeSort(TYPE low, TYPE high)
{
	TYPE mid = (low+high) / 2;

	if (low < high)
	{
		MergeSort(low, mid);
		MergeSort(mid+1, high);
		Merge(low, mid, high);
	}
}

// 실제 합치는 과정
void Merge(TYPE low, TYPE mid, TYPE high)
{
	TYPE i=low, j=mid+1, k=0, size = high-low+1;
	TYPE *U = (TYPE*) malloc(size * sizeof(TYPE));

	while (++CmpCount && i<=mid && j<=high)
		U[k++] = (WorkingSet[i] < WorkingSet[j]) ? WorkingSet[i++] : WorkingSet[j++];

	SwpCount += size;
	memcpy(U+k, WorkingSet+(i>mid?j:i), (size-k) * sizeof(TYPE)); 
	memcpy(WorkingSet+low, U, size * sizeof(TYPE));
	free(U);
}

// 퀵소트
void QuickSort(TYPE low, TYPE high)
{
	TYPE PivotPoint;

	if (high > low)
	{
		partition(low, high, &PivotPoint);
		if (PivotPoint != 0)
			QuickSort(low, PivotPoint-1);
		QuickSort(PivotPoint+1, high);
	}
}

// 피봇을 기준으로 데이터 정렬
void partition(TYPE low, TYPE high, TYPE* Pivot)
{
	TYPE i, j=low;
	TYPE PivotItem = WorkingSet[low];

	for (i=low+1; i <= high; i++)
		if (++CmpCount && WorkingSet[i] < PivotItem)
			swap(&WorkingSet[i], &WorkingSet[++j]);

	*Pivot = j;
	swap(&WorkingSet[low], &WorkingSet[*Pivot]);
}

// 스왑함수
void swap(TYPE* a, TYPE* b) {
	if (++SwpCount && *a != *b) {
		*a = *a ^ *b;
		*b = *a ^ *b;
		*a = *a ^ *b;
	}
}

Sort 시간 측정 골아프군

(dr.Dorothy) — Sun, 29 Mar 2009 13:33:44 +0900

...

검은색이 Quick Sort..
붉은색이 Merge Sort..
왼쪽 구석의 파란점이.. Exchange Sort..

아놔.. 퀵소트가 NLogN의 시간에 비례한다며 ㅡ_ㅡ;;..
어딜봐서 NLogN 이야 ㅡ_ㅡ;;..............
자료 수가 적은게냐 ㅡ_ㅡ..?

1000단위로.. 1000에서 803000 까지.. 총 803개의 자료를 만들었자나!!..
(저거 값 뽑아내는데 무려 1시간이 걸렸단 말이야..ㅠ_ㅠ)

뭐가 부족해!!.. ㅜ_ㅜ
무한정 돌려버릴까 ㅡ_ㅡ!?..

프로그래밍 언어시간에 교수님이 물어본 내용

(dr.Dorothy) — Tue, 24 Mar 2009 00:37:52 +0900

부동소수점 변수들 내부에 비트들이 어찌 생겨먹었는지 물어보셔서..
낼름 하나 짜봤음..
(비트 필드 만쉐이~)

#include <stdio.h>

typedef union
{
	float val;
	struct 
	{
		unsigned significand:23;
		unsigned exponent:8;
		unsigned sign:1;
	};
} FLOATING;

typedef union
{
	double val;
	struct 
	{
		unsigned significandEx:32;
		unsigned significand:20;
		unsigned exponent:11;
		unsigned sign:1;
	};
} DOUBLE;

int main(void)
{
	FLOATING f;
	DOUBLE d;

	f.val = 0.75;
	d.val = -0.75684564;

	printf("%x %x %x\n", f.sign, f.exponent, f.significand);
	printf("%x %x %x%0x\n", d.sign, d.exponent, d.significand, d.significandEx);

	return 0;
}

남용이네 자료구조 스택 숙제

(dr.Dorothy) — Sun, 22 Mar 2009 13:32:07 +0900

남용아~ 나 너무 착하지?ㅋㅋㅋ
너네 교수님은 특이한걸 요구 하시는군..ㅋㅋ
스택2개로 큐를 구현하라니..ㅋㅋ

#include <iostream>
#define DELIM " "

using namespace std;

template <typename T>
class CStack
{
private:
	T *S; int size, sp;
	bool inline isErr(T data) {return (data == OVERFLOW || data == UNDERFLOW);};

public:
	enum { OVERFLOW = 0x80000000, UNDERFLOW = 0x80000001 };

	CStack(T _size):size(_size),sp(0) { S = new T[size]; };
	virtual ~CStack()	{ delete[] S; };

	T pop(void) { return (sp > 0 ? S[--sp] : UNDERFLOW); };
	T push(T val) { return (sp<size && !isErr(val) ? S[sp++]=val : OVERFLOW); };

	void print(void) { for (int i=0; i<sp; cout<<S[i++]<<" ") ; cout << endl; };
};

class CCrazyQueue
{
private:
	CStack<int> st1, st2;

public:
	CCrazyQueue(int size = 10) : st1(size), st2(size) { }

	void in(int data)
	{
		if (st1.push(data) == CStack<int>::OVERFLOW) {
			cout << "작작좀 넣으삼!!" << endl;
			return ;
		}
		while (st2.push(st1.pop()) != CStack<int>::OVERFLOW);
		while (st1.push(st2.pop()) != CStack<int>::OVERFLOW);
	}

	int out(void)
	{
		while (st2.push(st1.pop()) != CStack<int>::OVERFLOW);
		int ret = st2.pop();
		if (ret == CStack<int>::UNDERFLOW) {
			cout << "작작좀 빼삼!!" << endl;
			return ret;
		}
		while (st1.push(st2.pop()) != CStack<int>::OVERFLOW);
		return ret;
	}

	void print(void) { st1.print(); }
};

int main(void)
{
	CCrazyQueue q(10);
	char input[256], *p;

	while (1)
	{
		cout << "> ";
		cin.getline(input, 256);
		if (*input == '\0') continue;

		p = strtok(input, DELIM);

		if (strcmp(p, "in") == 0)
		{
			for (p=strtok(NULL,DELIM); p != NULL; p=strtok(NULL,DELIM))
				q.in(atoi(p));
			q.print();
		}
		else if (strcmp(p, "out") == 0)
			q.out(), q.print();
		else if (strcmp(p, "quit") == 0)
			break;
		else
			cout << "손가락 병신임?" << endl;
	}

	return 0;
}

명환 in 올림픽공원 (09.03.18) - Maksim 내한공연

(dr.Dorothy) — Thu, 19 Mar 2009 08:53:15 +0900

막심 내한공연 다녀왔다~ㅎㅎㅎ
기대치 보다는 좀 실망을 했지만.............
아무튼 오랜만에 문화생활...

실망했던 점만 꼽으라면..

1. 저질스런 음향효과...
완전 맙소사였다.. 피아노소리가 주변연주에 파뭍혀버리고......
바이올린음이 고음으로 올라가자... 스피커에서 소리가 뭉개졌다....ㅡ_ㅡ

2. 조명..
일렉트릭적 요소가 가미되다 보니.. 화려하게 하는건 좋은데..
관객에게 빛을 그리도 쏴대면 눈부셔서 어쩌란거임 ㅡ_ㅡ...........

아무튼 돈에 비해선 뭔가 살짝 아쉬웠다..

그리고.. 끝내 저분은.. 목소리 공개를 안하시고 가버리는 ㅡ_ㅡ......
목소리가 궁금했는데 ㅡ_ㅡㅋ..
(내한공연 왔으면 인사정도는 해주는 센스 없나 ㅡ_ㅡ...)