Revision ecc02a93ab91dcf160aeb7d64a1954671e83ddde authored by Mark Clements on 01 November 2018, 21:30:03 UTC, committed by cran-robot on 01 November 2018, 21:30:03 UTC
1 parent 4f6cced
math.org
``````
* Axiom/Fricas source file

** General case

#+begin_src axiom :exports results :results output
)cl p all
η := operator 'η
G := operator 'G
rule1 := rule (D(η(t,β),β)==X; D(η(t,β),t)==XD*β; D(η(t,β),[t,β])==XD; η(t,β)==X*β)
S := G(η(t,β))
H := -log(S)
h := D(H,t)
[D(expr,β) for expr in [S,H,h]]
[rule1 expr for expr in [S,H,h]]
[rule1 D(expr,β) for expr in [S,H,h]]
#+end_src

#+RESULTS:
#+begin_example
(1) -> )cl p all
(1) -> η := operator 'η

(1)  η
Type: BasicOperator
(2) -> G := operator 'G

(2)  G
Type: BasicOperator
(3) -> rule1 := rule (D(η(t,β),β)==X; D(η(t,β),t)==XD*β; D(η(t,β),[t,β])==XD; η(t,β)==X*β)

(3)  {η  (t,β) == X,η  (t,β) == XD β,η    (t,β) == XD,η(t,β) == X β}
,2            ,1               ,1,2
Type: Ruleset(Integer,Integer,Expression(Integer))
(4) -> S := G(η(t,β))

(4)  G(η(t,β))
Type: Expression(Integer)
(5) -> H := -log(S)

(5)  - log(G(η(t,β)))
Type: Expression(Integer)
(6) -> h := D(H,t)

,
G (η(t,β))η  (t,β)
,1
(6)  - ------------------
G(η(t,β))
Type: Expression(Integer)
(7) -> [D(expr,β) for expr in [S,H,h]]

(7)
,
G (η(t,β))η  (t,β)
,                               ,2
[G (η(t,β))η  (t,β), - ------------------,
,2              G(η(t,β))

,                                               ,,
- G(η(t,β))G (η(t,β))η    (t,β) - G(η(t,β))η  (t,β)η  (t,β)G  (η(t,β))
,1,2                  ,1      ,2
+
,        2
G (η(t,β)) η  (t,β)η  (t,β)
,1      ,2
/
2
G(η(t,β))
]
Type: List(Expression(Integer))
(8) -> [rule1 expr for expr in [S,H,h]]

,
XD βG (X β)

(8)  [G(X β),- log(G(X β)),- -----------]
G(X β)
Type: List(Expression(Integer))
(9) -> [rule1 D(expr,β) for expr in [S,H,h]]

(9)
,
XG (X β)
,
[XG (X β), - --------,
G(X β)
,,                ,     2             ,
- X XD β G(X β)G  (X β) + X XD β G (X β)  - XD G(X β)G (X β)

------------------------------------------------------------]
2
G(X β)
Type: List(Expression(Integer))

#+end_example

** Proportional hazards
#+begin_src axiom :exports results :results output
G(x) == exp(-exp(x))
S := G(η(t,β))
H := -log(S)
h := D(H,t)
D(G(x),x)
[rule1 expr for expr in [S,H,h]]
[rule1 D(expr,β) for expr in [S,H,h]]
#+end_src

#+RESULTS:
#+begin_example
(10) -> G(x) == exp(-exp(x))
Type: Void
(11) -> S := G(η(t,β))
Compiling function G with type Expression(Integer) -> Expression(
Integer)

η(t,β)
- %e
(11)  %e
Type: Expression(Integer)
(12) -> H := -log(S)

η(t,β)
(12)  %e
Type: Expression(Integer)
(13) -> h := D(H,t)

η(t,β)
(13)  %e      η  (t,β)
,1
Type: Expression(Integer)
(14) -> D(G(x),x)
Compiling function G with type Variable(x) -> Expression(Integer)

x
x  - %e
(14)  - %e %e
Type: Expression(Integer)
(15) -> [rule1 expr for expr in [S,H,h]]

X β
- %e      X β        X β
(15)  [%e       ,%e   ,XD β %e   ]
Type: List(Expression(Integer))
(16) -> [rule1 D(expr,β) for expr in [S,H,h]]

X β
X β  - %e        X β                X β
(16)  [- X %e   %e       ,X %e   ,(X XD β + XD)%e   ]
Type: List(Expression(Integer))

#+end_example

** Proportional odds

#+begin_src axiom :exports results :results output
G(x) == 1/(1+exp(x))
S := G(η(t,β))
H := -log(S)
h := D(H,t)
D(G(x),x)
[rule1 expr for expr in [S,H,h]]
[rule1 D(expr,β) for expr in [S,H,h]]
#+end_src

#+RESULTS:
#+begin_example
(17) -> G(x) == 1/(1+exp(x))
Compiled code for G has been cleared.
1 old definition(s) deleted for function or rule G
Type: Void
(18) -> S := G(η(t,β))
Compiling function G with type Expression(Integer) -> Expression(
Integer)

1
(18)  ------------
η(t,β)
%e       + 1
Type: Expression(Integer)
(19) -> H := -log(S)

1
(19)  - log(------------)
η(t,β)
%e       + 1
Type: Expression(Integer)
(20) -> h := D(H,t)

η(t,β)
%e      η  (t,β)
,1
(20)  ----------------
η(t,β)
%e       + 1
Type: Expression(Integer)
(21) -> D(G(x),x)
Compiling function G with type Variable(x) -> Expression(Integer)

x
%e
(21)  - -----------------
x 2      x
(%e )  + 2%e  + 1
Type: Expression(Integer)
(22) -> [rule1 expr for expr in [S,H,h]]

X β
1               1      XD β %e
(22)  [---------,- log(---------),----------]
X β             X β         X β
%e    + 1       %e    + 1   %e    + 1
Type: List(Expression(Integer))
(23) -> [rule1 D(expr,β) for expr in [S,H,h]]

X β             X β        X β 2                  X β
X %e            X %e     XD (%e   )  + (X XD β + XD)%e
(23)  [- ---------------------,---------,--------------------------------]
X β 2      X β       X β              X β 2      X β
(%e   )  + 2%e    + 1 %e    + 1       (%e   )  + 2%e    + 1
Type: List(Expression(Integer))

#+end_example

** Probit

Is there a more canonical approach in Axiom?

#+begin_src axiom :exports results :results output
Φ := operator 'Φ
φ := operator 'φ
rule2 == rule D(Φ(x),x)==φ(x)
G(x) == Φ(-x)
S := G(η(t,β))
H := -log(S)
h := D(H,t)
rule2 D(G(x),x)
[rule1 rule2 expr for expr in [S,H,h]]
[rule1 rule2 D(expr,β) for expr in [S,H,h]]
#+end_src

#+RESULTS:
#+begin_example
(24) -> Φ := operator 'Φ

(24)  Φ
Type: BasicOperator
(25) -> φ := operator 'φ

(25)  φ
Type: BasicOperator
(26) -> rule2 == rule D(Φ(x),x)==φ(x)
Type: Void
(27) -> G(x) == Φ(-x)
Compiled code for G has been cleared.
1 old definition(s) deleted for function or rule G
Type: Void
(28) -> S := G(η(t,β))
Compiling function G with type Expression(Integer) -> Expression(
Integer)

(28)  Φ(- η(t,β))
Type: Expression(Integer)
(29) -> H := -log(S)

(29)  - log(Φ(- η(t,β)))
Type: Expression(Integer)
(30) -> h := D(H,t)

,
Φ (- η(t,β))η  (t,β)
,1
(30)  --------------------
Φ(- η(t,β))
Type: Expression(Integer)
(31) -> rule2 D(G(x),x)
Compiling function G with type Variable(x) -> Expression(Integer)
Compiling body of rule rule2 to compute value of type RewriteRule(
Integer,Integer,Expression(Integer))

(31)  - φ(- x)
Type: Expression(Integer)
(32) -> [rule1 rule2 expr for expr in [S,H,h]]

XD β φ(- X β)
(32)  [Φ(- X β),- log(Φ(- X β)),-------------]
Φ(- X β)
Type: List(Expression(Integer))
(33) -> [rule1 rule2 D(expr,β) for expr in [S,H,h]]

(33)
X φ(- X β)
[- X φ(- X β), ----------,
Φ(- X β)
,                         2
- X XD β Φ(- X β)φ (- X β) + X XD β φ(- X β)  + XD Φ(- X β)φ(- X β)

-------------------------------------------------------------------]
2
Φ(- X β)
Type: List(Expression(Integer))

#+end_example

#+begin_src axiom :exports results :results output
G(x) == exp(-x)
S := G(η(t,β))
H := -log(S)
h := D(H,t)
D(G(x),x)
[rule1 expr for expr in [S,H,h]]
[rule1 D(expr,β) for expr in [S,H,h]]
#+end_src

#+RESULTS:
#+begin_example
(34) -> G(x) == exp(-x)
Compiled code for G has been cleared.
1 old definition(s) deleted for function or rule G
Type: Void
(35) -> S := G(η(t,β))
Compiling function G with type Expression(Integer) -> Expression(
Integer)

- η(t,β)
(35)  %e
Type: Expression(Integer)
(36) -> H := -log(S)

(36)  η(t,β)
Type: Expression(Integer)
(37) -> h := D(H,t)

(37)  η  (t,β)
,1
Type: Expression(Integer)
(38) -> D(G(x),x)
Compiling function G with type Variable(x) -> Expression(Integer)

- x
(38)  - %e
Type: Expression(Integer)
(39) -> [rule1 expr for expr in [S,H,h]]

- X β
(39)  [%e     ,X β,XD β]
Type: List(Expression(Integer))
(40) -> [rule1 D(expr,β) for expr in [S,H,h]]

- X β
(40)  [- X %e     ,X,XD]
Type: List(Expression(Integer))

#+end_example

** Aranda-Ordaz
#+begin_src axiom :exports results :results output
G(x) == exp(-log(θ*exp(x)+1)/θ)
S := G(η(t,β))
H := -log(S)
h := D(H,t)
D(G(x),x)
[rule1 expr for expr in [S,H,h]]
[rule1 D(expr,β) for expr in [S,H,h]]
#+end_src

#+RESULTS:
#+begin_example
(41) -> G(x) == exp(-log(θ*exp(x)+1)/θ)
Compiled code for G has been cleared.
1 old definition(s) deleted for function or rule G
Type: Void
(42) -> S := G(η(t,β))
Compiling function G with type Expression(Integer) -> Expression(
Integer)

η(t,β)
log(θ %e       + 1)
- -------------------
θ
(42)  %e
Type: Expression(Integer)
(43) -> H := -log(S)

η(t,β)
log(θ %e       + 1)
(43)  -------------------
θ
Type: Expression(Integer)
(44) -> h := D(H,t)

η(t,β)
%e      η  (t,β)
,1
(44)  ----------------
η(t,β)
θ %e       + 1
Type: Expression(Integer)
(45) -> D(G(x),x)
Compiling function G with type Variable(x) -> Expression(Integer)

x
log(θ %e  + 1)
- --------------
x           θ
%e %e
(45)  - ---------------------
x
θ %e  + 1
Type: Expression(Integer)
(46) -> [rule1 expr for expr in [S,H,h]]

X β
log(θ %e    + 1)
- ----------------         X β              X β
θ        log(θ %e    + 1)  XD β %e
(46)  [%e                  ,----------------,-----------]
θ            X β
θ %e    + 1
Type: List(Expression(Integer))
(47) -> [rule1 D(expr,β) for expr in [S,H,h]]

(47)
X β
log(θ %e    + 1)
- ----------------
X β            θ               X β
X %e   %e                      X %e
[- ---------------------------, -----------,
X β                  X β
θ %e    + 1          θ %e    + 1
X β 2                  X β
XD θ (%e   )  + (X XD β + XD)%e
----------------------------------]
2   X β 2        X β
θ (%e   )  + 2θ %e    + 1
Type: List(Expression(Integer))

#+end_example