How to jump forward/backward from Xcode split window? - xcode

I used to split my Xcode window to 4 sub windows (not popup). I wonder if there's shortcut key to move cursor from one sub window to another ?
+++++++++++++++++++++++++++++
+ + + +
+ G / + F1 + F2 +
+ r F + + +
+ o i +++++++++++++++++++++++
+ u l + + +
+ p e + F3 + F4 +
+ + + +
+++++++++++++++++++++++++++++

Related

No more room for LISP objects error wxMaxima

I am trying to solve a non-linear equation system with maxima.
I use wxmaxima (17.05.0). The non-linear system is rather long and I am deeply sorry for posting the hole problem, but otherwise I do not think my problem will be clear.
I would like to solve these equations for eleven unkowns (K2 to K11) When I run this after some time the error message "No more room for LISP objects" occurs.
I have no glue how I can give it more cpu or to avoid the error.
I need the symbolic solutions for further calculations.
debugmode(true);
gcd : subres;
eq1:mBA*(K10*RABm10 + K11*RABm11 + K12*RABm12 + K7*RABm7 + K8*RABm8 + K9*RABm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RBm2 + K3*RBm3 + K4*RBm4 + K5*RBm5 + K6*RBm6) +
mAB*(K10*RABm10 + K11*RABm11 + K12*RABm12 + K7*RABm7 + K8*RABm8 +
K9*RABm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RBm10 + K11*M11*RBm11 + K12*M12*RBm12 + K2*M2*RBm2 +
K3*M3*RBm3 + K4*M4*RBm4 + K5*M5*RBm5 + K6*M6*RBm6 + K7*M7*RBm7 +
K8*M8*RBm8 + K9*M9*RBm9) =
mBA*(K10*RABm10 + K11*RABm11 + K12*RABm12 + K7*RABm7 + K8*RABm8 +
K9*RABm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RBm10 + K11*RBm11 + K12*RBm12 + K7*RBm7 + K8*RBm8 + K9*RBm9) +
mAB*(K10*RABm10 + K11*RABm11 + K12*RABm12 + K7*RABm7 + K8*RABm8 +
K9*RABm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RBm10 + K11*M11*RBm11 + K12*M12*RBm12 +
K2*M2*RBm2 + K3*M3*RBm3 + K4*M4*RBm4 + K5*M5*RBm5 + K6*M6*RBm6 +
K7*M7*RBm7 + K8*M8*RBm8 + K9*M9*RBm9)$
eq2:mCA*(K10*RACm10 + K11*RACm11 + K12*RACm12 + K7*RACm7 + K8*RACm8 + K9*RACm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RCm2 + K3*RCm3 + K4*RCm4 + K5*RCm5 + K6*RCm6) +
mAC*(K10*RACm10 + K11*RACm11 + K12*RACm12 + K7*RACm7 + K8*RACm8 +
K9*RACm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RCm10 + K11*M11*RCm11 + K12*M12*RCm12 + K2*M2*RCm2 +
K3*M3*RCm3 + K4*M4*RCm4 + K5*M5*RCm5 + K6*M6*RCm6 + K7*M7*RCm7 +
K8*M8*RCm8 + K9*M9*RCm9) =
mCA*(K10*RACm10 + K11*RACm11 + K12*RACm12 + K7*RACm7 + K8*RACm8 +
K9*RACm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RCm10 + K11*RCm11 + K12*RCm12 + K7*RCm7 + K8*RCm8 + K9*RCm9) +
mAC*(K10*RACm10 + K11*RACm11 + K12*RACm12 + K7*RACm7 + K8*RACm8 +
K9*RACm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RCm10 + K11*M11*RCm11 + K12*M12*RCm12 +
K2*M2*RCm2 + K3*M3*RCm3 + K4*M4*RCm4 + K5*M5*RCm5 + K6*M6*RCm6 +
K7*M7*RCm7 + K8*M8*RCm8 + K9*M9*RCm9)$
eq3:mDA*(K10*RADm10 + K11*RADm11 + K12*RADm12 + K7*RADm7 + K8*RADm8 + K9*RADm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RDm2 + K3*RDm3 + K4*RDm4 + K5*RDm5 + K6*RDm6) +
mAD*(K10*RADm10 + K11*RADm11 + K12*RADm12 + K7*RADm7 + K8*RADm8 +
K9*RADm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RDm10 + K11*M11*RDm11 + K12*M12*RDm12 + K2*M2*RDm2 +
K3*M3*RDm3 + K4*M4*RDm4 + K5*M5*RDm5 + K6*M6*RDm6 + K7*M7*RDm7 +
K8*M8*RDm8 + K9*M9*RDm9) =
mDA*(K10*RADm10 + K11*RADm11 + K12*RADm12 + K7*RADm7 + K8*RADm8 +
K9*RADm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RDm10 + K11*RDm11 + K12*RDm12 + K7*RDm7 + K8*RDm8 + K9*RDm9) +
mAD*(K10*RADm10 + K11*RADm11 + K12*RADm12 + K7*RADm7 + K8*RADm8 +
K9*RADm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RDm10 + K11*M11*RDm11 + K12*M12*RDm12 +
K2*M2*RDm2 + K3*M3*RDm3 + K4*M4*RDm4 + K5*M5*RDm5 + K6*M6*RDm6 +
K7*M7*RDm7 + K8*M8*RDm8 + K9*M9*RDm9)$
eq4:mEA*(K10*RAEm10 + K11*RAEm11 + K12*RAEm12 + K7*RAEm7 + K8*RAEm8 + K9*RAEm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*REm2 + K3*REm3 + K4*REm4 + K5*REm5 + K6*REm6) +
mAE*(K10*RAEm10 + K11*RAEm11 + K12*RAEm12 + K7*RAEm7 + K8*RAEm8 +
K9*RAEm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*REm10 + K11*M11*REm11 + K12*M12*REm12 + K2*M2*REm2 +
K3*M3*REm3 + K4*M4*REm4 + K5*M5*REm5 + K6*M6*REm6 + K7*M7*REm7 +
K8*M8*REm8 + K9*M9*REm9) =
mEA*(K10*RAEm10 + K11*RAEm11 + K12*RAEm12 + K7*RAEm7 + K8*RAEm8 +
K9*RAEm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*REm10 + K11*REm11 + K12*REm12 + K7*REm7 + K8*REm8 + K9*REm9) +
mAE*(K10*RAEm10 + K11*RAEm11 + K12*RAEm12 + K7*RAEm7 + K8*RAEm8 +
K9*RAEm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*REm10 + K11*M11*REm11 + K12*M12*REm12 +
K2*M2*REm2 + K3*M3*REm3 + K4*M4*REm4 + K5*M5*REm5 + K6*M6*REm6 +
K7*M7*REm7 + K8*M8*REm8 + K9*M9*REm9)$
eq5:mFA*(K10*RAFm10 + K11*RAFm11 + K12*RAFm12 + K7*RAFm7 + K8*RAFm8 + K9*RAFm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RFm2 + K3*RFm3 + K4*RFm4 + K5*RFm5 + K6*RFm6) +
mAF*(K10*RAFm10 + K11*RAFm11 + K12*RAFm12 + K7*RAFm7 + K8*RAFm8 +
K9*RAFm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RFm10 + K11*M11*RFm11 + K12*M12*RFm12 + K2*M2*RFm2 +
K3*M3*RFm3 + K4*M4*RFm4 + K5*M5*RFm5 + K6*M6*RFm6 + K7*M7*RFm7 +
K8*M8*RFm8 + K9*M9*RFm9) =
mFA*(K10*RAFm10 + K11*RAFm11 + K12*RAFm12 + K7*RAFm7 + K8*RAFm8 +
K9*RAFm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RFm10 + K11*RFm11 + K12*RFm12 + K7*RFm7 + K8*RFm8 + K9*RFm9) +
mAF*(K10*RAFm10 + K11*RAFm11 + K12*RAFm12 + K7*RAFm7 + K8*RAFm8 +
K9*RAFm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RFm10 + K11*M11*RFm11 + K12*M12*RFm12 +
K2*M2*RFm2 + K3*M3*RFm3 + K4*M4*RFm4 + K5*M5*RFm5 + K6*M6*RFm6 +
K7*M7*RFm7 + K8*M8*RFm8 + K9*M9*RFm9)$
eq6:mGA*(K10*RAGm10 + K11*RAGm11 + K12*RAGm12 + K7*RAGm7 + K8*RAGm8 + K9*RAGm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RGm2 + K3*RGm3 + K4*RGm4 + K5*RGm5 + K6*RGm6) +
mAG*(K10*RAGm10 + K11*RAGm11 + K12*RAGm12 + K7*RAGm7 + K8*RAGm8 +
K9*RAGm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RGm10 + K11*M11*RGm11 + K12*M12*RGm12 + K2*M2*RGm2 +
K3*M3*RGm3 + K4*M4*RGm4 + K5*M5*RGm5 + K6*M6*RGm6 + K7*M7*RGm7 +
K8*M8*RGm8 + K9*M9*RGm9) =
mGA*(K10*RAGm10 + K11*RAGm11 + K12*RAGm12 + K7*RAGm7 + K8*RAGm8 +
K9*RAGm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RGm10 + K11*RGm11 + K12*RGm12 + K7*RGm7 + K8*RGm8 + K9*RGm9) +
mAG*(K10*RAGm10 + K11*RAGm11 + K12*RAGm12 + K7*RAGm7 + K8*RAGm8 +
K9*RAGm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RGm10 + K11*M11*RGm11 + K12*M12*RGm12 +
K2*M2*RGm2 + K3*M3*RGm3 + K4*M4*RGm4 + K5*M5*RGm5 + K6*M6*RGm6 +
K7*M7*RGm7 + K8*M8*RGm8 + K9*M9*RGm9)$
eq7:mHA*(K10*RAHm10 + K11*RAHm11 + K12*RAHm12 + K7*RAHm7 + K8*RAHm8 + K9*RAHm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RHm2 + K3*RHm3 + K4*RHm4 + K5*RHm5 + K6*RHm6) +
mAH*(K10*RAHm10 + K11*RAHm11 + K12*RAHm12 + K7*RAHm7 + K8*RAHm8 +
K9*RAHm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RHm10 + K11*M11*RHm11 + K12*M12*RHm12 + K2*M2*RHm2 +
K3*M3*RHm3 + K4*M4*RHm4 + K5*M5*RHm5 + K6*M6*RHm6 + K7*M7*RHm7 +
K8*M8*RHm8 + K9*M9*RHm9) =
mHA*(K10*RAHm10 + K11*RAHm11 + K12*RAHm12 + K7*RAHm7 + K8*RAHm8 +
K9*RAHm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RHm10 + K11*RHm11 + K12*RHm12 + K7*RHm7 + K8*RHm8 + K9*RHm9) +
mAH*(K10*RAHm10 + K11*RAHm11 + K12*RAHm12 + K7*RAHm7 + K8*RAHm8 +
K9*RAHm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RHm10 + K11*M11*RHm11 + K12*M12*RHm12 +
K2*M2*RHm2 + K3*M3*RHm3 + K4*M4*RHm4 + K5*M5*RHm5 + K6*M6*RHm6 +
K7*M7*RHm7 + K8*M8*RHm8 + K9*M9*RHm9)$
eq8:mIA*(K10*RAIm10 + K11*RAIm11 + K12*RAIm12 + K7*RAIm7 + K8*RAIm8 + K9*RAIm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RIm2 + K3*RIm3 + K4*RIm4 + K5*RIm5 + K6*RIm6) +
mAI*(K10*RAIm10 + K11*RAIm11 + K12*RAIm12 + K7*RAIm7 + K8*RAIm8 +
K9*RAIm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RIm10 + K11*M11*RIm11 + K12*M12*RIm12 + K2*M2*RIm2 +
K3*M3*RIm3 + K4*M4*RIm4 + K5*M5*RIm5 + K6*M6*RIm6 + K7*M7*RIm7 +
K8*M8*RIm8 + K9*M9*RIm9) =
mIA*(K10*RAIm10 + K11*RAIm11 + K12*RAIm12 + K7*RAIm7 + K8*RAIm8 +
K9*RAIm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RIm10 + K11*RIm11 + K12*RIm12 + K7*RIm7 + K8*RIm8 + K9*RIm9) +
mAI*(K10*RAIm10 + K11*RAIm11 + K12*RAIm12 + K7*RAIm7 + K8*RAIm8 +
K9*RAIm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RIm10 + K11*M11*RIm11 + K12*M12*RIm12 +
K2*M2*RIm2 + K3*M3*RIm3 + K4*M4*RIm4 + K5*M5*RIm5 + K6*M6*RIm6 +
K7*M7*RIm7 + K8*M8*RIm8 + K9*M9*RIm9)$
eq9:mJA*(K10*RAJm10 + K11*RAJm11 + K12*RAJm12 + K7*RAJm7 + K8*RAJm8 + K9*RAJm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RJm2 + K3*RJm3 + K4*RJm4 + K5*RJm5 + K6*RJm6) +
mAJ*(K10*RAJm10 + K11*RAJm11 + K12*RAJm12 + K7*RAJm7 + K8*RAJm8 +
K9*RAJm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RJm10 + K11*M11*RJm11 + K12*M12*RJm12 + K2*M2*RJm2 +
K3*M3*RJm3 + K4*M4*RJm4 + K5*M5*RJm5 + K6*M6*RJm6 + K7*M7*RJm7 +
K8*M8*RJm8 + K9*M9*RJm9) =
mJA*(K10*RAJm10 + K11*RAJm11 + K12*RAJm12 + K7*RAJm7 + K8*RAJm8 +
K9*RAJm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RJm10 + K11*RJm11 + K12*RJm12 + K7*RJm7 + K8*RJm8 + K9*RJm9) +
mAJ*(K10*RAJm10 + K11*RAJm11 + K12*RAJm12 + K7*RAJm7 + K8*RAJm8 +
K9*RAJm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RJm10 + K11*M11*RJm11 + K12*M12*RJm12 +
K2*M2*RJm2 + K3*M3*RJm3 + K4*M4*RJm4 + K5*M5*RJm5 + K6*M6*RJm6 +
K7*M7*RJm7 + K8*M8*RJm8 + K9*M9*RJm9)$
eq10:mKA*(K10*RAKm10 + K11*RAKm11 + K12*RAKm12 + K7*RAKm7 + K8*RAKm8 + K9*RAKm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RKm2 + K3*RKm3 + K4*RKm4 + K5*RKm5 + K6*RKm6) +
mAK*(K10*RAKm10 + K11*RAKm11 + K12*RAKm12 + K7*RAKm7 + K8*RAKm8 +
K9*RAKm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RKm10 + K11*M11*RKm11 + K12*M12*RKm12 + K2*M2*RKm2 +
K3*M3*RKm3 + K4*M4*RKm4 + K5*M5*RKm5 + K6*M6*RKm6 + K7*M7*RKm7 +
K8*M8*RKm8 + K9*M9*RKm9) =
mKA*(K10*RAKm10 + K11*RAKm11 + K12*RAKm12 + K7*RAKm7 + K8*RAKm8 +
K9*RAKm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RKm10 + K11*RKm11 + K12*RKm12 + K7*RKm7 + K8*RKm8 + K9*RKm9) +
mAK*(K10*RAKm10 + K11*RAKm11 + K12*RAKm12 + K7*RAKm7 + K8*RAKm8 +
K9*RAKm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RKm10 + K11*M11*RKm11 + K12*M12*RKm12 +
K2*M2*RKm2 + K3*M3*RKm3 + K4*M4*RKm4 + K5*M5*RKm5 + K6*M6*RKm6 +
K7*M7*RKm7 + K8*M8*RKm8 + K9*M9*RKm9)$
eq11:mLA*(K10*RALm10 + K11*RALm11 + K12*RALm12 + K7*RALm7 + K8*RALm8 + K9*RALm9)*
(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 + K2*M2*RAm2 +
K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 + K7*M7*RAm7 +
K8*M8*RAm8 + K9*M9*RAm9)*
(1 + K2*RLm2 + K3*RLm3 + K4*RLm4 + K5*RLm5 + K6*RLm6) +
mAL*(K10*RALm10 + K11*RALm11 + K12*RALm12 + K7*RALm7 + K8*RALm8 +
K9*RALm9)*(1 + K2*RAm2 + K3*RAm3 + K4*RAm4 + K5*RAm5 + K6*RAm6)*
(M1 + K10*M10*RLm10 + K11*M11*RLm11 + K12*M12*RLm12 + K2*M2*RLm2 +
K3*M3*RLm3 + K4*M4*RLm4 + K5*M5*RLm5 + K6*M6*RLm6 + K7*M7*RLm7 +
K8*M8*RLm8 + K9*M9*RLm9) =
mLA*(K10*RALm10 + K11*RALm11 + K12*RALm12 + K7*RALm7 + K8*RALm8 +
K9*RALm9)*(M1 + K10*M10*RAm10 + K11*M11*RAm11 + K12*M12*RAm12 +
K2*M2*RAm2 + K3*M3*RAm3 + K4*M4*RAm4 + K5*M5*RAm5 + K6*M6*RAm6 +
K7*M7*RAm7 + K8*M8*RAm8 + K9*M9*RAm9)*
(K10*RLm10 + K11*RLm11 + K12*RLm12 + K7*RLm7 + K8*RLm8 + K9*RLm9) +
mAL*(K10*RALm10 + K11*RALm11 + K12*RALm12 + K7*RALm7 + K8*RALm8 +
K9*RALm9)*(K10*RAm10 + K11*RAm11 + K12*RAm12 + K7*RAm7 + K8*RAm8 +
K9*RAm9)*(M1 + K10*M10*RLm10 + K11*M11*RLm11 + K12*M12*RLm12 +
K2*M2*RLm2 + K3*M3*RLm3 + K4*M4*RLm4 + K5*M5*RLm5 + K6*M6*RLm6 +
K7*M7*RLm7 + K8*M8*RLm8 + K9*M9*RLm9)$
sol:solve([eq1,eq2,eq3,eq4,eq5,eq6,eq7,eq8,eq9,eq10,eq11],[K2,K3,K4,K5,K6,K7,K8,K9,K10,K11])$
Here are the missing infos about my system.
wxMaxima version: 17.05.0
Maxima version: 5.40.0
Maxima build date: 2017-06-01 18:54:32
Host type: x86_64-w64-mingw32
System type:
gcc -mno-cygwin -g -O2 -W -Wswitch -Wcomment -Wpointer-arith -Wimplicit -Wreturn-type -Wmissing-declarations -Wno-sign-compare -Wno-format-nonliteral -O2 -fexpensive-optimizations -falign-functions=4 -D_WIN32 -DENABLE_UNICODE -I/usr/local/include -DDYNAMIC_FFI -I. -L/usr/local/lib -lintl /usr/local/lib/libreadline.dll.a -L/usr/local/lib -ltermcap /usr/local/lib/libavcall.a /usr/local/lib/libcallback.a -luser32 -lws2_32 -lole32 -loleaut32 -luuid -liconv -L/usr/local/lib -lsigsegv libgnu_cl.a
SAFETY=0 HEAPCODES STANDARD_HEAPCODES GENERATIONAL_GC SPVW_BLOCKS SPVW_MIXED TRIVIALMAP_MEMORY
libsigsegv 2.8
libiconv 1.13
libreadline 6.0 GNU C 3.4.5 (mingw-vista special r3) PC/386
Lisp implementation type: CLISP
Lisp implementation version: 2.49 (2010-07-07) (built on toshiba [192.168.43.206])

This seems to me like heap exhaustion. Using the :lisp directive from my comment above, you can investigate the current heap size in the underlying Lisp. This is implementation-specific, but assuming you're running on SBCL, the following would retrieve the heap size:
:lisp (cl-user::dynamic-space-size)
Now, Maxima recognizes an environment variable MAXIMA_LISP_OPTIONS, which is just a list of command line parameters passed to Lisp. In SBCL there's a parameter --dynamic-space-size, which specifies the heap size in megabytes. So by running Maxima as follows:
MAXIMA_LISP_OPTIONS="--dynamic-space-size 10000" maxima
you should run the underlying SBCL with 10 GB of heap space, which you can verify as above. This approach would have to be appropriately modified for other Lisp implementations. Let me know if this allows your calculations to run to completion.

I have changed a line in the maxima.bat file.
There you can find some thing like
if exist "%maxima_prefix%/bin/libgcc_s_seh-1.dll" (
if "%lisp_options%"=="" set lisp_options=--dynamic-space-size^ 200
)
I have changed the 200 MB to 8000 MB, this help me to increase the heap size but still I was not able to solve my system of non-linear equations.

Loop optimisation

I am trying to understand what cache or other optimizations could be done in the source code to get this loop faster. I think it is quite cache friendly but, are there any experts out there that could squeeze a bit more performance tuning this code?
DO K = 1, NZ
DO J = 1, NY
DO I = 1, NX
SIDEBACK = STEN(I-1,J-1,K-1) + STEN(I-1,J,K-1) + STEN(I-1,J+1,K-1) + &
STEN(I ,J-1,K-1) + STEN(I ,J,K-1) + STEN(I ,J+1,K-1) + &
STEN(I+1,J-1,K-1) + STEN(I+1,J,K-1) + STEN(I+1,J+1,K-1)
SIDEOWN = STEN(I-1,J-1,K) + STEN(I-1,J,K) + STEN(I-1,J+1,K) + &
STEN(I ,J-1,K) + STEN(I ,J,K) + STEN(I ,J+1,K) + &
STEN(I+1,J-1,K) + STEN(I+1,J,K) + STEN(I+1,J+1,K)
SIDEFRONT = STEN(I-1,J-1,K+1) + STEN(I-1,J,K+1) + STEN(I-1,J+1,K+1) + &
STEN(I ,J-1,K+1) + STEN(I ,J,K+1) + STEN(I ,J+1,K+1) + &
STEN(I+1,J-1,K+1) + STEN(I+1,J,K+1) + STEN(I+1,J+1,K+1)
RES(I,J,K) = ( SIDEBACK + SIDEOWN + SIDEFRONT ) / 27.0
END DO
END DO
END DO

Ok, I think I've tried everything I reasonably could, and my conclusion unfortunately is that there is not too much room for optimizations, unless you are willing to go into parallelization. Let's see why, let's see what you can and can't do.
Compiler optimizations
Compilers nowadays are extremely good at optimizing code, much much more than humans are. Relying on the optimizations done by the compilers also have the added benefit that they don't ruin the readability of your source code. Whatever you do, (when optimizing for speed) always try it with every reasonable combination of compiler flags. You can even go as far as to try multiple compilers. Personally I only used gfortran (included in GCC) (OS is 64-bit Windows), which I trust to have efficient and correct optimization techniques.
-O2 almost always improve the speed drastically, but even -O3 is a safe bet (among others, it includes delicious loop unrolling). For this problem, I also tried -ffast-math and -fexpensive-optimizations, they didn't have any measurable effect, but -march-corei7(cpu architecture-specific tuning, specific to Core i7) had, so I did the measurements with -O3 -march-corei7
So how fast it actually is?
I wrote the following code to test your solution and compiled it with -O3 -march-corei7. Usually it ran under 0.78-0.82 seconds.
program benchmark
implicit none
real :: start, finish
integer :: I, J, K
real :: SIDEBACK, SIDEOWN, SIDEFRONT
integer, parameter :: NX = 600
integer, parameter :: NY = 600
integer, parameter :: NZ = 600
real, dimension (0 : NX + 2, 0 : NY + 2, 0 : NZ + 2) :: STEN
real, dimension (0 : NX + 2, 0 : NY + 2, 0 : NZ + 2) :: RES
call random_number(STEN)
call cpu_time(start)
DO K = 1, NZ
DO J = 1, NY
DO I = 1, NX
SIDEBACK = STEN(I-1,J-1,K-1) + STEN(I-1,J,K-1) + STEN(I-1,J+1,K-1) + &
STEN(I ,J-1,K-1) + STEN(I ,J,K-1) + STEN(I ,J+1,K-1) + &
STEN(I+1,J-1,K-1) + STEN(I+1,J,K-1) + STEN(I+1,J+1,K-1)
SIDEOWN = STEN(I-1,J-1,K) + STEN(I-1,J,K) + STEN(I-1,J+1,K) + &
STEN(I ,J-1,K) + STEN(I ,J,K) + STEN(I ,J+1,K) + &
STEN(I+1,J-1,K) + STEN(I+1,J,K) + STEN(I+1,J+1,K)
SIDEFRONT = STEN(I-1,J-1,K+1) + STEN(I-1,J,K+1) + STEN(I-1,J+1,K+1) + &
STEN(I ,J-1,K+1) + STEN(I ,J,K+1) + STEN(I ,J+1,K+1) + &
STEN(I+1,J-1,K+1) + STEN(I+1,J,K+1) + STEN(I+1,J+1,K+1)
RES(I,J,K) = ( SIDEBACK + SIDEOWN + SIDEFRONT ) / 27.0
END DO
END DO
END DO
call cpu_time(finish)
!Use the calculated value, so the compiler doesn't optimize away everything.
!Print the original value as well, because one can never be too paranoid.
print *, STEN(1,1,1), RES(1,1,1)
print '(f6.3," seconds.")',finish-start
end program
Ok, so this is as far as the compiler can take us. What's next?
Store intermediate results?
As you might suspect from the question mark, this one didn't really work. Sorry. But let's not rush that forward.
As mentioned in the comments, your current code calculates every partial sum multiple times, meaning one iteration's STEN(I+1,J-1,K-1) + STEN(I+1,J,K-1) + STEN(I+1,J+1,K-1) will be the next iteration's STEN(I,J-1,K-1) + STEN(I,J,K-1) + STEN(I,J+1,K-1), so no need to fetch and calculate again, you can store those partial results.
The problem is, that we cannot store too many partial results. As you said, your code is already quite cache-friendly, every partial sum you store means one less array element you can store in L1 cache. We could store a few values, from the last few iterations of I (values for index I-2, I-3, etc.), but the compiler almost certainly does that already. I have 2 proofs for this suspicion. First, my manual loop unrolling made the program slower, by about 5%
DO K = 1, NZ
DO J = 1, NY
DO I = 1, NX, 8
SIDEBACK(0) = STEN(I-1,J-1,K-1) + STEN(I-1,J,K-1) + STEN(I-1,J+1,K-1)
SIDEBACK(1) = STEN(I ,J-1,K-1) + STEN(I ,J,K-1) + STEN(I ,J+1,K-1)
SIDEBACK(2) = STEN(I+1,J-1,K-1) + STEN(I+1,J,K-1) + STEN(I+1,J+1,K-1)
SIDEBACK(3) = STEN(I+2,J-1,K-1) + STEN(I+2,J,K-1) + STEN(I+2,J+1,K-1)
SIDEBACK(4) = STEN(I+3,J-1,K-1) + STEN(I+3,J,K-1) + STEN(I+3,J+1,K-1)
SIDEBACK(5) = STEN(I+4,J-1,K-1) + STEN(I+4,J,K-1) + STEN(I+4,J+1,K-1)
SIDEBACK(6) = STEN(I+5,J-1,K-1) + STEN(I+5,J,K-1) + STEN(I+5,J+1,K-1)
SIDEBACK(7) = STEN(I+6,J-1,K-1) + STEN(I+6,J,K-1) + STEN(I+6,J+1,K-1)
SIDEBACK(8) = STEN(I+7,J-1,K-1) + STEN(I+7,J,K-1) + STEN(I+7,J+1,K-1)
SIDEBACK(9) = STEN(I+8,J-1,K-1) + STEN(I+8,J,K-1) + STEN(I+8,J+1,K-1)
SIDEOWN(0) = STEN(I-1,J-1,K) + STEN(I-1,J,K) + STEN(I-1,J+1,K)
SIDEOWN(1) = STEN(I ,J-1,K) + STEN(I ,J,K) + STEN(I ,J+1,K)
SIDEOWN(2) = STEN(I+1,J-1,K) + STEN(I+1,J,K) + STEN(I+1,J+1,K)
SIDEOWN(3) = STEN(I+2,J-1,K) + STEN(I+2,J,K) + STEN(I+2,J+1,K)
SIDEOWN(4) = STEN(I+3,J-1,K) + STEN(I+3,J,K) + STEN(I+3,J+1,K)
SIDEOWN(5) = STEN(I+4,J-1,K) + STEN(I+4,J,K) + STEN(I+4,J+1,K)
SIDEOWN(6) = STEN(I+5,J-1,K) + STEN(I+5,J,K) + STEN(I+5,J+1,K)
SIDEOWN(7) = STEN(I+6,J-1,K) + STEN(I+6,J,K) + STEN(I+6,J+1,K)
SIDEOWN(8) = STEN(I+7,J-1,K) + STEN(I+7,J,K) + STEN(I+7,J+1,K)
SIDEOWN(9) = STEN(I+8,J-1,K) + STEN(I+8,J,K) + STEN(I+8,J+1,K)
SIDEFRONT(0) = STEN(I-1,J-1,K+1) + STEN(I-1,J,K+1) + STEN(I-1,J+1,K+1)
SIDEFRONT(1) = STEN(I ,J-1,K+1) + STEN(I ,J,K+1) + STEN(I ,J+1,K+1)
SIDEFRONT(2) = STEN(I+1,J-1,K+1) + STEN(I+1,J,K+1) + STEN(I+1,J+1,K+1)
SIDEFRONT(3) = STEN(I+2,J-1,K+1) + STEN(I+2,J,K+1) + STEN(I+2,J+1,K+1)
SIDEFRONT(4) = STEN(I+3,J-1,K+1) + STEN(I+3,J,K+1) + STEN(I+3,J+1,K+1)
SIDEFRONT(5) = STEN(I+4,J-1,K+1) + STEN(I+4,J,K+1) + STEN(I+4,J+1,K+1)
SIDEFRONT(6) = STEN(I+5,J-1,K+1) + STEN(I+5,J,K+1) + STEN(I+5,J+1,K+1)
SIDEFRONT(7) = STEN(I+6,J-1,K+1) + STEN(I+6,J,K+1) + STEN(I+6,J+1,K+1)
SIDEFRONT(8) = STEN(I+7,J-1,K+1) + STEN(I+7,J,K+1) + STEN(I+7,J+1,K+1)
SIDEFRONT(9) = STEN(I+8,J-1,K+1) + STEN(I+8,J,K+1) + STEN(I+8,J+1,K+1)
RES(I ,J,K) = ( SIDEBACK(0) + SIDEOWN(0) + SIDEFRONT(0) + &
SIDEBACK(1) + SIDEOWN(1) + SIDEFRONT(1) + &
SIDEBACK(2) + SIDEOWN(2) + SIDEFRONT(2) ) / 27.0
RES(I + 1,J,K) = ( SIDEBACK(1) + SIDEOWN(1) + SIDEFRONT(1) + &
SIDEBACK(2) + SIDEOWN(2) + SIDEFRONT(2) + &
SIDEBACK(3) + SIDEOWN(3) + SIDEFRONT(3) ) / 27.0
RES(I + 2,J,K) = ( SIDEBACK(2) + SIDEOWN(2) + SIDEFRONT(2) + &
SIDEBACK(3) + SIDEOWN(3) + SIDEFRONT(3) + &
SIDEBACK(4) + SIDEOWN(4) + SIDEFRONT(4) ) / 27.0
RES(I + 3,J,K) = ( SIDEBACK(3) + SIDEOWN(3) + SIDEFRONT(3) + &
SIDEBACK(4) + SIDEOWN(4) + SIDEFRONT(4) + &
SIDEBACK(5) + SIDEOWN(5) + SIDEFRONT(5) ) / 27.0
RES(I + 4,J,K) = ( SIDEBACK(4) + SIDEOWN(4) + SIDEFRONT(4) + &
SIDEBACK(5) + SIDEOWN(5) + SIDEFRONT(5) + &
SIDEBACK(6) + SIDEOWN(6) + SIDEFRONT(6) ) / 27.0
RES(I + 5,J,K) = ( SIDEBACK(5) + SIDEOWN(5) + SIDEFRONT(5) + &
SIDEBACK(6) + SIDEOWN(6) + SIDEFRONT(6) + &
SIDEBACK(7) + SIDEOWN(7) + SIDEFRONT(7) ) / 27.0
RES(I + 6,J,K) = ( SIDEBACK(6) + SIDEOWN(6) + SIDEFRONT(6) + &
SIDEBACK(7) + SIDEOWN(7) + SIDEFRONT(7) + &
SIDEBACK(8) + SIDEOWN(8) + SIDEFRONT(8) ) / 27.0
RES(I + 7,J,K) = ( SIDEBACK(7) + SIDEOWN(7) + SIDEFRONT(7) + &
SIDEBACK(8) + SIDEOWN(8) + SIDEFRONT(8) + &
SIDEBACK(9) + SIDEOWN(9) + SIDEFRONT(9) ) / 27.0
END DO
END DO
END DO
And what's worse, it's easy to show we are already pretty close the theoretical minimal possible execution time. In order to calculate all these averages, the absolute minimum we need to do, is access every element at least once, and divide them by 27.0. So you can never get faster than the following code, which executes under 0.48-0.5 seconds on my machine.
program benchmark
implicit none
real :: start, finish
integer :: I, J, K
integer, parameter :: NX = 600
integer, parameter :: NY = 600
integer, parameter :: NZ = 600
real, dimension (0 : NX + 2, 0 : NY + 2, 0 : NZ + 2) :: STEN
real, dimension (0 : NX + 2, 0 : NY + 2, 0 : NZ + 2) :: RES
call random_number(STEN)
call cpu_time(start)
DO K = 1, NZ
DO J = 1, NY
DO I = 1, NX
!This of course does not do what you want to do,
!this is just an example of a speed limit we can never surpass.
RES(I, J, K) = STEN(I, J, K) / 27.0
END DO
END DO
END DO
call cpu_time(finish)
!Use the calculated value, so the compiler doesn't optimize away everything.
print *, STEN(1,1,1), RES(1,1,1)
print '(f6.3," seconds.")',finish-start
end program
But hey, even a negative result is a result. If just accessing every element once (and dividing by 27.0) takes up more than half of the execution time, that just means memory access is the bottle neck. Then maybe you can optimize that.
Less data
If you don't need the full precision of 64-bit doubles, you can declare your array with a type of real(kind=4). But maybe your reals are already 4 bytes. In that case, I believe some Fortran implementations support non-standard 16-bit doubles, or depending on your data you can just use integers (maybe floats multiplied by a number then rounded to integer). The smaller your base type is, the more elements you can fit into the cache. The most ideal would be integer(kind=1), of course, it caused more than a 2x speed up on my machine, compared to real(kind=4). But it depends on the precision you need.
Better locality
Column major arrays are slow when you need data from neighbouring column, and row major ones are slow for neighbouring rows.
Fortunately there is a funky way to store data, called a Z-order curve, which does have applications similar to your use case in computer graphics.
I can't promise it will help, maybe it will be terribly counterproductive, but maybe not. Sorry, I didn't feel like implementing it myself, to be honest.
Parallelization
Speaking of computer graphics, this problem is trivially and extremely well parallelizable, maybe even on a GPU, but if you don't want to go that far, you can just use a normal multicore CPU. The Fortran Wiki seems like a good place to search for Fortran parallelization libraries.

Boolean Algebra-Simplification Assistance Needed

I have to show that (!P.!Q+R)(!Q+P.!R) => !Q by simplifying it using De Morgan's Laws.
Here is what I did but I'm not sure it's right.
(!P.!Q + R)(!Q + P.!R) => !Q
(!P + !Q + R)(!Q + P.!R)
!P.!Q + !P.P.!R + !Q.!Q + !Q.P.!R + R.!Q + R.P.!R
!P.!Q + 0 + !Q + !Q.P.!Q + R.!Q + 0
!P.!Q + !Q + !Q(1 + P.!R + R)
!P.!Q + !Q + !Q
!Q + !P.!Q
!Q(1 + !P)
!Q
Hope that's clear enough.

4x4 Fixed point matrix multiplication doesn't work

I have this function which concatenates two matrices:
out->_11 = MAT_MUL(b->_11, a->_11) + MAT_MUL(b->_21, a->_12) + MAT_MUL(b->_31, a->_13) + MAT_MUL(b->_41, a->_14);
out->_12 = MAT_MUL(b->_12, a->_11) + MAT_MUL(b->_22, a->_12) + MAT_MUL(b->_32, a->_13) + MAT_MUL(b->_42, a->_14);
out->_13 = MAT_MUL(b->_13, a->_11) + MAT_MUL(b->_23, a->_12) + MAT_MUL(b->_33, a->_13) + MAT_MUL(b->_43, a->_14);
out->_14 = MAT_MUL(b->_14, a->_11) + MAT_MUL(b->_24, a->_12) + MAT_MUL(b->_34, a->_13) + MAT_MUL(b->_44, a->_14);
out->_21 = MAT_MUL(b->_11, a->_21) + MAT_MUL(b->_21, a->_22) + MAT_MUL(b->_31, a->_23) + MAT_MUL(b->_41, a->_24);
out->_22 = MAT_MUL(b->_12, a->_21) + MAT_MUL(b->_22, a->_22) + MAT_MUL(b->_32, a->_23) + MAT_MUL(b->_42, a->_24);
out->_23 = MAT_MUL(b->_13, a->_21) + MAT_MUL(b->_23, a->_22) + MAT_MUL(b->_33, a->_23) + MAT_MUL(b->_43, a->_24);
out->_24 = MAT_MUL(b->_14, a->_21) + MAT_MUL(b->_24, a->_22) + MAT_MUL(b->_34, a->_23) + MAT_MUL(b->_44, a->_24);
out->_31 = MAT_MUL(b->_11, a->_31) + MAT_MUL(b->_21, a->_32) + MAT_MUL(b->_31, a->_33) + MAT_MUL(b->_41, a->_34);
out->_32 = MAT_MUL(b->_12, a->_31) + MAT_MUL(b->_22, a->_32) + MAT_MUL(b->_32, a->_33) + MAT_MUL(b->_42, a->_34);
out->_33 = MAT_MUL(b->_13, a->_31) + MAT_MUL(b->_23, a->_32) + MAT_MUL(b->_33, a->_33) + MAT_MUL(b->_43, a->_34);
out->_34 = MAT_MUL(b->_14, a->_31) + MAT_MUL(b->_24, a->_32) + MAT_MUL(b->_34, a->_33) + MAT_MUL(b->_44, a->_34);
out->_41 = MAT_MUL(b->_11, a->_41) + MAT_MUL(b->_21, a->_42) + MAT_MUL(b->_31, a->_43) + MAT_MUL(b->_41, a->_44);
out->_42 = MAT_MUL(b->_12, a->_41) + MAT_MUL(b->_22, a->_42) + MAT_MUL(b->_32, a->_43) + MAT_MUL(b->_42, a->_44);
out->_43 = MAT_MUL(b->_13, a->_41) + MAT_MUL(b->_23, a->_42) + MAT_MUL(b->_33, a->_43) + MAT_MUL(b->_43, a->_44);
out->_44 = MAT_MUL(b->_14, a->_41) + MAT_MUL(b->_24, a->_42) + MAT_MUL(b->_34, a->_43) + MAT_MUL(b->_44, a->_44);
MAT_MUL looks like this:
#define MAT_MUL(o1,o2) ((GLfixed)((long)(o1)*(long)(o2))>>16)
The odd thing is that it doesn't work with fixed point values but with float values (MAT_MUL(o1,o2) (o1)*(o2) in this case). I traced the error down to this bit of code.
Any ideas? Thanks

Mathematica - DSolve spits out #1 in output

I'm not quite certain how to go about interpreting this.
I'm solving a fairly large system of differential equations, DSolve sometimes spits out a list of replacement rules that include terms that have a #1 . I know that #1 is a placeholder for an argument, but I just have no clue where it comes from.
If I have a system of equations similar to
eqs = {
x1'[t] = a1*x1[t] + b1*y1[t]
x2'[t] = a2*x2[t] + b2*y2[t]
...
y1'[t] = c1*y1[t] + d1*x1[t]
y2'[t] = c2*y2[t] + d2*x2[t]}
DSolve[eqs,vars,t] spits out something like
x1 -> e^(-ta1)
x2 -> e^(-t)RootSum[a1a2+a3b4#1 + a3a1b2#1]
...
Obviously a little more complicated but you get the point.
Nothing in the documentation hints as to why this is occurring, And it only happens under certain permuations of parameters (e.g. when I play around with parameters in the original system it either works or doesn't)

This RootSum may be generated by Integrate, which is used by DSolve internally, like so:
In[511]:= Integrate[1/(1 + x + x^2 + x^3 + x^4), x]
Out[511]= RootSum[1 + #1 + #1^2 + #1^3 + #1^4 &,
Log[x - #1]/(1 + 2 #1 + 3 #1^2 + 4 #1^3) &]
It represents a symbolic expression that is the Sum[ Log[x-t]/(1+2*t+3 t^2+4 t^3), {t, {"roots of 1+t+t^2+t^3+t^4"}] (caution, invalid syntax intentional). You can recover the expected normal form using Normal:
In[512]:= Normal[%]
Out[512]=
Log[(-1)^(1/5) + x]/(1 - 2 (-1)^(1/5) + 3 (-1)^(2/5) - 4 (-1)^(3/5)) +
Log[-(-1)^(2/5) + x]/(
1 - 4 (-1)^(1/5) + 2 (-1)^(2/5) + 3 (-1)^(4/5)) +
Log[(-1)^(3/5) + x]/(
1 - 3 (-1)^(1/5) - 2 (-1)^(3/5) + 4 (-1)^(4/5)) +
Log[-(-1)^(4/5) + x]/(1 + 4 (-1)^(2/5) - 3 (-1)^(3/5) + 2 (-1)^(4/5))
Or using the Sum directly:
In[513]:= Sum[
Log[x - t]/(1 + 2*t + 3 t^2 + 4 t^3), {t,
t /. {ToRules[Roots[1 + t + t^2 + t^3 + t^4 == 0, t]]}}]
Out[513]=
Log[(-1)^(1/5) + x]/(1 - 2 (-1)^(1/5) + 3 (-1)^(2/5) - 4 (-1)^(3/5)) +
Log[-(-1)^(2/5) + x]/(
1 - 4 (-1)^(1/5) + 2 (-1)^(2/5) + 3 (-1)^(4/5)) +
Log[(-1)^(3/5) + x]/(
1 - 3 (-1)^(1/5) - 2 (-1)^(3/5) + 4 (-1)^(4/5)) +
Log[-(-1)^(4/5) + x]/(1 + 4 (-1)^(2/5) - 3 (-1)^(3/5) + 2 (-1)^(4/5))
In[514]:= % - %% // FullSimplify
Out[514]= 0

Resources