fi

print "fi"

sqrt: :square-root

fi: (1 + sqrt 5) / 2

x: 1 + fi

{

1 3  7  18 47 123

1 =
2 = 3 - 1
3 =
4 = 3 + 1       >1 , <=4    , f 4 = [ 3 1]
--------------
5 = 7 - 3 + 1 ,  >4 , >=11 , f 5  = [7 -3 1]
6 = 7 - 1                  , f 6 =  [7 -1]
7 =
8 = 7 + 1
9 = 7 + 3 - 1
10 = 7 + 3
11 = 7 + 3 + 1              . f 11 = [7 3 1]
------------------
12 = 18 - 7 + 1   >11 , <=29  , f 12 = [18 -7 1]
13
14
15
16 = 18 - 3 + 1
17 = 18 - 1
18 = 18
19 = 18 + 1
29 = 18 + 7 + 3  + 1
--------------------------
47 =
}

index: [ 0 1 3  7  18 47 123 ]

m: 0

limit: clear copy [] ; [1 4 11 29 76 199]

foreach n index [ m: m + n  insert tail limit m ]



;---------------------------------

f: func [ n /local m tmp i][

  tmp: clear copy []

  i: 1

  for m -1 + length? limit 1  -1 [

if all [ n > limit/:m n <= limit/(m + 1) ][n: n - index/(m + 1 )  insert tail tmp   index/(m + 1) * i  if n < 0 [ i: i * -1 ] n: abs n ]

]
return tmp
]

g: func [ v /local a b y n ][ a: 0 b: 0 n: 0 y: x  foreach  m v [ n: n + 1 if all [ n = length? v 1 = abs m ][y: 1]    a: a +  ((sign? m) * power y abs m) b: b +  ((sign? m) / power y  abs m ) ] return a * b ]

h: func [ v /local a b y n ][ a: 0 b: 0 n: 0 y: x  foreach  m v [   a: a +  ((sign? m/1) * power y abs m/2) b: b +  ((sign? m/1) / power y  abs m/2 ) ] return a * b ]

val: h [[1 4] [1 2] [1 0]] ; = 64

source val


{
"x^^4+x^^2+1"

h [[1 4] [1 2] [1 0]]

(( power x 4) + (power x 2) + 1 ) * ((1 / power x 4) + (1 / power x 2) + 1 ) = 64 , g [ 4 2 1]
}

{

((power x 2) - 1 ) * ((1 / power x 2) - (1 / 1 )) = -5 , (x^2-1)(1/x^2-1) = -x^2+2 . [ 2 -1] , h [ [1 2] [-1 0]]
((power x 2) + 1 ) * ((1 / power x 2) + (1 / 1 )) = 9 ,  (x^2+1)(1/x^2+1) =  x^2+2 , [ 2 1] ,  h [ [1 2] [1 0]]
((power x 3) - 1 ) * ((1 / power x 3) - (1 / 1 )) = -16 ,(x^3-1)(1/x^3-1) = -x^3+2 , [ 3 -1] , h [ [1 3] [-1 0]]
((power x 3) + 1 ) * ((1 / power x 3) + (1 / 1 )) = 20  ,(x^3+1)(1/x^3+1) =  x^3+2  , [ 3 1 ] , h [ [1 3] [1 0]]
((power x 4) - 1 ) * ((1 / power x 4) - (1 / 1 )) = -45                             , [ 4 -1]
(power x 4) + 1 ) * ((1 / power x 4) + (1 / 1 )) = 49                               , [ 4 1

}

;------------------------------------------------------


vec-to-str: func [ v /local s n ][n: 0 s: clear copy {} foreach m v [

 n: n + 1

 either  m/1 < 0 [ insert tail s "-" ] [if n <> 1 [insert tail s "+" ]]

 insert  tail s ajoin [ either 1 = abs m/1 [clear copy "" ] [ajoin [ m/1 "*"] ] either 0 = m/2 ["1"][ ajoin ["x^^" m/2]]]]

return s ]

s: vec-to-str [ [ 1 3] [2 2 ] [ -1 0 ]] ; "x^^3+2*x^^2-1"
source s

s: vec-to-str [ [ 1 3] [-1 2 ] [ 1 0 ]] ; "x^^3-x^^2+1"
source s
;-----------------------------------------------------------------------------------

str-to-vec: func [ s /local v i a b int ][

i: 0 v: clear copy []

int: charset "0123456789"

parse/all s [some [["-" (i: -1  )| "+" (i: 1) | (i: 1) ][ copy a some int "*x" | "x" (a: 1 ) | copy a some int] (a: i * to-integer a ) "^^"  copy b some int (b: to-integer b insert tail v reduce [reduce [ a b ]] )] opt END (insert tail v reduce [reduce [a 0] ]) ] return v ]

v: str-to-vec "x^^3+2*x^^2-1" ; [[1 3] [2 2] [-1 0]]
source v

v: str-to-vec "x^^3-x^^2+1" ; [[1 3] [-1 2] [ 1 0]]
source v

;-------------------------------------------------------------------------------------

inv-vec: func [ v /local u m o ][

u: clear copy []

o: v/1/2

 foreach m v [ insert tail u reduce [reduce [ m/1 o - m/2]]]

sort/compare u func [ a b ][ a/2 > b/2]

return u ]

v: inv-vec [[1 4] [1 2] [1 0]]

source v
;--------------------------------------------------------


mul-vec: func [ v1 v2 /local v3 v4 k l n m][

v3: clear copy []

v4: clear copy []


for k 1 length? v1 1 [

for l 1 length? v2 1 [

insert tail v3 reduce [reduce [v1/:k/1 * v2/:l/1 v1/:k/2 + v2/:l/2  ]]

] ]

sort/compare v3 func [ a b ][ a/2 > b/2]

source v3

a: v3/1/1
b: v3/1/2

until [

remove v3

attempt [

either b = v3/1/2 [ a: a + v3/1/1 ] [insert tail v4 reduce [ reduce [a b ] ]

a: v3/1/1
b: v3/1/2

]]

empty? v3
]

return v4

]

;--------------------------------------------

v: mul-vec [[1 4] [1 2] [1 0]] [[1 4] [1 2] [1 0]] ; [[1 8] [1 6] [1 6] [1 4] [1 4] [1 4] [1 2] [1 2] [1 0]] = [[1 8] [ 2 6] [3 4]  [2 2] [1 0]] = x^4 + 2 x^2 + 3

source v

;---------------------

halt
{

(1+x^2+x^4)*(1+1/x^2+1/x^4) =(x^4 + x^2 + 1)^2/x^4 = x^2+2x+3

"x^^4+x^^2+1" [[1 4] [1 2] [1 0]]

(power x 3) - (power x 2) - (power x ) 1 ) * ((1 / power x 4) + (1 / 1 ))

}


halt