diff -urN rt_v17/ax.py rt_v18/ax.py
--- rt_v17/ax.py	2018-04-03 10:03:55.000000000 +0900
+++ rt_v18/ax.py	2018-04-07 23:52:48.000000000 +0900
@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 
+import numpy as np
 import ut
 import mt
 import v
@@ -10,15 +11,15 @@
 def new(p, vs):
 	# vs: vecs
 
-	p = mt.to_arr(p)
-
 	e = ut.Empty()
 	e.typ = 'ax'
 	e.p = p
 	e.vs = vs
 
-	l2g = lambda p: vs.tr( 'l2g', p ) + e.p
-	g2l = lambda p: vs.tr( 'g2l', p - e.p )
+	#l2g = lambda p: vs.tr( 'l2g', p ) + e.p
+	#g2l = lambda p: vs.tr( 'g2l', p - e.p )
+	e.l2g = l2g = lambda p: vs.l2g(p) + e.p
+	e.g2l = g2l = lambda p: vs.g2l(p - e.p)
 	e.tr_p = lambda d, p: { 'l2g': l2g, 'g2l': g2l }.get(d, l2g)(p)
 	e.tr_v = lambda d, v: vs.tr(d, v)
 	e.tr_line = lambda d, l: line.new( e.tr_p(d, l.p), e.tr_v(d, l.v) )
@@ -36,9 +37,12 @@
 	def compo(ax_outside):
 		# o.p + o.vs x (i.p + i.vs x p)
 		# = (o.p + o.vs x i.p) + o.vs x i.vs x p
-		d = 'l2g'
-		vs_ = vecs.new( ut.map_lst( lambda v: ax_outside.tr(d, v, typ='v'), vs.v3 ) )
-		p_ = ax_outside.tr(d, p)
+
+		#d = 'l2g'
+		#vs_ = vecs.new( np.apply_along_axis( lambda v: ax_outside.tr(d, v, typ='v'), 1, vs.v3 ) )
+		#p_ = ax_outside.tr(d, p)
+		vs_ = vecs.new( np.apply_along_axis( lambda v: ax_outside.vs.l2g(v), 1, vs.v3 ) )
+		p_ = ax_outside.l2g(p)
 		return new(p_, vs_)
 	e.compo = compo
 
@@ -49,23 +53,24 @@
 		vs_ = vs.rev()
 		if not vs_:
 			return []
-		p_ = vs_.tr( 'l2g', -p )
+		#p_ = vs_.tr( 'l2g', -p )
+		p_ = vs_.l2g(-p)
 		return new(p_, vs_)
 	e.rev = rev
 
 	return e
 
-one = new( [0,0,0], vecs.one )
-slide = lambda sld: new(sld, vecs.one)
+one = new( mt.zero, vecs.one )
+slide = lambda sld: new( mt.arr( sld ), vecs.one)
 slide_x = lambda x: slide( [x,0,0] )
 slide_y = lambda y: slide( [0,y,0] )
 slide_z = lambda z: slide( [0,0,z] )
-zoom = lambda zm3: new( [0,0,0], vecs.one.zoom(zm3) )
+zoom = lambda zm3: new( mt.zero, vecs.one.zoom(zm3) )
 zoom_all = lambda zm: zoom( [zm,zm,zm] )
 zoom_x = lambda zm: zoom( [zm,1,1] )
 zoom_y = lambda zm: zoom( [1,zm,1] )
 zoom_z = lambda zm: zoom( [1,1,zm] )
-rot_y = lambda deg: new( [0,0,0], vecs.rot_y(deg) )
+rot_y = lambda deg: new( mt.zero, vecs.rot_y(deg) )
 rot = lambda l, deg: ( lambda ax: ax.rev().compo( rot_y(deg) ).compo(ax) )( new_line(l) )
 rot_x = lambda deg: rot(line.x1, deg)
 rot_z = lambda deg: rot(line.z1, deg)
diff -urN rt_v17/cross.py rt_v18/cross.py
--- rt_v17/cross.py	2018-04-04 18:29:49.000000000 +0900
+++ rt_v18/cross.py	2018-04-07 23:36:02.000000000 +0900
@@ -21,7 +21,7 @@
 		return False
 
 	pz = l.p[2]
-	t = -float(pz) / vz
+	t = -pz / vz
 	if t <= 0:
 		return False
 
@@ -69,7 +69,8 @@
 	w = math.sin(rad)
 	for i in range(n):
 		axi = ax.slide_y(-1).compo( ax.zoom([w,h,1]) ).compo( ax.rot_z(i*deg) )
-		crs_ = { 'l': axi.tr( 'g2l', crs.get('l') ), 'd': crs.get('d') }
+		#crs_ = { 'l': axi.tr( 'g2l', crs.get('l') ), 'd': crs.get('d') }
+		crs_ = { 'l': axi.tr_line( 'g2l', crs.get('l') ), 'd': crs.get('d') }
 		if triangle(crs_):
 			crs['t'] = crs_.get('t')
 			return True
@@ -131,7 +132,7 @@
 	ts = sorted( filter( lambda v: v > 0, ts ) )
 	if not ts:
 		return False
-	tpzs = map( lambda t: ( lambda x,y,z: (t, [x,y,z], z) )( *l.on_line_p(t) ), ts )
+	tpzs = map( lambda t: ( lambda p: (t, p, p[2]) )( l.on_line_p(t) ), ts )
 	tpzs = ut.filter_up_lst( lambda t,p,z: abs(z) < 1, tpzs )
 	if not tpzs:
 		return False
@@ -142,7 +143,7 @@
 
 def pipe_side_nv(crs):
 	(px, py, _) = crs.get('p')
-	crs['nv'] = v.unit( [px,py,0] )
+	crs['nv'] = v.unit( mt.arr( [px,py,0] ) )
 
 def cone_side(crs):
 	# 0 < z < 1
@@ -189,7 +190,7 @@
 	if not ts:
 		return False
 
-	tpzs = map( lambda t: ( lambda x,y,z: (t, [x,y,z], z) )( *l.on_line_p(t) ), ts )
+	tpzs = map( lambda t: ( lambda p: (t, p, p[2]) )( l.on_line_p(t) ), ts )
 	tpzs = ut.filter_up_lst( lambda t,p,z: 0<z and z<1 , tpzs )
 	if not tpzs:
 		return False
@@ -199,15 +200,21 @@
 	return True
 
 def cone_side_nv(crs):
-	(px, py, _) = crs.get('p')
-	(px, py, _) = v.unit( [px,py,0] )
-	crs['nv'] = v.unit( [px,py,1] )
+	p = crs.get('p').copy()
+	p[2] = 0
+	if all(p == 0):
+		crs['nv'] = mt.arr( [0,0,1] )
+		return
+	p = v.unit(p)
+	p[2] = 1
+	crs['nv'] = v.unit(p)
 
 def cross(crs):
 	l_g = crs.get('l_g')
 	d = crs.get('d')
 	l2g = d.get('l2g')
-	crs['l'] = lstx.tr( l2g, 'g2l', l_g )
+	#crs['l'] = lstx.tr( l2g, 'g2l', l_g )
+	crs['l'] = lstx.tr_line( l2g, 'g2l', l_g )
 
 	dic = {
 		'square': square,
@@ -247,7 +254,8 @@
 
 	l_nv = line.new( crs.get('p'), crs.get('nv') )
 	l2g = d.get('l2g')
-	crs['l_nv_g'] = l_nv_g = lstx.tr( l2g, 'l2g', l_nv )
+	#crs['l_nv_g'] = l_nv_g = lstx.tr( l2g, 'l2g', l_nv )
+	crs['l_nv_g'] = l_nv_g = lstx.tr_line( l2g, 'l2g', l_nv )
 	crs['p_g'] = l_nv_g.p
 	crs['nv_g'] = l_nv_g.v
 # EOF
diff -urN rt_v17/line.py rt_v18/line.py
--- rt_v17/line.py	2018-04-04 09:59:20.000000000 +0900
+++ rt_v18/line.py	2018-04-07 23:04:30.000000000 +0900
@@ -5,21 +5,18 @@
 import mt
 import v
 
-def new(p, v_):
-	p = mt.to_arr(p)
-	v_ = mt.to_arr(v_)
+def on_line_p(l, t):
+	return l.p + l.v * t
 
+def new(p, v_):
 	e = ut.Empty()
 	e.typ = 'line'
 	e.p = p
 	e.v = v_
-	e.on_line_p = lambda t: p + e.v * t
-	e.get_p_t = lambda : ( p, e.on_line_p(1) )
+	e.on_line_p = lambda t: p + v_ * t
+	#e.on_line_p = lambda t: on_line_p(e, t)
 
-	def tr_by_func(f):
-		(p, t) = map( f, e.get_p_t() )
-		return new_p2_no_unit(p, t) # no unit !!!
-	e.tr_by_func = tr_by_func
+	e.tr_by_func = lambda f: ( lambda p, t: new(p, t-p) )( f(p), f(p+v_) )
 
         ###
 
@@ -34,17 +31,16 @@
 		base = np.dot(l.v, e.v)
 		if base == 0:
 			return []
-		t = float( np.dot( e.p - l.p, e.v ) ) / base
+		t = np.dot( e.p - l.p, e.v ) / base
 		return l.on_line_p(t)
 	e.cross_plane_line = cross_plane_line
 
 	return e
 
-new_p2_no_unit = lambda p, t: new( p, t - p )
 new_p2 = lambda p, t: new( p, v.unit( t -  p ) )
 
-x1 = new( [0,0,0], v.x1 )
-y1 = new( [0,0,0], v.y1 )
-z1 = new( [0,0,0], v.z1 )
+x1 = new( mt.zero, v.x1 )
+y1 = new( mt.zero, v.y1 )
+z1 = new( mt.zero, v.z1 )
 
 # EOF
diff -urN rt_v17/mt.py rt_v18/mt.py
--- rt_v17/mt.py	2018-03-31 16:53:31.000000000 +0900
+++ rt_v18/mt.py	2018-04-06 15:33:20.000000000 +0900
@@ -3,8 +3,9 @@
 import math
 import numpy as np
 
-arr = lambda lst: np.array( lst, dtype=np.float32 )
-to_arr = lambda lst: arr(lst) if type(lst) != np.ndarray else lst
+arr = lambda lst: np.array( lst, dtype=np.float64 )
+zero = arr( [0,0,0] )
+#to_arr = lambda lst: arr(lst) if type(lst) != np.ndarray else lst
 T = lambda v: v.reshape(v.size, 1)
 
 linear_conv = lambda s, sa, sb, da, db: da + (s - sa) * (db - da) / float(sb - sa) if sa != sb else (da + db) * 0.5
@@ -12,11 +13,6 @@
 deg_to_rad = lambda deg: deg * math.pi / 180
 rad_to_deg = lambda rad: rad * 180 / math.pi
 
-def v3_rev(v3):
-	if np.linalg.det(v3) == 0:
-		return []
-	return np.linalg.inv(v3)
-
 ###
 
 def quadratic_formula(a, b, c):
diff -urN rt_v17/rt.py rt_v18/rt.py
--- rt_v17/rt.py	2018-04-04 21:33:33.000000000 +0900
+++ rt_v18/rt.py	2018-04-07 23:33:23.000000000 +0900
@@ -20,21 +20,24 @@
 
 	def f(m):
 		xyz2g = m.get('xyz2g')
-		nv_line = lstx.tr( xyz2g, 'g2l', crs.get('l_nv_g') )
+		#nv_line = lstx.tr( xyz2g, 'g2l', crs.get('l_nv_g') )
+		nv_line = lstx.tr_line( xyz2g, 'g2l', crs.get('l_nv_g') )
 		img_nv = v.z1
 		if np.dot( nv_line.v, img_nv ) < 0:
 			return []
 		fn = m.get( 'fn_r' if rev else 'fn', '' )
 		if not fn:
 			return []
-		(x, y, _) = lstx.tr( m.get('wh2xyz'), 'g2l', nv_line.p )
+		#(x, y, _) = lstx.tr( m.get('wh2xyz'), 'g2l', nv_line.p )
+		(x, y, _) = lstx.tr_p( m.get('wh2xyz'), 'g2l', nv_line.p )
 		sec = video.cur_sec()
 		return img.col( fn, sec, int(x), int(y), [] )
 
 	cols = map( f, d.get('maps') )
 	cols = ut.filter_lst( lambda col: col != [], cols )
-	col = np.sum(cols, axis=0) if cols else def_col
-	return ut.map_lst( lambda v: min(v, 255), col )
+	if not cols:
+		return def_col
+	return np.fmin( np.sum(cols, axis=0), 255 )
 
 ref_rate = ut.arg_f('ref_rate', 0.001)
 
@@ -65,7 +68,6 @@
 	nv = v.unit( crs.get('nv_g') )
 
 	eyev = v.unit(l_g.v)
-	eyev_nega = -eyev
 	ang_nv_eyev = np.dot( nv, eyev )
 	ang_nv_eyev_nega = -ang_nv_eyev
 	rev = ang_nv_eyev_nega < 0
@@ -81,7 +83,10 @@
 		def f(ltd):
 			ltv = ltd.get( 'v', mt.arr( [0,0,-1] ) )
 			if 'p' in ltd:
-				ltv = v.unit( crsp - ltd.get('p') )
+				ltv = crsp - ltd.get('p')
+				if all(ltv == 0):
+					return 0
+				ltv = v.unit(ltv)
 			ang_nv_lt = np.dot( nv, ltv )
 			ang_nv_lt_nega = -ang_nv_lt
 			if ang_nv_eyev_nega * ang_nv_lt_nega < 0:
@@ -117,7 +122,7 @@
 		if ang_nv_eyev < 0:
 			density = 1.0 / density
 		r_sin_v = sin_v * density
-		sin_len2 = v.len2( r_sin_v )
+		sin_len2 = np.dot( r_sin_v, r_sin_v )
 		sin_len2 = min( sin_len2, 1 )
 		cos_len = math.sqrt( 1 - sin_len2 )
 		r_cos_v = cos_v * ( cos_len / v.len1( cos_v ) )
@@ -145,10 +150,11 @@
 	show = '-quiet' not in sys.argv
 	while cnt.up(show):
 		(ix, iy) = cnt.cur()
-		p = lstx.tr( wh2g, 'l2g', mt.arr( [ix,iy,-d_] ) )
+		#p = lstx.tr( wh2g, 'l2g', mt.arr( [ix,iy,-d_] ) )
+		p = lstx.tr_p( wh2g, 'l2g', mt.arr( [ix,iy,-d_] ) )
 		l_g = line.new_p2(eye2g.p, p)
 		col = get_col(data, lights, l_g, video)
-		col = ut.map_lst( lambda v: min( int(v), 255 ), col )
 		if col != []:
+			col = np.fmin( col, 255 )
 			video.set(ix, iy, col)
 # EOF
diff -urN rt_v17/ut.py rt_v18/ut.py
--- rt_v17/ut.py	2018-04-03 09:55:40.000000000 +0900
+++ rt_v18/ut.py	2018-04-07 23:48:39.000000000 +0900
@@ -123,7 +123,7 @@
 		if e.i >= n:
 			return 'fin ' + str_hms(e.total_sec)
 		rest = e.total_sec - ( now_sec() - e.st_sec )
-		return 'rest {} : {}'.format( str_hms(rest), str_dt( e.st_sec + e.total_sec ) )
+		return 'total {} : rest {} : {}'.format( str_hms(e.total_sec), str_hms(rest), str_dt( e.st_sec + e.total_sec ) )
 
 	pcent = lambda : Decimal(100*e.i/n).quantize( Decimal('1.0') )
 	stat_str = lambda : '{}{}/{}({}%) : {}'.format( id_str, e.i, n, pcent(), fin_str() )
diff -urN rt_v17/v.py rt_v18/v.py
--- rt_v17/v.py	2018-04-01 11:55:34.000000000 +0900
+++ rt_v18/v.py	2018-04-06 15:51:25.000000000 +0900
@@ -4,18 +4,16 @@
 import numpy as np
 import mt
 
-zero = mt.arr( [0,0,0] )
+zero = mt.zero
 one = mt.arr( [1,1,1] )
 x1 = mt.arr( [1,0,0] )
 y1 = mt.arr( [0,1,0] )
 z1 = mt.arr( [0,0,1] )
 all = lambda e: mt.arr( [e,e,e] )
 
-len2 = lambda v: np.dot(v,v)
-
 len1 = lambda v: np.linalg.norm(v)
 
-unit = lambda v: ( lambda l: v / l if l != 0 else z1 )( np.linalg.norm( mt.to_arr(v) ) ) # !
+unit = lambda v: v / np.linalg.norm(v)
 
 cross_product_unit = lambda va, vb: unit( np.cross(va, vb) )
 
diff -urN rt_v17/vecs.py rt_v18/vecs.py
--- rt_v17/vecs.py	2018-04-02 17:18:41.000000000 +0900
+++ rt_v18/vecs.py	2018-04-07 23:41:35.000000000 +0900
@@ -9,23 +9,22 @@
 def new(v3):
 	# v3: [ v.x1, v.y1, v.z1 ]
 
-	v3 = mt.to_arr(v3)
-
 	e = ut.Empty()
 	e.typ = 'vecs'
 	e.v3 = v3
-	l2g = lambda v_: np.dot( v3.T, v_ )
-	g2l = lambda v: e.rev().tr('l2g', v)
+	e.l2g = l2g = lambda v_: np.dot( v3.T, v_ )
+	#e.g2l = g2l = lambda v: e.rev().tr('l2g', v)
+	e.g2l = g2l = lambda v: e.rev().l2g(v)
 	e.tr = lambda d, v: { 'l2g': l2g, 'g2l': g2l }.get(d, l2g)(v)
 
 	e.rev_vs = None
 	def rev():
 		if not e.rev_vs:
-			e.rev_vs = new( mt.v3_rev(v3) )
+			e.rev_vs = new( np.linalg.inv(v3) )
 		return e.rev_vs
 	e.rev = rev
 
-	e.zoom = lambda zm3: new( v3 * mt.T( mt.to_arr(zm3) ) )
+	e.zoom = lambda zm3: new( v3 * mt.T( mt.arr(zm3) ) )
 	e.zoom_all = lambda zm: e.zoom( [zm,zm,zm] )
 	e.zoom_x = lambda zm: e.zoom( [zm,1,1] )
 	e.zoom_y = lambda zm: e.zoom( [1,zm,1] )
@@ -33,7 +32,7 @@
 
 	return e
 
-one = new( [v.x1, v.y1, v.z1] )
+one = new( mt.arr( [v.x1, v.y1, v.z1] ) )
 
 def by_fix_ref(fix_nm, fix, ref_nm, ref):
 	fix_i = 'xyz'.index(fix_nm)
@@ -56,7 +55,7 @@
 	(a, b) = (fix, c) if (fix_i + 1) % 3 == i else (c, fix)
 	v3[ref_i] = v.cross_product_unit(a, b)
 	
-	return new(v3)
+	return new( mt.arr(v3) )
 
 def rot_y(deg):
 	rad = mt.deg_to_rad(deg)
@@ -77,5 +76,5 @@
 	z = (zx, zy, zz)
 	v3 = (x, y, z)
 
-	return new(v3)
+	return new( mt.arr(v3) )
 # EOF
diff -urN rt_v17/way.py rt_v18/way.py
--- rt_v17/way.py	2018-04-04 17:07:41.000000000 +0900
+++ rt_v18/way.py	2018-04-06 15:34:11.000000000 +0900
@@ -15,7 +15,7 @@
 
 def get_idx_t(ts, t):
 	s = sum(ts)
-	t -= int( float(t) / s ) * s
+	t -= int( t / s ) * s
 	s = 0
 	for i in range( len(ts) ):
 		if s <= t and t <= s + ts[i]:
@@ -30,7 +30,7 @@
 		return None
 	j = (i + 1) % len(lst)
 	(v2, _) = lst[j]
-	return float(v2 - v) / t
+	return (v2 - v) / t
 
 def get(lst, t, itp3=False):
 	# itp3 is using mt.interp3
@@ -49,7 +49,7 @@
 		k0 = f(ka, kb, ti)
 		k1 = f(kb, kc, ti)
 
-		(v, k) = mt.interp3( vs[idx], vs[(idx+1)%n], k0, k1, float(t)/ti )
+		(v, k) = mt.interp3( vs[idx], vs[(idx+1)%n], k0, k1, t/ti )
 		return v
 
 	return mt.linear_conv( t, 0, ts[idx], vs[idx], vs[(idx+1)%n] )
diff -urN rt_v17/wf.py rt_v18/wf.py
--- rt_v17/wf.py	2018-04-04 18:24:52.000000000 +0900
+++ rt_v18/wf.py	2018-04-06 15:33:56.000000000 +0900
@@ -83,7 +83,7 @@
 	return ([],[])
 
 def nv_clip(nv, pa, pb):
-	nv_line = line.new( [0,0,0], nv )
+	nv_line = line.new( mt.zero, nv )
 	(in_a, in_b) = ut.map_lst( lambda p: nv_line.is_plane_side(p), [pa, pb] )
 	if in_a and in_b:
 		return [pa, pb]
@@ -98,7 +98,7 @@
 	p4 = mt.arr( [ [0,0,-d], [w,0,-d], [w,h,-d], [0,h,-d] ] )
 	p4 = ut.map_lst( lambda p: lstx.tr(wh2eye, 'l2g', p), p4 )
 	for i in range(n):
-		nv = v.p3_to_nv( mt.arr( [0,0,0] ), p4[i], p4[(i+1)%n] )
+		nv = v.p3_to_nv( mt.zero, p4[i], p4[(i+1)%n] )
 		r = nv_clip(nv, pa, pb)
 		if not r:
 			return []