미루어둔 작업의 하나로 아트캔버스 정식 버전의 출시를 위해 리뉴얼 작업이 진행중입니다.
byedodo artCanvas는 제작년 와콤 뱀부펀 체험 참여건과 맞물려 베타 버전이 출시되었고, 그 후 심볼릭 엔진인 mathAcademy 개발건에 밀려 정식 버전 출시가 계속 지연되어 왔습니다.

artCanvas 개발의 주 목적은 디지털 아트를 실제 그림처럼 자연스럽게 표현하는 것이며, 그에 따라 어린이부터 전문 아티스트까지 폭넒게 운용할 수 있도록 하는데 있습니다.

아트캔버스 정식 버전 주요 기능

1. 하나의 버전 안에서, 유아용, 어린이용, 교육용, 전문가용까지 옵션상에서 구현할 수 있도록 처리하며,
2. 레일노트 타입의 카테고리형 저장 시스템을 장착하여 그림의 보관과 색인이 하나의 파일 (4 Tera bytes 지원)안에서 편리하게 처리되도록 구현하게 됩니다.
3. 또한, 트래킹 기능을 넣어 사용자의 그림 그리는 과정을 기록할 수 있고, 트래킹 정보를 다른 이들과 공유할 수 있도록 합니다.
4. 레이어 기능을 첨부하여, 포토샵과 같은 다양한 레이어 블렌딩 효과 등을 처리하게 됩니다.
5. 바이도도 아트파티 사이트와 연계하여, 유아, 어린이, 학생, 전문가의 각 포지션별 업로드 및 열람 기능을 지원합니다.

정식 버전의 아트캔버스 프로그램 기능은 올해 말까지 1차 완료될 계획이며,
아트 파티 사이트 제작 및 프로그램 연계 작업은 내년 중순까지 완료할 계획입니다.

지경부 및 정보통신진흥원의 수상, 지구별 여행 사이트 및 컨텐츠, 인적 자원 문제 등의 여러 작업에 따른 수개월간의 시간적 공백이 있었다.
한달여 전부터 미루어 두었던 아이디어패널 정식버전, 레일노트 UI 추가 및 웹 에디터 엔진의 업데이트가 진행되었고, 기반 컴퍼넌트와 라이브러리의 속도와 디자인 개선 부분이 진행되었다.
또한, 사무 공간 이전과 신규 컴퓨터 구매, 개발용으로 포팅하는 작업이 진행되었다.

현재, 아트캔버스를 정식 버전으로 업데이트 중이며,
여기에는 드로잉 트래킹(자취 기록 및 재생), 레이어(Layer) 처리 등이 추가되며,
전체 UI는 레일노트처럼 트리 기반의 그림 에디터로 업데이트되게 된다.
또한, 드로잉 속도와 질감의 문제 (특히, 수묵화, 수채화, 유화 부분의 드로잉 질감을 보다 현실적으로 개선하는 것)에 대해 아주 많은 그림 및 질감 데이타를 모아서 수정 작업 중이다.
그 다음으로, 지난 수개월간 미뤄온 매쓰아카데미(mathAcademy)의 버전 업이 진행된다.
기술적인 문제들이 산적해 있기 때문에 mathAcademy 개발은 여전히 힘든 도전이 될 것으로 보인다.

매쓰아카데미 정식 버전이 종료되면,
새로운 목표로 정적 분석 소프트웨어를 개발하게 된다.
정적 분석 소프트웨어란, 일반적으로 프로그램 개발 소스를 런타임상에서 테스트하는 것과 달리, 소스 그 자체의 취약점과 메모리, 구조적 문제, Null 문제 등을 자동으로 체크하고 알려주는 기능을 포함한다.
시중에 나와 있는 몇몇 유료 정적 분석 소프트웨어를 가져와 테스트해보았으나 생각외로 실망스러웠다. 특히 소스 분석력과 알고리즘 문제 체크 능력이 개발자에게 도움이 될 수 있는 수준이 되지 못하였다.
새로운 정적 분석 모델로서, mathAcademy에 사용된 심볼릭 엔진 기술과, mathAcademy 자체 인터프리터 엔진, 디버깅 엔진, 메타 로직 알고리즘 등을 정적 분석에 맞게 확장하고,
소스 코드를 심볼릭 기반으로 해석하는 것을 기술적 중심으로 하려고 한다.

1. Byedodo 학교 개설 (3월 중순 ~)
   어린이, 학생들을 위한 여행 중심 학습을 전개하기 위해,
   Byedodo 학교(가칭)를 개설하고자 합니다.
   Byedodo 학교에서는 저소득 가정의 어린이에 대한 바우쳐 활동 등이 포함됩니다.
   많은 성원을 부탁드립니다.

2. math Academy 출시 (3월 중 알파 버전 배포)
   + 강력한 Symbolic engine
     대부분의 수학 함수를 포괄하는 전용 Symbolic engine으로,
     symbolic 전용 엔진으로는 국내 최초의 프로그램입니다.
     참고로, Byedodo Equation 프로그램이 다항식 연산을 처리하지만,
     n차 복소 다항식을 제외한 일반 수식에 대해서는 지원하지 못하고 있습니다.
     math Academy는 복소 계산, 수론, 다항식, 삼각함수, 미적분 등에 대해 인식하고
     수식을 대수 형태 그 자체로 계산할 수 있습니다.
   + 다양한 함수에 대한 수치 해석 엔진
     삼각함수, 복소함수, 수론함수, 감마 타입, 기타 300여가지의 전문 수학 함수와 수치 미적분을 포함하며,
     유효자리수 소수점 이하 1만자리(정밀도 0.00000... 으로 0이 1만개),
     정수부 10만자리(10^100,000)까지 지원합니다.
     Elliptic curve method, 임의 적분법을 통한 수치 적분 등, 최신의 수학적 기법을 사용하고 있습니다.
   + 메타적인 프로그래밍 언어
     알고리즘 자체를 변수로 다루고, 알고리즘의 Join, Shift, Insert 등이 실행중에 이루어집니다.
     runtime상의 구조 변경, 자체 조직화 등의 기능을 포괄하며, Lisp의 기능적 장점을 흡수하였습니다.
   위의 세가지 주요 기능을 포괄한 프로그램이며,
   알파 버전에는 위의 기능 중 일부분이 포함되지 않습니다.


이상이 가까운 시일내의 주요 Byedodo 스케쥴입니다.
이 후, artCanvas 정식 버전 개발과 myDrawer 리뉴얼 등 기존 프로그램 작업과,
Byedodo 학교에 대한 일반.
레일노트의 웹오피스 작업 등이 진행됩니다.

matheTOY 함수 엔진을 지속적으로 확장해가며,
범용적인 부분까지 처리하다보니,
결국 그 연산 내용이 LISP 처리와 유사해지고 말았다.

현재의 matheTOY 엔진의 처리 과정은 LISP 처리 과정과 동일하며,
수식, 방정식, 함수식, 집합, 행렬, 리스트 등의 지원되는 처리외에
String 등 추가적인 변수 타입, 디바이스 I/O 등을 추가한다면, 훌륭한 Lisp 엔진이 될 것 같다.

matheTOY 수식 처리 Language 엔진이 기존 Lisp 언어보다 강력한 것은, (어쩌면 기존 Lisp에도 있을지 모르지만)
1. Trans 함수
   예를들어, Tan(x) = Sin(x) / Cos(x) 와 같은 '대입 정의 함수'를 Lisp에서 처리할 수는 있다.
   그러나,
   (A ^ b) * (A ^ c) = A ^ (b + c) 같은 형태의 Trans 식은,
   LIsp 뿐만 아니라, 여타 랭귀지에서도 지원하지 않는 것으로 안다.
   (위에서 A, b, c는 단순한 수치가 아니라, 알고리즘이나 함수들을 포함한 함수식이다.)
   물론 저것을 기존 제공된 알고리즘으로 풀 수는 있다.
   그러나 그 알고리즘을 만드는 것은 Case마다 개별적이며 번거로운 과정이 필요하다.
   Trans 식은 매우 직관적이고, 수학적이다.
2. IsEqual 함수
   두 함수식 또는 두 알고리즘식이 같은 것인지 판단한다.
   복잡하게 얽힌 두 함수식, 두 알고리즘식이 같은지 여부를 판단하는 것은
   Logic이나 함수, 알고리즘 자체를 원소로 다루는 계산에서 중요한 처리이다.
   그것을 처리하도록 고안된 함수이다.
3. Mergin 함수
   함수식 내에 Inverse 함수가 중첩되거나, 중복 의미 함수가 존재하거나,
   Operator-inverse 함수가 존재할 때,
   그것은 가장 간단하게 표현되도록 Mergin하는 처리를 담당한다.
기술한 것 외에 여러가지 '함수식을 처리'하는 함수들이 있다.
또한, 그 ['함수식을 처리'하는 함수]가 포함된 함수식 역시 처리되는 대상 인자이다.

Lisp을 지원하는 프로그래밍 툴의 희소성은 충분하고,
게다가 보다 강력한 메타 랭귀지 함수를 지원하므로, 도전해볼만 한 것으로 생각된다.
하지만, 무의미한 과부하가 걸리는 것은 아닌지...

matheTOY 입실론 버전에서 현재(2010년 2월 22일)까지 처리된 함수 목록입니다.
(※ matheTOY 입실론 버전은 아직 출시되지 않은 버전이므로 착오없으시길 바랍니다)

몇몇 함수는 계산 속도를 위한 알고리즘 개선 등의 추가 작업이 필요한 상태입니다.
또, 통계 파트의 상당수 함수는 이번 버전에서 제거되어 풀시될 예정입니다.
통계 파트의 다양한 분포 함수와 PDF 처리, 신뢰도 검정 등의 부분에 대해서는 전체적인 UI를 다듬은 후에 출시할 수 있을 듯 합니다.

현재 지원되는 함수만으로도, 대부분의 수학 분야에서 mathmatica의 수학 함수 리스트에 비교하여 부족하지 않습니다.
또, 통상 소수점 이하 20자리 정도까지의 정밀도만 제공하는 여러 전문 수학 프로그램들과 달리,
각 함수에 대해 소수점 이하 1만자리까지 정밀도를 지원하므로, mathmatica에 비교하여 더 뛰어난 기능성을 보일 수 있을 것이라 생각됩니다.
또한 matheTOY는 mathmatica 처럼, 스크립트 언어를 지원하므로,
사용자가 클래스 등을 제작하여, 원하는 수학적 출력물을 프로그래밍할 수 있게 됩니다.

비함수 연산자 부분

  - 대소 비교문
  - 선택문
  - 조건문
  - 사칙연산, 거듭제곱

함수 부분
Abs  : Abs(A)
Sgn  : Sgn(A), A Is Real
Floor  : Floor(A[, FloorDigit])
Re  : Re(A)
Im  : Im(A)
------------------------------------------------
Reciprocal
Exp  : Exp(A)
Sqr
------------------------------------------------
Cos / Sin / Tan
Sec / Cosec / Cotan
Arcsin / Arccos / Arcsec / Arccosec / Arccotan
Hsin / Hcos / Htan / Hsec / Hcosec / Hcotan
Harcsin / Harccos / Harctan / Harcsec / Harccosec / Harccotan
------------------------------------------------
Atan / ArcTan / Atn
Asin / Acos / Csc / Ctan / Ctn / Acosec / Acsc / ArcCsc / Acotan / Actan / Actn / ArcCtan / ArcCtn / Asec
Hatan / Hatn / Hasin / Hacos / HCsc / Hctan / HCtn
Hacosec / Hacsc / HArcCsc / Hacotan / Hactan / Hactn / HArcCtan / HArcCtn
Hasec / Atanh / Atnh / Asinh / Acosh / Csch / Ctanh / Ctnh / Acosech / Acsch
ArcCsch / Acotanh / Actanh / Actnh / ArcCtanh / ArcCtnh / Asech / ArcTanh
ArcSinh / ArcCosh / Cosech / Cotanh / ArcCosech / ArcCotanh / ArcSech
------------------------------------------------
Sinc  : = Sin(Pi*x)/(Pi*x)
Ln  : Ln(A)
Log(X1, X2)
Gudermannian  : = 2*arcTan(e^x) - Pi/2
LogFloor  : (a, b)
Arg 
------------------------------------------------
Bernoulli  : (n) : n is none negative integer
Gamma  : (s) : s is complex
Gamma_Incomplete_Upper  : STT (통계) : (s, up) and  : up :  is Real
Gamma_Incomplete_Lower  : STT (통계) : (s, low) and  : low :  is Real
Gamma_Di  : Di(z) = PolyGamma(0, z)
Gamma_Poly  : (m, z) : m is none negative integer
Gamma_Multivariate  : (p, x) : p is natural number
Beta  : Beta(X, Y)
Beta_Incomplete  : STT (통계) : Beta_Imcomp(up, a, b) and  : up :  is Real
Zeta  : (z)
Zeta_Hurwitz  : (s, q) and Re(s)>1, Re(q)>0
// Zeta_Lerch  : -> 너무 복잡하여 사용치 않음
Error  :  = 2*Cumulative_Distribution(x * Sqr(2)) - 1
ErrorC  :  = 2*Cumulative_Distribution(-x * Sqr(2))
K  : K(n)
Barnes_G  : (z)
Dirichlet_L  : L(s, k) and k is natural number > 1
                  = Zeta_Hurwitz(s, m/k))
Dirichlet_Beta  : 4^(-n) * (Zeta_Hurwitz(s, 1/4) - Zeta_Hurwitz(s, 3/4))
Dirichlet_Character  : (k, s, n) - k: 1 보다 큰 Integer
                                     s: Positive int, n: none negative integer
------------------------------------------------
Eta_Dirichlet  : = (1 - 2^(1 - s)) * Zeta(s)
Eta_Dedekind  : (z)
Euler  : Euler(q) = q^(-1/24) * Eta_Dedekind(Tau), 단, q = e^(2*pi*i*Tau)
                                하지만, Tau를 구하는 것이 쉽지 않기 때문에 따로 처리한다.
Chi_Legendre  : chi_v(z) = 1/2 * [Li_v(z) - Li_v(-z)] : Li : PolyLogarithm
Delta_Kronecker  : (i, j) : i, j is integer
------------------------------------------------
Theta_Riemann_Siegel  : theta(t) = arg (Gammat((2it+1)/4))) - t * Ln(pi)/2
Theta_Jacobi  : (z, r) : z, r is complex
Theta_Ramanujan  : (a, b) a, b is real and |ab| < 1
Theta_Riemann  : (t) : t is real
Theta_Q  : (z, q) : q is real and |q| < 1
------------------------------------------------
Bessel_First  : J_a(x) 로 표기 - (a, x) and a, x is complex
Bessel_Second  : Y_a(x) = (J_a(x) * cos(a * pi) - J_-a(x)) / sin(a * pi)
Bessel_Modified_I  : I_a(x) = i ^ (-a) * J_a(i * x)
Bessel_Modified_K  : K_a(x) = (Pi / 2) * i ^ (a + 1) * H1_a(i * x)
Bessel_Spherical_J  : j_n(x) = sqr(pi / (2 * x)) * J_{n+1/2}(x)
Bessel_Spherical_Y  : y_n(x) = (-1)^{n+1} * sqr{pi / (2 * x)} * J_{-n-1/2}(x)
Bessel_Riccati_S  : S_n(x) = x * j_n(x)
Bessel_Riccati_C  : C_n(x) = -x * y_n(x)
Bessel_Riccati_Zeta  : Zeta_n(x) = x * h2_n(x)
Bessel_Clifford_One  : (n, z) : n, z is complex
Bessel_Clifford_Two  : (n, z) : n, z is complex
Hankel_One  : H1_a(x) = (J_-a(x) - e^(a * pi * i) * J_a(x)) / (i * sin(a * pi))
Hankel_Two  : H2_a(x) = (J_-a(x) - e^(a * pi * i) * J_a(x)) / (-i * sin(a * pi))
Hankel_One_Spherical  : h1_n(x) = j_n(x) + i * y_n(x)
Hankel_Two_Spherical  : h2_n(x) = j_n(x) - i * y_n(x)
Kelvin_Ber  : (n, x) : n is integer
Kelvin_Bei
Kelvin_Ker
Kelvin_Kei
Airy_Ai  : (x) : x is real
Airy_Bi 
Synchrotron_First  : (x) : x is real >=0
Synchrotron_Second  : G(x) = x * K_{2/3}(x)
------------------------------------------------
Weierstrass  : (x, a, b) : 0 < a < 1, b : positive odd integer, and ab > 1 + {3 * pi}/2
Weierstrass_Elliptic  : (z[, w1], w2)
Invariant_J  : j(x) =      [θ(0;x)^8+θ_{01}(0;x)^8+θ_{10}(0;x)^8]^3
                             32 ---------------------------------------
                                [θ(0;x) θ_{01}(0;x) θ_{10}(0;x)]^8}
                                θ : Jacobi Theta FC
Struve  : (a, x) : a, x is complex
Anger  : (v, z)
Weber  : (v, z)
Riesz  : (x)
Dawson  : = - {i * sqr{pi} / 2} * e^{-x^2} * erf(i * x)  :  erf() : Error Function
Lambert_W  : (x)
Dirac_Delta  : (x)
Mittag_Leffler  : (a, b, z) : a, b, z is complex, Re(a) > 0
------------------------------------------------
Polylog  : Li(s, z) : s, z Is complex and |z| < 1
Polylog_Incomplete  : Li(s, low, z) : s, z Is complex and |z| < 1, low is real
Polylog_Spence  :  = Li_2(z)
------------------------------------------------
Integral Type Function
integral_Scorer_Gi  : (x)
integral_Scorer_Hi  : (x)
integral_Clausen  : (s, x) : Re(s) > 1
integral_Kummer  : (n, z) : n, z is complex
integral_Heaviside_Step  : (x) : x is real
integral_Logarithmic  : li(x) : x is real > 0 and x<>1
integral_Logarithmic_Offset  : Li(x) = li(x) - li(2)
integral_Exponential  : Ei(x) : x is real x <> 0
integral_Trigono_Upper  : Si(x) : x is real > 0
integral_Trigono_Lower  : si(x) : x is real > 0
integral_Fresnel_Sin  : (x) : x is real > 0
integral_Fresnel_Cos  : (x) : x is real > 0
// integral_Elliptic_Incomplete_First  : -> 이해되지 않는 수학적 내용이 있어서 처리를 미룸
integral_Elliptic_Incomplete_Second
integral_Elliptic_Incomplete_Third
integral_Elliptic_Complete_First
integral_Elliptic_Complete_Second
integral_Elliptic_Complete_Third
------------------------------------------------
Seri_Integral  : 부정 적분이다. Integral(By X, F(X)) 꼴로 나타낸다.
Seri_IntegralReal  : 정적분이다. IntegralReal(By X, Area(), F(X)) 꼴로 나타낸다.
Seri_Differ  : 미분 Differ(By X, F(X)) 꼴
Seri_Series  : Series(By X, Area(A, B), F(X)[, Where(IsFactor(X,C))]) 양식
Seri_SumAll  : SumAll(By X, Area(A, B), F(X)[, Where(IsFactor(X,C))]) 양식
Seri_ProductAll  : ProductAll(By X, Area(A, B), F(X)[, Where(IsFactor(X,C))]) 양식
Seri_ContinuedFrac  : ContinuedFrac(By X, Area(A, B), F(X)[, Where(IsFactor(X,C))]) 양식
Seri_Interval  : Series, Integral 등에서 사용, (Start, End[, Step])
------------------------------------------------
ModExpand_CycleMod  : (R, modR)
------------------------------------------------
n번째 항을 순차적으로 출력하는 함수들만 모음
nThElem_Bernoulli  : (n) : n is none negative integer
nThElem_Prime  : (n) : n is none negative integer
nThElem_Divisor  : (d, n) : d is natural, n is none negative integer
nThElem_Divisor_Count  : (d)
nThElem_Factor_Prime  : (d, n) : d, n is natural
nThElem_Factor_Prime_Count  : (d)
nThElem_Factor_PrimePower  : (d, n) : d, n is natural
nThElem_Factor_PrimePower_Count  : (d)
nThElem_Modulus_Coprimes  : (d, n) : d, n is natural
nThElem_Modulus_PrimitiveRoots  : (d, n) : d, n is natural
nThElem_Modulus_PrimitiveRootFirst  : (d)
nThElem_Add_PowersRepresent  : (d, n) : d, n is natural
nThElem_Add_CountOfPowersRepresent  : (d)
nThElem_Add_SumByTwoSquares  : (d, n) : d, n is natural
nThElem_Add_CountOfSumByTwoSquares  : (d)
------------------------------------------------
Expand_ContinuedFrac  : (v, Count) : v는 수 또는 함수, Count = 자연수
Expand_Talor  : (F) : F is function
Expand_Integral  : (F) : F is function
Expand_SumAll  : (F) : F is function
------------------------------------------------
Poly_Expand  : (F) : F is function
Poly_Collapse  : (F) : F is function
Poly_Collapse_Differention  : (F) : F is function
------------------------------------------------
PolyExpand_Hermite  : (n, x) : n is none negative integer
PolyExpand_Laguerre  : (n, x) : n is none negative integer
PolyExpand_Bessel  : (n, x) : n is none negative integer
PolyExpand_BesselReserved  : (n, x) : n is none negative integer
PolyExpand_Tchebycheff_First  : (n, x) : n is none negative integer
PolyExpand_Tchebycheff_Second  : (n, x) : n is none negative integer
PolyExpand_Legendre  : (n, x) : n is none negative integer
PolyExpand_Legendre_Associated  : (m, n, x) : m, n is none negative integer
PolyExpand_Primitive  : (n, x) : n is natural > 1, 원시 방정식
PolyExpand_Symetric  : (n, x1, x2, ..., xk) : n is natural
PolyExpand_PowerSymetric  : (n, x1, x2, ..., xk) : n is natural
------------------------------------------------
NumThAdd_Partition  : (n) : n is natural
NumThAdd_Bell_Number  : (n) : n is none negative integer
// NumThAdd_Stirling_Number_First  : 수학적 의미가 부정확하여 처리를 미룸
NumThAdd_Stirling_Number_Second
------------------------------------------------
NumThBin_Binomial  : (a, b) : a, b is complex
NumThBin_Multinomial  : (a, k1, k2, k3, ...) : all arguments is complex
NumThBin_Catalan_Number  : (n) : n is none negative integer
------------------------------------------------
NumTh_Lcm  : (x1, x2, ...) : x is gauss integer
NumTh_Gcd  : (x1, x2, ...) : x is gauss integer
NumTh_Quotient  : (a, b) : a, b is gauss integer
NumTh_SumOfPower  : (a To b, n) : a, b, n is natural
------------------------------------------------
NumThMul_Legendre_Symbol  : (a, b) : a is integer, b is odd prime > 0
NumThMul_Jacobi_Symbol  : (a, b) : a is integer, b is odd integer > 0
NumThMul_Kronecker_Symbol  : (a, b) : a, b is integer
NumThMul_MoebiusMu  : (n) : n is integer > 0
NumThMul_Liouville  : = (-1)^PrimOmega(n)  : (n) : n is integer > 0
NumThMul_Dedekind_Psi  : (n) : n is integer > 0
NumThMul_Euler_Totient_Phi  : (n) : n is integer > 0
NumThMul_Carmichael_Lambda  : (n) : n is integer > 0
NumThMul_Mangoldt_Lambda  : (n) : n is integer > 0
NumThMul_DivisorSigma  : (n[, x]) : n is integer > 0, x is complex
NumThMul_DivisorSigmaAliquot  : (n[, x]) : n is integer > 0, x is complex
NumThMul_Dedekind_Sum  : (a, b, c) : a, b, c is integer > 0
NumThMul_PrimeOmega  : (n) : n is integer > 0
NumThMul_PrimeOmegaDistinct  : (n) : n is integer > 0
------------------------------------------------
NumThPrime_NearPrime  : (n) : n is real > 0
NumThPrime_PrimePi  : (n) : n is real > 0
NumThPrime_NextPrime  : (n) : n is real > 0
------------------------------------------------
STT_Fermi_Dirac_Complete  : (j, x) : j, x is complex
STT_Fermi_Dirac_Incomplete  : (j, x, low) : j, x is complex, low is real
STT_Cumulative_Distribution
------------------------------------------------
Method_Select  : Select(T/F, TruePart, FalsePart)
------------------------------------------------
Where  : Where(T/F)  :  Series 등에 사용되는 조건문
------------------------------------------------
Bool Type Function - Where문에서 사용
Is_Even  : (n) : n is integer
Is_Odd  : (n) : n is integer
Is_Natural  : (C) : C is complex
Is_Integer  : (C) : C is complex
Is_Rational  : (C) : C is complex
Is_Irrational  : (C) : C is complex
Is_UnReal  : (C) : C is complex
Is_Not  : Not(T/F)  :  Ex) IsNot(IsEven(a)) 등
------------------------------------------------ 여기까지 Base Is-Function
Is_Prime  : (n) : n is integer
Is_PrimePower  : (n) : n is integer
Is_SqaureFree  : (n) : n is integer
Is_Factor  : (n, m) : n, m is integer
Is_Divisible  : (n, m) : n, m is integer
Is_CoPrime  : (a1, a2, a3, ... ) : all arguments are integer
------------------------------------------------
※ 상기의 함수 목록은 제작 과정 중에 변경 또는 추가될 수 있습니다.

처리 엔진의 개략
위의 함수들은 심볼릭 연산 엔진을 기반으로 처리하게 됩니다.
즉, 모든 함수는 심볼릭 연산을 우선적으로 처리합니다.
따라서,
다항식이나 초월함수 등의 여러가지 수학적 형태를 있는 그대로 다루어 계산하게 됩니다.
출력값은,
기본적으로 복합 함수식이거나 미적분 꼴이 되고,
사용자가 추가적인 명령을 내리면, 복소수 또는 그래프로 출력할 수 있게 됩니다.

matheTOY Delta 버전의 수론 계산기 및 다항식 계산기에서 발전하여 더욱 강력해진 심볼릭 연산을 통해,
사용자들이 여러가지 수학적 연산을 깊이있게 실행해볼 수 있으리라 기대합니다.