(*******************************************************************
This file was generated automatically by the Mathematica front end.
It contains Initialization cells from a Notebook file, which
typically will have the same name as this file except ending in
".nb" instead of ".m".

This file is intended to be loaded into the Mathematica kernel using
the package loading commands Get or Needs.  Doing so is equivalent
to using the Evaluate Initialization Cells menu command in the front
end.

DO NOT EDIT THIS FILE.  This entire file is regenerated
automatically each time the parent Notebook file is saved in the
Mathematica front end.  Any changes you make to this file will be
overwritten.
***********************************************************************)

























































BeginPackage["DecisionModels`DecisionModels`"]





DecisionMatrix::usage="DecisionMatrix[g,a,b] berechnet die \
Konsequenzen-Matrix der Werte g(x,y) zu gegebenen Strategien x (aus a) und y \
(aus b)."

ScaleTransform::usage="ScaleTransform[{a0,b0},{a1,b1}] ist die lineare \
(monoton wachsende) Funktion, die das Intervall [a0;b0] auf das Intervall \
[a1;b1] abbildet."

ScaleNorm::usage="ScaleNorm[a,b] ist die Skalentransformation (vgl. \
ScaleTransform), die das Intervall [a;b] auf das Einheitsintervall [0;1] \
abbildet."

NormalizeValue::usage="NormalizeValue[x,{xmin,xmax}] berechnet den Wert von x \
unter der Skalentransformation, die das reelle Intervall [xmin;xmax] auf das \
Einheitsintervall [0;1] abbildet."

NormalizeRange::usage="NormalizeRange[data] bildet den gesamten Datenbereich \
data durch eine Skalentransformation auf das Einheitsintervall [0;1] ab."

NormalizeFunction::usage="NormalizeFunction[f,{a,b}] berechnet die \
Skalen-Normierte der reellen Funktion f \[UDoubleDot]ber dem abgeschlossenen \
Intervall [a;b]."



LinUtility::usage="LinUtility[k0,k1,Normalize->False] ist die lineare \
(Nutzen-)funktion u[c]=k0+k1*c. Mit der Option Normalize->{a,b} wird die \
Skalen-Normierte \[UDoubleDot]ber dem Intervall [a;b] ausgegeben."

QuadUtility::usage="QuadUtility[k0,k1,k2] ist die quadratische \
(Nutzen-)Funktion u[c]=k0+k1*c+k2*c^2."

ExpUtility::usage="ExpUtility[k0,k1,k2] ist die exponentielle \
(Nutzen-)Funktion u[c]=k0+k1*Exp[k2*c]."

LogUtility::usage="LogUtility[k0,k1] ist die (Nutzen-)Funktion \
u[c]=k0+k1*Log[c]. Mit der Option Normalize->{a,b} wird die Skalen-Normierte \
\[UDoubleDot]ber dem Intervall [a;b] (0<a<b) ausgegeben."

SqrtUtility::usage="SqrtUtility[k0,k1] ist die (Nutzen-)Funktion \
u[c]=k0+k1*Sqrt[c]. Mit der Option Normalize->{a,b} wird die Skalen-Normierte \
\[UDoubleDot]ber dem Intervall [a;b] (0<=a<b) ausgegeben."

CompoundUtility::usage="CompoundUtility[scores,maxscore,weights] berechnet zu \
gegebener Nutzwertfolge scores relativ zum Maximalwert maxscore den \
gemischten (= gewichteten) Nutzenwert. Die Liste weights enth\[ADoubleDot]lt \
die erforderlichen Gewichte in passender Anzahl (= Anzahl zu mischender \
Werte)."



PresentValue::usage="PresentValue[c,q] berechnet den Barwert der \
Zahlungsreihe (Liste c) bei vorliegender Liste q von Diskontierungsfaktoren. \
Bedingung: L\[ADoubleDot]nge von c = 1 + L\[ADoubleDot]nge von q."

PresentValueAtRate::usage="PresentValueAtRate[c,r] berechnet den Barwert der \
Zahlungsreihe (Liste c) bei der kalkulatorischen Zinsrate r."

PresentValueGraph::usage="PresentValueGraph[c,rmin,rmax,(Optionen)] zeichnet \
den Funktionsgraphen zu PresentValueAtRate[c,r]."

InterestRatePoly::usage="InterestRatePoly[c] berechnet die (reine) \
Polynomfunktion zur Zahlungsreihe c (Liste)."

InterestRateRealZeros::usage="InterestRateRealZeros[c] berechnet die Menge \
der reellen Nullstellen des Polynoms InterestRatePoly[c]. Vgl. auch \
InternalRate[c]."

InternalRate::usage="InternalRate[c,(rstart)] berechnet f\[UDoubleDot]r die \
Zahlungsreihe c (Liste) die interne Zinsrate (Rendite). Der optionale \
Startwert rstart ist auf 0 voreingestellt."

PositiveInvestmentQ::usage="PositiveInvestmentQ[c] entscheidet \
f\[UDoubleDot]r Zahlungsreihen c (Liste)mit positiver Nettosumme, ob sie eine \
eindeutige positive Rendite besitzen."



HurwiczValue::usage="HurwiczValue[u,lambda] berechnet den Wert eines \
Nutzenvektors u bei angenommenem Optimismus-Parameter lambda."

HurwiczSolve::usage="HurwiczSolve[u,lambda] berechnet die \
L\[ODoubleDot]sungsmenge eines Entscheidungsproblems mit Nutzenmatrix u bei \
angenommenem Optimismus-Parameter lambda."

MaximinSolve::usage="MaximinSolve[u] berechnet die L\[ODoubleDot]sungsmenge \
eines Entscheidungsproblems mit Nutzenmatrix u bei v\[ODoubleDot]lligem \
Pessimismus (Hurwicz-Lambda = 0)."

MaximaxSolve::usage="MaximaxSolve[u] berechnet die L\[ODoubleDot]sungsmenge \
eines Entscheidungsproblems mit Nutzenmatrix u bei v\[ODoubleDot]lligem \
Optimismus (Hurwicz-Lambda = 1)."

RegretMatrix::usage="RegretMatrix[u] berechnet aus der Nutzenmatrix u die \
zugeh\[ODoubleDot]rige Matrix der Bedauernswerte nach L. Savage."

SavageSolve::usage="SavageSolve[u] berechnet die L\[ODoubleDot]sungsmenge \
eines Entscheidungsproblems mit der Nutzenmatrix u nach dem 'minimization of \
regret'-Verfahren nach L. Savage."

Expectation::usage="Expectation[c,p] berechnet den Erwartungswert der \
Zufallsvariablen c (Liste) bei der Wahrscheinlichkeitsverteilung p (Liste)." 

ExpectedUtility::usage="ExpectedUtility[u,c,prob] berechnet den \
Nutzenerwartungswert eines Nutzenvektors u[c] bei vorliegender \
Wahrscheinlichkeitsverteilung prob (Liste)."

BernoulliSolve::usage="BernoulliSolve[u,prob] berechnet die \
L\[ODoubleDot]sungsmenge eines Entscheidungsproblems mit der Nutzenmatrix u \
nach Bernoullis Regel vom maximalen Erwartungswert unter der \
Wahrscheinlichkeitsverteilung prob (Liste)."

LaplaceSolve::usage="LaplaceSolve[u] berechnet die L\[ODoubleDot]sungsmenge \
eines Entscheidungsproblems mit der Nutzenmatrix u nach der Regel vom \
maximalen Erwartungswert unter der Annahme gleicher Wahrscheinlichkeiten."



CertaintyEquivalent::usage="CertaintyEquivalent[u,{cmin,cmax},c,p] sucht im \
Intervall [cmin;cmax] ein Sicherheits\[ADoubleDot]quivalent zu einer \
riskanten Alternative mit dem Konsequenzenvektor c (Liste) bei vorgegebener \
Wahrscheinlichkeitsverteilung p (Liste)."

RiskPremium::usage="RiskPremium[u,{cmin,cmax},c,p] berechnet die Risikopr\
\[ADoubleDot]mie (soweit \[UDoubleDot]ber dem Intervall [cmin;cmax] \
vorhanden) eines Entscheiders (mit Nutzenfunktion u) bei Entscheidung f\
\[UDoubleDot]r eine riskante Alternative mit dem Konsequenzenvektor c (Liste) \
und vorgegebener Wahrscheinlichkeitsverteilung p (Liste)."

AbsoluteRiskFunction::usage="AbsoluteRiskFunction[u] berechnet zu \
zweimal-differenzierbarer Nutzenfunktion u das zugeh\[ODoubleDot]rige \
Risikoeinstellungsma\[SZ] nach Arrow und Pratt in Form einer reinen Funktion."

RelativeRiskFunction::usage="RelativeRiskFunction[u] berechnet zu \
zweimal-differenzierbarer Nutzenfunktion u das zugeh\[ODoubleDot]rige \
relative (proportionale) Risikoeinstellungsma\[SZ] nach Arrow und Pratt in \
Form einer reinen Funktion."



ReduceLines::usage="ReduceLines[m] streicht in der Entscheidungsmatrix m alle \
dominierten Zeilen."

ReduceColumns::usage="ReduceColumns[m] streicht in der Entscheidungsmatrix m \
alle dominierten Spalten."

MaximinSet::usage="MaximinSet[g] berechnet den Maximin-Wert (kleinsten Wert) \
eines Zweipersonenspiels mit der Auszahlungsmatrix g zusammen mit der zugeh\
\[ODoubleDot]rigen Strategienmenge."

MinimaxSet::usage="MinimaxSet[g] berechnet den Minimax-Wert (gr\[ODoubleDot]\
\[SZ]ten Wert) eines Zweipersonenspiels mit der Auszahlungsmatrix g zusammen \
mit der zugeh\[ODoubleDot]rigen Strategienmenge."

SaddlepointSolution::usage="SaddlepointSolution[g] berechnet (sofern \
vorhanden) den Wert eines Zweipersonenspiels mit der Auszahlungsmatrix g \
zusammen mit der Menge der zugeh\[ODoubleDot]rigen Strategienpaare \
(Sattelpunkt-L\[ODoubleDot]sungen)."

MixedStrategySolution::usage="MixedStrategySolution[g] berechnet den Wert und \
die optimalen gemischten Strategien eines Zweipersonen-Nullsummenspiels mit \
der Auszahlungsmatrix g (nach dem Minimax-Theorem)."





Options[UtilityFunctionOpt]={Normalize\[Rule]False};



Options[PresentValueGraph]=
    Join[Options[
        Plot],{PlotStyle\[Rule]{RGBColor[0.6,0.1,0.4],Hue[1,0.5,0.7],
            Thickness[0.004]}}];







Begin["`Private`"]





UtilityFunctionOpt[opts___?OptionQ]:=Module[{opt,a,b,nm=False},
    opt=Normalize/.{opts}/.Options[UtilityFunctionOpt];
    Switch[opt,{_,_},{a,b}=opt;nm=True];
    {nm,{a,b}}
    ]



SignChanges[f_List/;VectorQ[f,NumberQ]]:=Module[{scno=0},
    Do[scno=scno+If[Sign[f[[i]]*f[[i+1]]]<0,1,0],{i,1,Length[f]-1}];
    scno]

TransformedCashflow[c_List/;VectorQ[c,NumberQ]]:=
  Module[{n=Length[c],t,tcf={}},
    Do[t=Sum[Binomial[n-i,k-i]*c[[i]],{i,1,k}];
      AppendTo[tcf,t],
      {k,1,Length[c]}];
    tcf]



DisplaySolutions[v_List/;VectorQ[v,NumberQ]]:=Flatten[Position[v,Max[v]]]



DominatesQ[a_List/;VectorQ[a,NumberQ],
    b_List/;VectorQ[b,NumberQ]]:=(Select[a-b,#<0&]\[Equal]{})

DominationList[v_List/;VectorQ[v,NumberQ],mat_List/;MatrixQ[mat,NumberQ]]:=
  Select[mat,DominatesQ[v,#]&]

DominationPositionList[v_List,mat_List]:=Module[{poslist={},domlist},
    domlist=DominationList[v,mat];
    Do[AppendTo[poslist,Position[mat,domlist[[i]]]],{i,1,Length[domlist]}];
    Flatten[poslist,1]
    ]

PositiveShift[m_List/;MatrixQ[m,NumberQ]]:=Module[{mm=m,ps},
    ps=Min[mm];
    If[ps\[LessEqual]0,1+Abs[ps],0]
    ]





DecisionMatrix[g_,a_List/;VectorQ[a],b_List/;VectorQ[b]]:=Outer[g,a,b]

ScaleTransform[{a0_/;NumberQ[a0],b0_/;NumberQ[b0]},{a1_/;NumberQ[a1],
      b1_/;NumberQ[b1]}]:=Module[{h},
    If[a0>b0,h=a0;a0=b0;b0=h];
    If[a1>b1,h=a1;a1=b1;b1=h];
    If[a0\[NotEqual]b0,
      Function[x,x*(b1-a1)/(b0-a0)+(a1*b0-a0*b1)/(b0-a0)]]
    ]

ScaleNorm[a_/;NumberQ[a],b_/;NumberQ[b]]:=ScaleTransform[{a,b},{0,1}]

NormalizeValue[x_/;NumberQ[x],{xmin_/;NumberQ[xmin],xmax_/;NumberQ[xmax]}]:=
  ScaleNorm[xmin,xmax][x]

NormalizeRange[data_List]:=Module[{datamin=Min[data],datamax=Max[data]},
    ScaleNorm[datamin,datamax][data]
    ]

NormalizeFunction[f_,{a_/;NumberQ[a],b_/;NumberQ[b]}]:=
  Module[{n,s,h,valmin,valmax},
    If[a>b,h=a;a=b;b=h];
    n=Ceiling[4+Log[b-a]/Log[10]];
    s=(b-a)*10^(-n);
    vals=Table[f[a+j*s],{j,0,10^n}];
    {valmin,valmax}={Min[vals],Max[vals]};
    Function[x,(f[x]-valmin)/(valmax-valmin)]
    ]



LinUtility[k0_/;NumberQ[k0],k1_/;NumberQ[k1],opts___?OptionQ]:=
  Module[{h,opt,a,b,nm=False},
    opt=UtilityFunctionOpt[opts];
    If[opt[[1]],{a,b}=opt[[2]];nm=True];
    If[nm\[Equal]False||a\[Equal]b,Function[x,k0+k1*x],
      If[a>b,h=a;a=b;b=h];
      Which[
        k1>0,Function[x,(x-a)/(b-a)],
        k1<0,Function[x,(x-b)/(a-b)],
        k1\[Equal]0, If[k0>0,Function[x,1],Function[x,0]]
        ]]
    ]

QuadUtility[k0_/;NumberQ[k0],k1_/;NumberQ[k1],k2_/;NumberQ[k2],
    opts___?OptionQ]:=Module[{h,opt,a,b,xm,nm=False,ufkt},
    opt=UtilityFunctionOpt[opts];
    If[opt[[1]],{a,b}=opt[[2]];nm=True];
    ufkt=Function[x,k0+k1*x+k2*x^2];
    If[nm\[Equal]False||a\[Equal]b,ufkt,
      If[a>b,h=a;a=b;b=h];
      If[k2\[NotEqual]0,xm=-k1/(2*k2),Return[ufkt]];
      Which[
        (k2>0)&&(a\[GreaterEqual]xm),xmin=a;xmax=b,
        (k2>0)&&(b\[LessEqual] xm),xmin=b;xmax=a,
        (k2>0)&&(a<xm<b),xmin=xm;xmax=If[ufkt[a]>ufkt[b],a,b],
        (k2<0)&&(a\[GreaterEqual]xm),xmin=b;xmax=a,
        (k2<0)&&(b\[LessEqual] xm),xmin=a;xmax=b,
        (k2<0)&&(a<xm<b),xmin=If[ufkt[a]<ufkt[b],a,b];xmax=xm
        ](* End Which *);
      Function[x,(ufkt[x]-ufkt[xmin])/(ufkt[xmax]-ufkt[xmin])]
      ] (* End If *)
    ]

ExpUtility[k0_/;NumberQ[k0],k1_/;NumberQ[k1],k2_/;NumberQ[k2],
    opts___?OptionQ]:=Module[{h,opt,a,b,nm=False,ufkt},
    opt=UtilityFunctionOpt[opts];
    If[opt[[1]],{a,b}=opt[[2]];nm=True];
    ufkt=Function[x,k0+k1*Exp[k2*x]];
    If[k1*k2\[Equal]0,
      Return[If[k0\[NotEqual]0,Function[x,1],Function[x,0]]]];
    If[nm\[Equal]False,ufkt,
      If[a>b,h=a;a=b;b=h];
      Which[
        k1*k2>0,Function[x,(ufkt[x]-ufkt[a])/(ufkt[b]-ufkt[a])],
        k1*k2<0,Function[x,(ufkt[x]-ufkt[b])/(ufkt[a]-ufkt[b])]
        ]]
    ]

LogUtility[k0_/;NumberQ[k0],k1_/;NumberQ[k1],opts___?OptionQ]:=
  Module[{h,opt,a,b,nm=False},
    opt=UtilityFunctionOpt[opts];
    If[opt[[1]],{a,b}=opt[[2]];nm=True];
    If[(nm\[Equal]False)||(a\[LessEqual] 0)||(b\[LessEqual] 0),
      Function[x,k0+k1*Log[x]],
      If[a>b,h=a;a=b;b=h];
      Which[
        k1>0,Function[x,(Log[x]-Log[a])/(Log[b]-Log[a])],
        k1<0,Function[x,(Log[x]-Log[b])/(Log[a]-Log[b])]
        ]]
    ]

SqrtUtility[k0_/;NumberQ[k0],k1_/;NumberQ[k1],opts___?OptionQ]:=
  Module[{h,opt,a,b,nm=False},
    opt=UtilityFunctionOpt[opts];
    If[opt[[1]],{a,b}=opt[[2]];nm=True];
    If[(nm\[Equal]False)||(a< 0)||(b< 0),Function[x,k0+k1*Sqrt[x]],
      If[a>b,h=a;a=b;b=h];
      Which[
        k1>0,Function[x,(Sqrt[x]-Sqrt[a])/(Sqrt[b]-Sqrt[a])],
        k1<0,Function[x,(Sqrt[x]-Sqrt[b])/(Sqrt[a]-Sqrt[b])]
        ]]
    ]

CompoundUtility[scores_List/;VectorQ[scores,NumberQ],
    maxscore_/;NumberQ[maxscore],weights_List/;VectorQ[weights,NumberQ]]:=
  (scores/maxscore).(weights/Plus@@weights)



PresentValue[c_List/;VectorQ[c,NumberQ],q_List]:=Module[{df=1,gpv=c[[1]]},
    If[Length[q]\[GreaterEqual]Length[c]-1,
      Do[df=df*q[[j-1]];gpv=gpv+c[[j]]/df,{j,2,Length[c]}];
      gpv ]
    ]

PresentValueAtRate[c_List/;VectorQ[c,NumberQ],r_]:=
  PresentValue[c,Table[1+r,{Length[c]-1 }]]

PresentValueGraph[c_List/;VectorQ[c,NumberQ],rmin_/;NumberQ[rmin],
    rmax_/;NumberQ[rmax],opts___?OptionQ]:=Module[{pstyle},
    pstyle=PlotStyle/.{opts}/.Options[PresentValueGraph];
    Plot[PresentValueAtRate[c,r],{r,rmin,rmax},PlotStyle\[Rule]pstyle];
    ]

InterestRatePoly[c_List]:=
  Function[r,Simplify[Expand[PresentValueAtRate[c,r](1+r)^(Length[c]-1)]]]

InterestRateRealZeros[c_List/;VectorQ[c,NumberQ]]:=
  Cases[r/.NSolve[InterestRatePoly[c][r]\[Equal]0,r],_Real]

InternalRate[c_List/;VectorQ[c,NumberQ],rstart_:0]:=
  r/.FindRoot[PresentValueAtRate[c,r]\[Equal]0,{r,rstart}]

PositiveInvestmentQ[
    c_List/;Plus@@N[c]>0]:=(SignChanges[TransformedCashflow[c]]==1)



HurwiczValue[u_List/;VectorQ[u,NumberQ],lambda_/;NumberQ[lambda]]:=
  lambda*Max[u]+(1-lambda)*Min[u]

HurwiczSolve[u_List/;MatrixQ[u,NumberQ],lambda_/;NumberQ[lambda]]:=
  Module[{uhurwtab},
    uhurwtab=Table[HurwiczValue[u[[i]],lambda],{i,1,Length[u]}];
    DisplaySolutions[uhurwtab]
    ]

MaximinSolve[u_List/;MatrixQ[u,NumberQ]]:=HurwiczSolve[u,0]

MaximaxSolve[u_List/;MatrixQ[u,NumberQ]]:=HurwiczSolve[u,1]

RegretMatrix[u_List/;MatrixQ[u,NumberQ]]:=Module[{usterntab,utrans},
    utrans=Transpose[u];
    usterntab=Table[Max[utrans[[j]]],{j,1,Length[utrans]}];
    Table[u[[i]]-usterntab,{i,1,Length[u]}]
    ]

SavageSolve[u_List/;MatrixQ[u,NumberQ]]:=Module[{rm,regmintab},
    rm=RegretMatrix[u];
    regmintab=Table[Min[rm[[i]]],{i,1,Length[rm]}];
    DisplaySolutions[regmintab]
    ]

Expectation[c_List/;VectorQ[N[c],NumberQ],prob_List/;Plus@@prob\[Equal]1]:=
  N[c].N[prob]

ExpectedUtility[u_,c_,prob_]:=Expectation[u[N[c]],prob]

BernoulliSolve[u_List/;MatrixQ[u,NumberQ],prob_List]:=Module[{uexvaltab},
    uexvaltab=Table[Expectation[u[[i]],prob],{i,1,Length[u]}];
    DisplaySolutions[uexvaltab]
    ]

LaplaceSolve[u_List/;MatrixQ[u,NumberQ]]:=Module[{n=Length[Transpose[u]]},
    BernoulliSolve[u,Table[1/n,{n}]]
    ]



CertaintyEquivalent[u_,{cmin_,cmax_},c_List/;VectorQ[c,NumberQ],prob_List]:=
  x/.FindRoot[
      u[x]\[Equal]ExpectedUtility[u,c,prob],{x,(cmin+cmax)/2,cmin,cmax}]

RiskPremium[u_,{cmin_,cmax_},c_,prob_]:=
  Expectation[c,prob]-CertaintyEquivalent[u,{cmin,cmax},c,prob]

AbsoluteRiskFunction[u_]:=Function[x,-D[u[x],{x,2}]/D[u[x],x]]

RelativeRiskFunction[u_]:=Function[x,-D[u[x],{x,2}]*x/D[u[x],x]]



ReduceLines[m_List]:=Module[{mat=m,dpl,dplall={}},
    Do[
      dpl=DominationPositionList[mat[[i]],mat];
      dpl=Select[dpl,#\[NotEqual] {i}&];
      dplall=Union[dplall,dpl],
      {i,1,Length[mat]}
      ];
    Return[Delete[mat,dplall]]
    ]

ReduceColumns[m_List]:=Module[{mat=-m},
    -Transpose[ReduceLines[Transpose[mat]]]
    ]

MaximinSet[g_List/;MatrixQ[g,NumberQ]]:=Module[{alphav,alphatab},
    alphatab=Table[Min[g[[i]]],{i,1,Length[g]}];
    alphav=Max[alphatab];
    alphaposlist=Flatten[Position[alphatab,alphav]];
    {alphav,alphaposlist}
    ]

MinimaxSet[g_List/;MatrixQ[g,NumberQ]]:=Module[{betav,betatab},
    betatab=Table[Max[Transpose[g][[j]]],{j,1,Length[Transpose[g]]}];
    betav=Min[betatab];
    betaposlist=Flatten[Position[betatab,betav]];
    {betav,betaposlist}
    ]

SaddlepointSolution[g_]:=Module[{ma,mi,vals,v},
    mi=MinimaxSet[g];
    ma=MaximinSet[g];
    vals=Union[{First[mi],First[ma]}];
    If[Length[vals]\[Equal]1,{vals[[1]],
        Flatten[Outer[List,Flatten[Rest[mi]],Flatten[Rest[ma]]],1]},{}]
    ]

MixedStrategySolution[g_]:=
  Module[{ga=Transpose[g],gb=-g, psa,psb,va,vb,a1,b1,x,y},
    (* Spielmatrizen positiv machen *)
    psa=PositiveShift[ga];
    psb=PositiveShift[gb];
    ga=ga+psa; gb=gb+psb;
    (* rechte Seiten f\[UDoubleDot]r die Ungleichungen *)
    a1=Table[1,{Length[ga]}];
    b1=Table[1,{Length[gb]}];
    (* L\[ODoubleDot]sungen f\[UDoubleDot]r Spieler A und B *)
    x=LinearProgramming[b1,ga,a1];
    y=LinearProgramming[a1,gb,b1];
    va=(1/Plus@@x);vb=(1/Plus@@y);
    (* Wert des Spiels, Strategie A, Strategie B *)
    {va-psa,x*va,y*vb}
    ]



End[ ]





Protect["UtilityFunctionOpt","DisplaySolutions","Expectation","SignChanges","DecisionMatrix","ScaleTransform","ScaleNorm","NormalizeValue","NormalizeRange","NormalizeFunction","LinUtility","QuadUtility","ExpUtility","LogUtility","SqrtUtility","PresentValue","PresentValueAtRate","PresentValueGraph","InterestRatePoly","InterestRateRealZeros","InternalRate","PositiveInvestmentQ","TransformedCashflow","HurwiczValue","HurwiczSolve","MaximinSolve","MaximaxSolve","RegretMatrix","SavageSolve","ExpectedUtility","BernoulliSolve","LaplaceSolve","CertaintyEquivalent","RiskPremium","AbsoluteRiskFunction","RelativeRiskFunction","DominatesQ","DominationList","DominationPositionList","PositiveShift","ReduceLines","ReduceColumns","ReduceAll","MaximinSet","MinimaxSet","SaddlepointSolution","MixedStrategySolution"]



EndPackage[]