GiNaC  1.8.0
function.cpp
Go to the documentation of this file.
1 
5 /*
6  * This file was generated automatically by function.py.
7  * Please do not modify it directly, edit function.cppy instead!
8  * function.py options: maxargs=14
9  *
10  * GiNaC Copyright (C) 1999-2020 Johannes Gutenberg University Mainz, Germany
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 #include "function.h"
28 #include "operators.h"
29 #include "fderivative.h"
30 #include "ex.h"
31 #include "lst.h"
32 #include "symmetry.h"
33 #include "print.h"
34 #include "power.h"
35 #include "archive.h"
36 #include "inifcns.h"
37 #include "utils.h"
38 #include "hash_seed.h"
39 #include "remember.h"
40 
41 #include <iostream>
42 #include <limits>
43 #include <list>
44 #include <stdexcept>
45 #include <string>
46 
47 namespace GiNaC {
48 
50 // helper class function_options
52 
54 {
55  initialize();
56 }
57 
58 function_options::function_options(std::string const & n, std::string const & tn)
59 {
60  initialize();
61  set_name(n, tn);
62 }
63 
64 function_options::function_options(std::string const & n, unsigned np)
65 {
66  initialize();
67  set_name(n, std::string());
68  nparams = np;
69 }
70 
72 {
73  // nothing to clean up at the moment
74 }
75 
77 {
78  set_name("unnamed_function", "\\mbox{unnamed}");
79  nparams = 0;
82  info_f = nullptr;
83  evalf_params_first = true;
84  use_return_type = false;
85  eval_use_exvector_args = false;
96  info_use_exvector_args = false;
97  use_remember = false;
99  symtree = 0;
100 }
101 
103  std::string const & tn)
104 {
105  name = n;
106  if (tn==std::string())
107  TeX_name = "\\mbox{"+name+"}";
108  else
109  TeX_name = tn;
110  return *this;
111 }
112 
114 {
115  TeX_name = tn;
116  return *this;
117 }
118 
119 // the following lines have been generated for max. 14 parameters
121 {
123  eval_f = eval_funcp(e);
124  return *this;
125 }
127 {
129  eval_f = eval_funcp(e);
130  return *this;
131 }
133 {
135  eval_f = eval_funcp(e);
136  return *this;
137 }
139 {
141  eval_f = eval_funcp(e);
142  return *this;
143 }
145 {
147  eval_f = eval_funcp(e);
148  return *this;
149 }
151 {
153  eval_f = eval_funcp(e);
154  return *this;
155 }
157 {
159  eval_f = eval_funcp(e);
160  return *this;
161 }
163 {
165  eval_f = eval_funcp(e);
166  return *this;
167 }
169 {
171  eval_f = eval_funcp(e);
172  return *this;
173 }
175 {
177  eval_f = eval_funcp(e);
178  return *this;
179 }
181 {
183  eval_f = eval_funcp(e);
184  return *this;
185 }
187 {
189  eval_f = eval_funcp(e);
190  return *this;
191 }
193 {
195  eval_f = eval_funcp(e);
196  return *this;
197 }
199 {
201  eval_f = eval_funcp(e);
202  return *this;
203 }
205 {
207  evalf_f = evalf_funcp(e);
208  return *this;
209 }
211 {
213  evalf_f = evalf_funcp(e);
214  return *this;
215 }
217 {
219  evalf_f = evalf_funcp(e);
220  return *this;
221 }
223 {
225  evalf_f = evalf_funcp(e);
226  return *this;
227 }
229 {
231  evalf_f = evalf_funcp(e);
232  return *this;
233 }
235 {
237  evalf_f = evalf_funcp(e);
238  return *this;
239 }
241 {
243  evalf_f = evalf_funcp(e);
244  return *this;
245 }
247 {
249  evalf_f = evalf_funcp(e);
250  return *this;
251 }
253 {
255  evalf_f = evalf_funcp(e);
256  return *this;
257 }
259 {
261  evalf_f = evalf_funcp(e);
262  return *this;
263 }
265 {
267  evalf_f = evalf_funcp(e);
268  return *this;
269 }
271 {
273  evalf_f = evalf_funcp(e);
274  return *this;
275 }
277 {
279  evalf_f = evalf_funcp(e);
280  return *this;
281 }
283 {
285  evalf_f = evalf_funcp(e);
286  return *this;
287 }
289 {
292  return *this;
293 }
295 {
298  return *this;
299 }
301 {
304  return *this;
305 }
307 {
310  return *this;
311 }
313 {
316  return *this;
317 }
319 {
322  return *this;
323 }
325 {
328  return *this;
329 }
331 {
334  return *this;
335 }
337 {
340  return *this;
341 }
343 {
346  return *this;
347 }
349 {
352  return *this;
353 }
355 {
358  return *this;
359 }
361 {
364  return *this;
365 }
367 {
370  return *this;
371 }
373 {
376  return *this;
377 }
379 {
382  return *this;
383 }
385 {
388  return *this;
389 }
391 {
394  return *this;
395 }
397 {
400  return *this;
401 }
403 {
406  return *this;
407 }
409 {
412  return *this;
413 }
415 {
418  return *this;
419 }
421 {
424  return *this;
425 }
427 {
430  return *this;
431 }
433 {
436  return *this;
437 }
439 {
442  return *this;
443 }
445 {
448  return *this;
449 }
451 {
454  return *this;
455 }
457 {
460  return *this;
461 }
463 {
466  return *this;
467 }
469 {
472  return *this;
473 }
475 {
478  return *this;
479 }
481 {
484  return *this;
485 }
487 {
490  return *this;
491 }
493 {
496  return *this;
497 }
499 {
502  return *this;
503 }
505 {
508  return *this;
509 }
511 {
514  return *this;
515 }
517 {
520  return *this;
521 }
523 {
526  return *this;
527 }
529 {
532  return *this;
533 }
535 {
538  return *this;
539 }
541 {
543  expand_f = expand_funcp(e);
544  return *this;
545 }
547 {
549  expand_f = expand_funcp(e);
550  return *this;
551 }
553 {
555  expand_f = expand_funcp(e);
556  return *this;
557 }
559 {
561  expand_f = expand_funcp(e);
562  return *this;
563 }
565 {
567  expand_f = expand_funcp(e);
568  return *this;
569 }
571 {
573  expand_f = expand_funcp(e);
574  return *this;
575 }
577 {
579  expand_f = expand_funcp(e);
580  return *this;
581 }
583 {
585  expand_f = expand_funcp(e);
586  return *this;
587 }
589 {
591  expand_f = expand_funcp(e);
592  return *this;
593 }
595 {
597  expand_f = expand_funcp(e);
598  return *this;
599 }
601 {
603  expand_f = expand_funcp(e);
604  return *this;
605 }
607 {
609  expand_f = expand_funcp(e);
610  return *this;
611 }
613 {
615  expand_f = expand_funcp(e);
616  return *this;
617 }
619 {
621  expand_f = expand_funcp(e);
622  return *this;
623 }
625 {
628  return *this;
629 }
631 {
634  return *this;
635 }
637 {
640  return *this;
641 }
643 {
646  return *this;
647 }
649 {
652  return *this;
653 }
655 {
658  return *this;
659 }
661 {
664  return *this;
665 }
667 {
670  return *this;
671 }
673 {
676  return *this;
677 }
679 {
682  return *this;
683 }
685 {
688  return *this;
689 }
691 {
694  return *this;
695 }
697 {
700  return *this;
701 }
703 {
706  return *this;
707 }
709 {
712  return *this;
713 }
715 {
718  return *this;
719 }
721 {
724  return *this;
725 }
727 {
730  return *this;
731 }
733 {
736  return *this;
737 }
739 {
742  return *this;
743 }
745 {
748  return *this;
749 }
751 {
754  return *this;
755 }
757 {
760  return *this;
761 }
763 {
766  return *this;
767 }
769 {
772  return *this;
773 }
775 {
778  return *this;
779 }
781 {
784  return *this;
785 }
787 {
790  return *this;
791 }
793 {
795  power_f = power_funcp(e);
796  return *this;
797 }
799 {
801  power_f = power_funcp(e);
802  return *this;
803 }
805 {
807  power_f = power_funcp(e);
808  return *this;
809 }
811 {
813  power_f = power_funcp(e);
814  return *this;
815 }
817 {
819  power_f = power_funcp(e);
820  return *this;
821 }
823 {
825  power_f = power_funcp(e);
826  return *this;
827 }
829 {
831  power_f = power_funcp(e);
832  return *this;
833 }
835 {
837  power_f = power_funcp(e);
838  return *this;
839 }
841 {
843  power_f = power_funcp(e);
844  return *this;
845 }
847 {
849  power_f = power_funcp(e);
850  return *this;
851 }
853 {
855  power_f = power_funcp(e);
856  return *this;
857 }
859 {
861  power_f = power_funcp(e);
862  return *this;
863 }
865 {
867  power_f = power_funcp(e);
868  return *this;
869 }
871 {
873  power_f = power_funcp(e);
874  return *this;
875 }
877 {
879  series_f = series_funcp(e);
880  return *this;
881 }
883 {
885  series_f = series_funcp(e);
886  return *this;
887 }
889 {
891  series_f = series_funcp(e);
892  return *this;
893 }
895 {
897  series_f = series_funcp(e);
898  return *this;
899 }
901 {
903  series_f = series_funcp(e);
904  return *this;
905 }
907 {
909  series_f = series_funcp(e);
910  return *this;
911 }
913 {
915  series_f = series_funcp(e);
916  return *this;
917 }
919 {
921  series_f = series_funcp(e);
922  return *this;
923 }
925 {
927  series_f = series_funcp(e);
928  return *this;
929 }
931 {
933  series_f = series_funcp(e);
934  return *this;
935 }
937 {
939  series_f = series_funcp(e);
940  return *this;
941 }
943 {
945  series_f = series_funcp(e);
946  return *this;
947 }
949 {
951  series_f = series_funcp(e);
952  return *this;
953 }
955 {
957  series_f = series_funcp(e);
958  return *this;
959 }
961 {
963  info_f = info_funcp(e);
964  return *this;
965 }
967 {
969  info_f = info_funcp(e);
970  return *this;
971 }
973 {
975  info_f = info_funcp(e);
976  return *this;
977 }
979 {
981  info_f = info_funcp(e);
982  return *this;
983 }
985 {
987  info_f = info_funcp(e);
988  return *this;
989 }
991 {
993  info_f = info_funcp(e);
994  return *this;
995 }
997 {
999  info_f = info_funcp(e);
1000  return *this;
1001 }
1003 {
1005  info_f = info_funcp(e);
1006  return *this;
1007 }
1009 {
1011  info_f = info_funcp(e);
1012  return *this;
1013 }
1015 {
1017  info_f = info_funcp(e);
1018  return *this;
1019 }
1021 {
1023  info_f = info_funcp(e);
1024  return *this;
1025 }
1027 {
1029  info_f = info_funcp(e);
1030  return *this;
1031 }
1033 {
1035  info_f = info_funcp(e);
1036  return *this;
1037 }
1039 {
1041  info_f = info_funcp(e);
1042  return *this;
1043 }
1044 // end of generated lines
1045 
1047 {
1048  eval_use_exvector_args = true;
1049  eval_f = eval_funcp(e);
1050  return *this;
1051 }
1053 {
1054  evalf_use_exvector_args = true;
1055  evalf_f = evalf_funcp(e);
1056  return *this;
1057 }
1059 {
1062  return *this;
1063 }
1065 {
1068  return *this;
1069 }
1071 {
1074  return *this;
1075 }
1077 {
1078  expand_use_exvector_args = true;
1079  expand_f = expand_funcp(e);
1080  return *this;
1081 }
1083 {
1086  return *this;
1087 }
1089 {
1092  return *this;
1093 }
1095 {
1096  power_use_exvector_args = true;
1097  power_f = power_funcp(e);
1098  return *this;
1099 }
1101 {
1102  series_use_exvector_args = true;
1103  series_f = series_funcp(e);
1104  return *this;
1105 }
1107 {
1108  info_use_exvector_args = true;
1109  info_f = info_funcp(e);
1110  return *this;
1111 }
1112 
1113 // end of generated lines
1114 
1116 {
1117  use_return_type = true;
1118  return_type = rt;
1119  if (rtt != nullptr)
1120  return_type_tinfo = *rtt;
1121  else
1122  return_type_tinfo = make_return_type_t<function>();
1123  return *this;
1124 }
1125 
1127 {
1128  evalf_params_first = false;
1129  return *this;
1130 }
1131 
1133  unsigned assoc_size,
1134  unsigned strategy)
1135 {
1136  use_remember = true;
1137  remember_size = size;
1138  remember_assoc_size = assoc_size;
1139  remember_strategy = strategy;
1140  return *this;
1141 }
1142 
1144 {
1146  return *this;
1147 }
1148 
1150 {
1151  symtree = s;
1152  return *this;
1153 }
1154 
1156 {
1157  if (nparams==0) {
1158  nparams = n;
1159  } else if (nparams!=n) {
1160  // we do not throw an exception here because this code is
1161  // usually executed before main(), so the exception could not
1162  // be caught anyhow
1163  std::cerr << "WARNING: " << name << "(): number of parameters ("
1164  << n << ") differs from number set before ("
1165  << nparams << ")" << std::endl;
1166  }
1167 }
1168 
1170 {
1171  if (id >= print_dispatch_table.size())
1172  print_dispatch_table.resize(id + 1);
1173  print_dispatch_table[id] = f;
1174 }
1175 
1177 unsigned function::current_serial = 0;
1178 
1179 
1181 
1182 // default constructor
1185 
1186 // public
1187 
1188 function::function() : serial(0)
1189 {
1190 }
1191 
1193 // other constructors
1195 
1196 // public
1197 
1198 function::function(unsigned ser) : serial(ser)
1199 {
1200 }
1201 
1202 // the following lines have been generated for max. 14 parameters
1203 function::function(unsigned ser, const ex & param1)
1204  : exprseq{param1}, serial(ser)
1205 {
1206 }
1207 function::function(unsigned ser, const ex & param1, const ex & param2)
1208  : exprseq{param1, param2}, serial(ser)
1209 {
1210 }
1211 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3)
1212  : exprseq{param1, param2, param3}, serial(ser)
1213 {
1214 }
1215 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4)
1216  : exprseq{param1, param2, param3, param4}, serial(ser)
1217 {
1218 }
1219 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5)
1220  : exprseq{param1, param2, param3, param4, param5}, serial(ser)
1221 {
1222 }
1223 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6)
1224  : exprseq{param1, param2, param3, param4, param5, param6}, serial(ser)
1225 {
1226 }
1227 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6, const ex & param7)
1228  : exprseq{param1, param2, param3, param4, param5, param6, param7}, serial(ser)
1229 {
1230 }
1231 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6, const ex & param7, const ex & param8)
1232  : exprseq{param1, param2, param3, param4, param5, param6, param7, param8}, serial(ser)
1233 {
1234 }
1235 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6, const ex & param7, const ex & param8, const ex & param9)
1236  : exprseq{param1, param2, param3, param4, param5, param6, param7, param8, param9}, serial(ser)
1237 {
1238 }
1239 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6, const ex & param7, const ex & param8, const ex & param9, const ex & param10)
1240  : exprseq{param1, param2, param3, param4, param5, param6, param7, param8, param9, param10}, serial(ser)
1241 {
1242 }
1243 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6, const ex & param7, const ex & param8, const ex & param9, const ex & param10, const ex & param11)
1244  : exprseq{param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11}, serial(ser)
1245 {
1246 }
1247 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6, const ex & param7, const ex & param8, const ex & param9, const ex & param10, const ex & param11, const ex & param12)
1248  : exprseq{param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12}, serial(ser)
1249 {
1250 }
1251 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6, const ex & param7, const ex & param8, const ex & param9, const ex & param10, const ex & param11, const ex & param12, const ex & param13)
1252  : exprseq{param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13}, serial(ser)
1253 {
1254 }
1255 function::function(unsigned ser, const ex & param1, const ex & param2, const ex & param3, const ex & param4, const ex & param5, const ex & param6, const ex & param7, const ex & param8, const ex & param9, const ex & param10, const ex & param11, const ex & param12, const ex & param13, const ex & param14)
1256  : exprseq{param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11, param12, param13, param14}, serial(ser)
1257 {
1258 }
1259 
1260 function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser)
1261 {
1262 
1263  // Force re-evaluation even if the exprseq was already evaluated
1264  // (the exprseq copy constructor copies the flags)
1266 }
1267 
1268 function::function(unsigned ser, const exvector & v)
1269  : exprseq(v), serial(ser)
1270 {
1271 }
1272 
1273 function::function(unsigned ser, exvector && v)
1274  : exprseq(std::move(v)), serial(ser)
1275 {
1276 }
1277 
1279 // archiving
1281 
1284 {
1285  inherited::read_archive(n, sym_lst);
1286  // Find serial number by function name and number of parameters
1287  unsigned np = seq.size();
1288  std::string s;
1289  if (n.find_string("name", s)) {
1290  unsigned int ser = 0;
1291  for (auto & it : registered_functions()) {
1292  if (s == it.name && np == registered_functions()[ser].nparams) {
1293  serial = ser;
1294  return;
1295  }
1296  ++ser;
1297  }
1298  throw (std::runtime_error("unknown function '" + s +
1299  "' with " + std::to_string(np) + " parameters in archive"));
1300  } else
1301  throw (std::runtime_error("unnamed function in archive"));
1302 }
1303 
1306 {
1307  inherited::archive(n);
1309  n.add_string("name", registered_functions()[serial].name);
1310 }
1311 
1313 
1315 // functions overriding virtual functions from base classes
1317 
1318 // public
1319 
1320 void function::print(const print_context & c, unsigned level) const
1321 {
1324  const std::vector<print_funcp> &pdt = opt.print_dispatch_table;
1325 
1326  // Dynamically dispatch on print_context type
1327  const print_context_class_info *pc_info = &c.get_class_info();
1328 
1329 next_context:
1330  unsigned id = pc_info->options.get_id();
1331  if (id >= pdt.size() || pdt[id] == nullptr) {
1332 
1333  // Method not found, try parent print_context class
1334  const print_context_class_info *parent_pc_info = pc_info->get_parent();
1335  if (parent_pc_info) {
1336  pc_info = parent_pc_info;
1337  goto next_context;
1338  }
1339 
1340  // Method still not found, use default output
1341  if (is_a<print_tree>(c)) {
1342 
1343  c.s << std::string(level, ' ') << class_name() << " "
1344  << opt.name << " @" << this
1345  << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
1346  << ", nops=" << nops()
1347  << std::endl;
1348  unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
1349  for (size_t i=0; i<seq.size(); ++i)
1350  seq[i].print(c, level + delta_indent);
1351  c.s << std::string(level + delta_indent, ' ') << "=====" << std::endl;
1352 
1353  } else if (is_a<print_csrc>(c)) {
1354 
1355  // Print function name in lowercase
1356  std::string lname = opt.name;
1357  size_t num = lname.size();
1358  for (size_t i=0; i<num; i++)
1359  lname[i] = tolower(lname[i]);
1360  c.s << lname;
1361  printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
1362 
1363  } else if (is_a<print_latex>(c)) {
1364  c.s << opt.TeX_name;
1365  printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
1366  } else {
1367  c.s << opt.name;
1368  printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
1369  }
1370 
1371  } else {
1372 
1373  // Method found, call it
1375  if (opt.print_use_exvector_args)
1376  ((print_funcp_exvector)pdt[id])(seq, c);
1377  else switch (opt.nparams) {
1378  // the following lines have been generated for max. 14 parameters
1379  case 1:
1380  ((print_funcp_1)(pdt[id]))(seq[0], c);
1381  break;
1382  case 2:
1383  ((print_funcp_2)(pdt[id]))(seq[0], seq[1], c);
1384  break;
1385  case 3:
1386  ((print_funcp_3)(pdt[id]))(seq[0], seq[1], seq[2], c);
1387  break;
1388  case 4:
1389  ((print_funcp_4)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], c);
1390  break;
1391  case 5:
1392  ((print_funcp_5)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], c);
1393  break;
1394  case 6:
1395  ((print_funcp_6)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], c);
1396  break;
1397  case 7:
1398  ((print_funcp_7)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], c);
1399  break;
1400  case 8:
1401  ((print_funcp_8)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], c);
1402  break;
1403  case 9:
1404  ((print_funcp_9)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], c);
1405  break;
1406  case 10:
1407  ((print_funcp_10)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], c);
1408  break;
1409  case 11:
1410  ((print_funcp_11)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], c);
1411  break;
1412  case 12:
1413  ((print_funcp_12)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], c);
1414  break;
1415  case 13:
1416  ((print_funcp_13)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], c);
1417  break;
1418  case 14:
1419  ((print_funcp_14)(pdt[id]))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13], c);
1420  break;
1421  // end of generated lines
1422  default:
1423  throw(std::logic_error("function::print(): invalid nparams"));
1424  }
1425  }
1426 }
1427 
1429 {
1431  return *this;
1432  }
1433 
1436 
1437  // Canonicalize argument order according to the symmetry properties
1438  if (seq.size() > 1 && !(opt.symtree.is_zero())) {
1439  exvector v = seq;
1440  GINAC_ASSERT(is_a<symmetry>(opt.symtree));
1441  int sig = canonicalize(v.begin(), ex_to<symmetry>(opt.symtree));
1442  if (sig != std::numeric_limits<int>::max()) {
1443  // Something has changed while sorting arguments, more evaluations later
1444  if (sig == 0)
1445  return _ex0;
1446  return ex(sig) * thiscontainer(std::move(v));
1447  }
1448  }
1449 
1450  if (opt.eval_f==nullptr) {
1451  return this->hold();
1452  }
1453 
1454  bool use_remember = opt.use_remember;
1455  ex eval_result;
1456  if (use_remember && lookup_remember_table(eval_result)) {
1457  return eval_result;
1458  }
1460  if (opt.eval_use_exvector_args)
1461  eval_result = ((eval_funcp_exvector)(opt.eval_f))(seq);
1462  else
1463  switch (opt.nparams) {
1464  // the following lines have been generated for max. 14 parameters
1465  case 1:
1466  eval_result = ((eval_funcp_1)(opt.eval_f))(seq[0]);
1467  break;
1468  case 2:
1469  eval_result = ((eval_funcp_2)(opt.eval_f))(seq[0], seq[1]);
1470  break;
1471  case 3:
1472  eval_result = ((eval_funcp_3)(opt.eval_f))(seq[0], seq[1], seq[2]);
1473  break;
1474  case 4:
1475  eval_result = ((eval_funcp_4)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3]);
1476  break;
1477  case 5:
1478  eval_result = ((eval_funcp_5)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4]);
1479  break;
1480  case 6:
1481  eval_result = ((eval_funcp_6)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5]);
1482  break;
1483  case 7:
1484  eval_result = ((eval_funcp_7)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6]);
1485  break;
1486  case 8:
1487  eval_result = ((eval_funcp_8)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7]);
1488  break;
1489  case 9:
1490  eval_result = ((eval_funcp_9)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8]);
1491  break;
1492  case 10:
1493  eval_result = ((eval_funcp_10)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9]);
1494  break;
1495  case 11:
1496  eval_result = ((eval_funcp_11)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10]);
1497  break;
1498  case 12:
1499  eval_result = ((eval_funcp_12)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11]);
1500  break;
1501  case 13:
1502  eval_result = ((eval_funcp_13)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12]);
1503  break;
1504  case 14:
1505  eval_result = ((eval_funcp_14)(opt.eval_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13]);
1506  break;
1507  // end of generated lines
1508  default:
1509  throw(std::logic_error("function::eval(): invalid nparams"));
1510  }
1511  if (use_remember) {
1512  store_remember_table(eval_result);
1513  }
1514  return eval_result;
1515 }
1516 
1518 {
1521 
1522  // Evaluate children first
1523  exvector eseq;
1524  if (!opt.evalf_params_first)
1525  eseq = seq;
1526  else {
1527  eseq.reserve(seq.size());
1528  for (auto & it : seq) {
1529  eseq.push_back(it.evalf());
1530  }
1531  }
1532 
1533  if (opt.evalf_f==nullptr) {
1534  return function(serial,eseq).hold();
1535  }
1537  if (opt.evalf_use_exvector_args)
1538  return ((evalf_funcp_exvector)(opt.evalf_f))(seq);
1539  switch (opt.nparams) {
1540  // the following lines have been generated for max. 14 parameters
1541  case 1:
1542  return ((evalf_funcp_1)(opt.evalf_f))(eseq[0]);
1543  case 2:
1544  return ((evalf_funcp_2)(opt.evalf_f))(eseq[0], eseq[1]);
1545  case 3:
1546  return ((evalf_funcp_3)(opt.evalf_f))(eseq[0], eseq[1], eseq[2]);
1547  case 4:
1548  return ((evalf_funcp_4)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3]);
1549  case 5:
1550  return ((evalf_funcp_5)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4]);
1551  case 6:
1552  return ((evalf_funcp_6)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5]);
1553  case 7:
1554  return ((evalf_funcp_7)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5], eseq[6]);
1555  case 8:
1556  return ((evalf_funcp_8)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5], eseq[6], eseq[7]);
1557  case 9:
1558  return ((evalf_funcp_9)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5], eseq[6], eseq[7], eseq[8]);
1559  case 10:
1560  return ((evalf_funcp_10)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5], eseq[6], eseq[7], eseq[8], eseq[9]);
1561  case 11:
1562  return ((evalf_funcp_11)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5], eseq[6], eseq[7], eseq[8], eseq[9], eseq[10]);
1563  case 12:
1564  return ((evalf_funcp_12)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5], eseq[6], eseq[7], eseq[8], eseq[9], eseq[10], eseq[11]);
1565  case 13:
1566  return ((evalf_funcp_13)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5], eseq[6], eseq[7], eseq[8], eseq[9], eseq[10], eseq[11], eseq[12]);
1567  case 14:
1568  return ((evalf_funcp_14)(opt.evalf_f))(eseq[0], eseq[1], eseq[2], eseq[3], eseq[4], eseq[5], eseq[6], eseq[7], eseq[8], eseq[9], eseq[10], eseq[11], eseq[12], eseq[13]);
1569  // end of generated lines
1570  }
1571  throw(std::logic_error("function::evalf(): invalid nparams"));
1572 }
1573 
1578 {
1579  // If this function is called then the list of arguments is non-empty
1580  // and the first argument is non-commutative, see function::return_type()
1581  return seq.begin()->eval_ncmul(v);
1582 }
1583 
1584 unsigned function::calchash() const
1585 {
1586  unsigned v = golden_ratio_hash(make_hash_seed(typeid(*this)) ^ serial);
1587  for (size_t i=0; i<nops(); i++) {
1588  v = rotate_left(v);
1589  v ^= this->op(i).gethash();
1590  }
1591 
1594  hashvalue = v;
1595  }
1596  return v;
1597 }
1598 
1600 {
1601  return function(serial, v);
1602 }
1603 
1605 {
1606  return function(serial, std::move(v));
1607 }
1608 
1611 ex function::series(const relational & r, int order, unsigned options) const
1612 {
1615 
1616  if (opt.series_f==nullptr) {
1617  return basic::series(r, order);
1618  }
1619  ex res;
1621  if (opt.series_use_exvector_args) {
1622  try {
1623  res = ((series_funcp_exvector)(opt.series_f))(seq, r, order, options);
1624  } catch (do_taylor) {
1625  res = basic::series(r, order, options);
1626  }
1627  return res;
1628  }
1629  switch (opt.nparams) {
1630  // the following lines have been generated for max. 14 parameters
1631  case 1:
1632  try {
1633  res = ((series_funcp_1)(opt.series_f))(seq[0], r, order, options);
1634  } catch (do_taylor) {
1635  res = basic::series(r, order, options);
1636  }
1637  return res;
1638  case 2:
1639  try {
1640  res = ((series_funcp_2)(opt.series_f))(seq[0], seq[1], r, order, options);
1641  } catch (do_taylor) {
1642  res = basic::series(r, order, options);
1643  }
1644  return res;
1645  case 3:
1646  try {
1647  res = ((series_funcp_3)(opt.series_f))(seq[0], seq[1], seq[2], r, order, options);
1648  } catch (do_taylor) {
1649  res = basic::series(r, order, options);
1650  }
1651  return res;
1652  case 4:
1653  try {
1654  res = ((series_funcp_4)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], r, order, options);
1655  } catch (do_taylor) {
1656  res = basic::series(r, order, options);
1657  }
1658  return res;
1659  case 5:
1660  try {
1661  res = ((series_funcp_5)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], r, order, options);
1662  } catch (do_taylor) {
1663  res = basic::series(r, order, options);
1664  }
1665  return res;
1666  case 6:
1667  try {
1668  res = ((series_funcp_6)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], r, order, options);
1669  } catch (do_taylor) {
1670  res = basic::series(r, order, options);
1671  }
1672  return res;
1673  case 7:
1674  try {
1675  res = ((series_funcp_7)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], r, order, options);
1676  } catch (do_taylor) {
1677  res = basic::series(r, order, options);
1678  }
1679  return res;
1680  case 8:
1681  try {
1682  res = ((series_funcp_8)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], r, order, options);
1683  } catch (do_taylor) {
1684  res = basic::series(r, order, options);
1685  }
1686  return res;
1687  case 9:
1688  try {
1689  res = ((series_funcp_9)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], r, order, options);
1690  } catch (do_taylor) {
1691  res = basic::series(r, order, options);
1692  }
1693  return res;
1694  case 10:
1695  try {
1696  res = ((series_funcp_10)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], r, order, options);
1697  } catch (do_taylor) {
1698  res = basic::series(r, order, options);
1699  }
1700  return res;
1701  case 11:
1702  try {
1703  res = ((series_funcp_11)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], r, order, options);
1704  } catch (do_taylor) {
1705  res = basic::series(r, order, options);
1706  }
1707  return res;
1708  case 12:
1709  try {
1710  res = ((series_funcp_12)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], r, order, options);
1711  } catch (do_taylor) {
1712  res = basic::series(r, order, options);
1713  }
1714  return res;
1715  case 13:
1716  try {
1717  res = ((series_funcp_13)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], r, order, options);
1718  } catch (do_taylor) {
1719  res = basic::series(r, order, options);
1720  }
1721  return res;
1722  case 14:
1723  try {
1724  res = ((series_funcp_14)(opt.series_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13], r, order, options);
1725  } catch (do_taylor) {
1726  res = basic::series(r, order, options);
1727  }
1728  return res;
1729  // end of generated lines
1730  }
1731  throw(std::logic_error("function::series(): invalid nparams"));
1732 }
1733 
1736 {
1738  const function_options & opt = registered_functions()[serial];
1739 
1740  if (opt.conjugate_f==nullptr) {
1741  return conjugate_function(*this).hold();
1742  }
1743 
1744  if (opt.conjugate_use_exvector_args) {
1745  return ((conjugate_funcp_exvector)(opt.conjugate_f))(seq);
1746  }
1747 
1748  switch (opt.nparams) {
1749  // the following lines have been generated for max. 14 parameters
1750  case 1:
1751  return ((conjugate_funcp_1)(opt.conjugate_f))(seq[0]);
1752  case 2:
1753  return ((conjugate_funcp_2)(opt.conjugate_f))(seq[0], seq[1]);
1754  case 3:
1755  return ((conjugate_funcp_3)(opt.conjugate_f))(seq[0], seq[1], seq[2]);
1756  case 4:
1757  return ((conjugate_funcp_4)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3]);
1758  case 5:
1759  return ((conjugate_funcp_5)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4]);
1760  case 6:
1761  return ((conjugate_funcp_6)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5]);
1762  case 7:
1763  return ((conjugate_funcp_7)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6]);
1764  case 8:
1765  return ((conjugate_funcp_8)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7]);
1766  case 9:
1767  return ((conjugate_funcp_9)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8]);
1768  case 10:
1769  return ((conjugate_funcp_10)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9]);
1770  case 11:
1771  return ((conjugate_funcp_11)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10]);
1772  case 12:
1773  return ((conjugate_funcp_12)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11]);
1774  case 13:
1775  return ((conjugate_funcp_13)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12]);
1776  case 14:
1777  return ((conjugate_funcp_14)(opt.conjugate_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13]);
1778  // end of generated lines
1779  }
1780  throw(std::logic_error("function::conjugate(): invalid nparams"));
1781 }
1782 
1785 {
1787  const function_options & opt = registered_functions()[serial];
1788 
1789  if (opt.real_part_f==nullptr)
1790  return basic::real_part();
1791 
1793  return ((real_part_funcp_exvector)(opt.real_part_f))(seq);
1794 
1795  switch (opt.nparams) {
1796  // the following lines have been generated for max. 14 parameters
1797  case 1:
1798  return ((real_part_funcp_1)(opt.real_part_f))(seq[0]);
1799  case 2:
1800  return ((real_part_funcp_2)(opt.real_part_f))(seq[0], seq[1]);
1801  case 3:
1802  return ((real_part_funcp_3)(opt.real_part_f))(seq[0], seq[1], seq[2]);
1803  case 4:
1804  return ((real_part_funcp_4)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3]);
1805  case 5:
1806  return ((real_part_funcp_5)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4]);
1807  case 6:
1808  return ((real_part_funcp_6)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5]);
1809  case 7:
1810  return ((real_part_funcp_7)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6]);
1811  case 8:
1812  return ((real_part_funcp_8)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7]);
1813  case 9:
1814  return ((real_part_funcp_9)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8]);
1815  case 10:
1816  return ((real_part_funcp_10)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9]);
1817  case 11:
1818  return ((real_part_funcp_11)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10]);
1819  case 12:
1820  return ((real_part_funcp_12)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11]);
1821  case 13:
1822  return ((real_part_funcp_13)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12]);
1823  case 14:
1824  return ((real_part_funcp_14)(opt.real_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13]);
1825  // end of generated lines
1826  }
1827  throw(std::logic_error("function::real_part(): invalid nparams"));
1828 }
1829 
1832 {
1834  const function_options & opt = registered_functions()[serial];
1835 
1836  if (opt.imag_part_f==nullptr)
1837  return basic::imag_part();
1838 
1840  return ((imag_part_funcp_exvector)(opt.imag_part_f))(seq);
1841 
1842  switch (opt.nparams) {
1843  // the following lines have been generated for max. 14 parameters
1844  case 1:
1845  return ((imag_part_funcp_1)(opt.imag_part_f))(seq[0]);
1846  case 2:
1847  return ((imag_part_funcp_2)(opt.imag_part_f))(seq[0], seq[1]);
1848  case 3:
1849  return ((imag_part_funcp_3)(opt.imag_part_f))(seq[0], seq[1], seq[2]);
1850  case 4:
1851  return ((imag_part_funcp_4)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3]);
1852  case 5:
1853  return ((imag_part_funcp_5)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4]);
1854  case 6:
1855  return ((imag_part_funcp_6)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5]);
1856  case 7:
1857  return ((imag_part_funcp_7)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6]);
1858  case 8:
1859  return ((imag_part_funcp_8)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7]);
1860  case 9:
1861  return ((imag_part_funcp_9)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8]);
1862  case 10:
1863  return ((imag_part_funcp_10)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9]);
1864  case 11:
1865  return ((imag_part_funcp_11)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10]);
1866  case 12:
1867  return ((imag_part_funcp_12)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11]);
1868  case 13:
1869  return ((imag_part_funcp_13)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12]);
1870  case 14:
1871  return ((imag_part_funcp_14)(opt.imag_part_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13]);
1872  // end of generated lines
1873  }
1874  throw(std::logic_error("function::imag_part(): invalid nparams"));
1875 }
1876 
1878 bool function::info(unsigned inf) const
1879 {
1881  const function_options & opt = registered_functions()[serial];
1882 
1883  if (opt.info_f==nullptr) {
1884  return basic::info(inf);
1885  }
1886 
1887  if (opt.info_use_exvector_args) {
1888  return ((info_funcp_exvector)(opt.info_f))(seq, inf);
1889  }
1890 
1891  switch (opt.nparams) {
1892  // the following lines have been generated for max. 14 parameters
1893  case 1:
1894  return ((info_funcp_1)(opt.info_f))(seq[0], inf);
1895  case 2:
1896  return ((info_funcp_2)(opt.info_f))(seq[0], seq[1], inf);
1897  case 3:
1898  return ((info_funcp_3)(opt.info_f))(seq[0], seq[1], seq[2], inf);
1899  case 4:
1900  return ((info_funcp_4)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], inf);
1901  case 5:
1902  return ((info_funcp_5)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], inf);
1903  case 6:
1904  return ((info_funcp_6)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], inf);
1905  case 7:
1906  return ((info_funcp_7)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], inf);
1907  case 8:
1908  return ((info_funcp_8)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], inf);
1909  case 9:
1910  return ((info_funcp_9)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], inf);
1911  case 10:
1912  return ((info_funcp_10)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], inf);
1913  case 11:
1914  return ((info_funcp_11)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], inf);
1915  case 12:
1916  return ((info_funcp_12)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], inf);
1917  case 13:
1918  return ((info_funcp_13)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], inf);
1919  case 14:
1920  return ((info_funcp_14)(opt.info_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13], inf);
1921  // end of generated lines
1922  }
1923  throw(std::logic_error("function::info(): invalid nparams"));
1924 }
1925 
1926 // protected
1927 
1932 {
1933  ex result;
1934 
1935  try {
1936  // Explicit derivation
1937  result = expl_derivative(s);
1938  } catch (...) {
1939  // Chain rule
1940  ex arg_diff;
1941  size_t num = seq.size();
1942  for (size_t i=0; i<num; i++) {
1943  arg_diff = seq[i].diff(s);
1944  // We apply the chain rule only when it makes sense. This is not
1945  // just for performance reasons but also to allow functions to
1946  // throw when differentiated with respect to one of its arguments
1947  // without running into trouble with our automatic full
1948  // differentiation:
1949  if (!arg_diff.is_zero())
1950  result += pderivative(i)*arg_diff;
1951  }
1952  }
1953  return result;
1954 }
1955 
1956 int function::compare_same_type(const basic & other) const
1957 {
1958  GINAC_ASSERT(is_a<function>(other));
1959  const function & o = static_cast<const function &>(other);
1960 
1961  if (serial != o.serial)
1962  return serial < o.serial ? -1 : 1;
1963  else
1964  return exprseq::compare_same_type(o);
1965 }
1966 
1967 bool function::is_equal_same_type(const basic & other) const
1968 {
1969  GINAC_ASSERT(is_a<function>(other));
1970  const function & o = static_cast<const function &>(other);
1971 
1972  if (serial != o.serial)
1973  return false;
1974  else
1975  return exprseq::is_equal_same_type(o);
1976 }
1977 
1978 bool function::match_same_type(const basic & other) const
1979 {
1980  GINAC_ASSERT(is_a<function>(other));
1981  const function & o = static_cast<const function &>(other);
1982 
1983  return serial == o.serial;
1984 }
1985 
1986 unsigned function::return_type() const
1987 {
1990 
1991  if (opt.use_return_type) {
1992  // Return type was explicitly specified
1993  return opt.return_type;
1994  } else {
1995  // Default behavior is to use the return type of the first
1996  // argument. Thus, exp() of a matrix behaves like a matrix, etc.
1997  if (seq.empty())
1999  else
2000  return seq.begin()->return_type();
2001  }
2002 }
2003 
2005 {
2008 
2009  if (opt.use_return_type) {
2010  // Return type was explicitly specified
2011  return opt.return_type_tinfo;
2012  } else {
2013  // Default behavior is to use the return type of the first
2014  // argument. Thus, exp() of a matrix behaves like a matrix, etc.
2015  if (seq.empty())
2016  return make_return_type_t<function>();
2017  else
2018  return seq.begin()->return_type_tinfo();
2019  }
2020 }
2021 
2023 // new virtual functions which can be overridden by derived classes
2025 
2026 // none
2027 
2029 // non-virtual functions in this class
2031 
2032 // protected
2033 
2034 ex function::pderivative(unsigned diff_param) const // partial differentiation
2035 {
2036  GINAC_ASSERT(serial<registered_functions().size());
2037  const function_options &opt = registered_functions()[serial];
2038 
2039  if (opt.derivative_f) {
2040  // Invoke the defined derivative function.
2041  current_serial = serial;
2043  return ((derivative_funcp_exvector)(opt.derivative_f))(seq, diff_param);
2044  switch (opt.nparams) {
2045  // the following lines have been generated for max. 14 parameters
2046  case 1:
2047  return ((derivative_funcp_1)(opt.derivative_f))(seq[0], diff_param);
2048  case 2:
2049  return ((derivative_funcp_2)(opt.derivative_f))(seq[0], seq[1], diff_param);
2050  case 3:
2051  return ((derivative_funcp_3)(opt.derivative_f))(seq[0], seq[1], seq[2], diff_param);
2052  case 4:
2053  return ((derivative_funcp_4)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], diff_param);
2054  case 5:
2055  return ((derivative_funcp_5)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], diff_param);
2056  case 6:
2057  return ((derivative_funcp_6)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], diff_param);
2058  case 7:
2059  return ((derivative_funcp_7)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], diff_param);
2060  case 8:
2061  return ((derivative_funcp_8)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], diff_param);
2062  case 9:
2063  return ((derivative_funcp_9)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], diff_param);
2064  case 10:
2065  return ((derivative_funcp_10)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], diff_param);
2066  case 11:
2067  return ((derivative_funcp_11)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], diff_param);
2068  case 12:
2069  return ((derivative_funcp_12)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], diff_param);
2070  case 13:
2071  return ((derivative_funcp_13)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], diff_param);
2072  case 14:
2073  return ((derivative_funcp_14)(opt.derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13], diff_param);
2074  // end of generated lines
2075  }
2076  }
2077  // No derivative defined? Fall back to abstract derivative object.
2078  return fderivative(serial, diff_param, seq);
2079 }
2080 
2081 ex function::expl_derivative(const symbol & s) const // explicit differentiation
2082 {
2083  GINAC_ASSERT(serial<registered_functions().size());
2084  const function_options &opt = registered_functions()[serial];
2085 
2086  if (opt.expl_derivative_f) {
2087  // Invoke the defined explicit derivative function.
2088  current_serial = serial;
2090  return ((expl_derivative_funcp_exvector)(opt.expl_derivative_f))(seq, s);
2091  switch (opt.nparams) {
2092  // the following lines have been generated for max. 14 parameters
2093  case 1:
2094  return ((expl_derivative_funcp_1)(opt.expl_derivative_f))(seq[0], s);
2095  case 2:
2096  return ((expl_derivative_funcp_2)(opt.expl_derivative_f))(seq[0], seq[1], s);
2097  case 3:
2098  return ((expl_derivative_funcp_3)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], s);
2099  case 4:
2100  return ((expl_derivative_funcp_4)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], s);
2101  case 5:
2102  return ((expl_derivative_funcp_5)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], s);
2103  case 6:
2104  return ((expl_derivative_funcp_6)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], s);
2105  case 7:
2106  return ((expl_derivative_funcp_7)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], s);
2107  case 8:
2108  return ((expl_derivative_funcp_8)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], s);
2109  case 9:
2110  return ((expl_derivative_funcp_9)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], s);
2111  case 10:
2112  return ((expl_derivative_funcp_10)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], s);
2113  case 11:
2114  return ((expl_derivative_funcp_11)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], s);
2115  case 12:
2116  return ((expl_derivative_funcp_12)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], s);
2117  case 13:
2118  return ((expl_derivative_funcp_13)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], s);
2119  case 14:
2120  return ((expl_derivative_funcp_14)(opt.expl_derivative_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13], s);
2121  // end of generated lines
2122  }
2123  }
2124  // There is no fallback for explicit derivative.
2125  throw(std::logic_error("function::expl_derivative(): explicit derivation is called, but no such function defined"));
2126 }
2127 
2128 ex function::power(const ex & power_param) const // power of function
2129 {
2130  GINAC_ASSERT(serial<registered_functions().size());
2131  const function_options &opt = registered_functions()[serial];
2132 
2133  if (opt.power_f) {
2134  // Invoke the defined power function.
2135  current_serial = serial;
2136  if (opt.power_use_exvector_args)
2137  return ((power_funcp_exvector)(opt.power_f))(seq, power_param);
2138  switch (opt.nparams) {
2139  // the following lines have been generated for max. 14 parameters
2140  case 1:
2141  return ((power_funcp_1)(opt.power_f))(seq[0], power_param);
2142  case 2:
2143  return ((power_funcp_2)(opt.power_f))(seq[0], seq[1], power_param);
2144  case 3:
2145  return ((power_funcp_3)(opt.power_f))(seq[0], seq[1], seq[2], power_param);
2146  case 4:
2147  return ((power_funcp_4)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], power_param);
2148  case 5:
2149  return ((power_funcp_5)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], power_param);
2150  case 6:
2151  return ((power_funcp_6)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], power_param);
2152  case 7:
2153  return ((power_funcp_7)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], power_param);
2154  case 8:
2155  return ((power_funcp_8)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], power_param);
2156  case 9:
2157  return ((power_funcp_9)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], power_param);
2158  case 10:
2159  return ((power_funcp_10)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], power_param);
2160  case 11:
2161  return ((power_funcp_11)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], power_param);
2162  case 12:
2163  return ((power_funcp_12)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], power_param);
2164  case 13:
2165  return ((power_funcp_13)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], power_param);
2166  case 14:
2167  return ((power_funcp_14)(opt.power_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13], power_param);
2168  // end of generated lines
2169  }
2170  }
2171  // No power function defined? Fall back to returning a power object.
2172  return dynallocate<GiNaC::power>(*this, power_param).setflag(status_flags::evaluated);
2173 }
2174 
2175 ex function::expand(unsigned options) const
2176 {
2179 
2180  if (opt.expand_f) {
2181  // Invoke the defined expand function.
2183  if (opt.expand_use_exvector_args)
2184  return ((expand_funcp_exvector)(opt.expand_f))(seq, options);
2185  switch (opt.nparams) {
2186  // the following lines have been generated for max. 14 parameters
2187  case 1:
2188  return ((expand_funcp_1)(opt.expand_f))(seq[0], options);
2189  case 2:
2190  return ((expand_funcp_2)(opt.expand_f))(seq[0], seq[1], options);
2191  case 3:
2192  return ((expand_funcp_3)(opt.expand_f))(seq[0], seq[1], seq[2], options);
2193  case 4:
2194  return ((expand_funcp_4)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], options);
2195  case 5:
2196  return ((expand_funcp_5)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], options);
2197  case 6:
2198  return ((expand_funcp_6)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], options);
2199  case 7:
2200  return ((expand_funcp_7)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], options);
2201  case 8:
2202  return ((expand_funcp_8)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], options);
2203  case 9:
2204  return ((expand_funcp_9)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], options);
2205  case 10:
2206  return ((expand_funcp_10)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], options);
2207  case 11:
2208  return ((expand_funcp_11)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], options);
2209  case 12:
2210  return ((expand_funcp_12)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], options);
2211  case 13:
2212  return ((expand_funcp_13)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], options);
2213  case 14:
2214  return ((expand_funcp_14)(opt.expand_f))(seq[0], seq[1], seq[2], seq[3], seq[4], seq[5], seq[6], seq[7], seq[8], seq[9], seq[10], seq[11], seq[12], seq[13], options);
2215  // end of generated lines
2216  }
2217  }
2218  // No expand function defined? Return the same function with expanded arguments (if required)
2220  return inherited::expand(options);
2221  else
2222  return (options == 0) ? setflag(status_flags::expanded) : *this;
2223 }
2224 
2225 std::vector<function_options> & function::registered_functions()
2226 {
2227  static std::vector<function_options> rf = std::vector<function_options>();
2228  return rf;
2229 }
2230 
2232 {
2233  return remember_table::remember_tables()[this->serial].lookup_entry(*this,result);
2234 }
2235 
2236 void function::store_remember_table(ex const & result) const
2237 {
2238  remember_table::remember_tables()[this->serial].add_entry(*this,result);
2239 }
2240 
2241 // public
2242 
2244 {
2245  size_t same_name = 0;
2246  for (auto & i : registered_functions()) {
2247  if (i.name==opt.name) {
2248  ++same_name;
2249  }
2250  }
2251  if (same_name>=opt.functions_with_same_name) {
2252  // we do not throw an exception here because this code is
2253  // usually executed before main(), so the exception could not
2254  // caught anyhow
2255  std::cerr << "WARNING: function name " << opt.name
2256  << " already in use!" << std::endl;
2257  }
2258  registered_functions().push_back(opt);
2259  if (opt.use_remember) {
2261  push_back(remember_table(opt.remember_size,
2262  opt.remember_assoc_size,
2263  opt.remember_strategy));
2264  } else {
2266  }
2267  return registered_functions().size()-1;
2268 }
2269 
2272 unsigned function::find_function(const std::string &name, unsigned nparams)
2273 {
2274  unsigned serial = 0;
2275  for (auto & it : function::registered_functions()) {
2276  if (it.get_name() == name && it.get_nparams() == nparams)
2277  return serial;
2278  ++serial;
2279  }
2280  throw (std::runtime_error("no function '" + name + "' with " + std::to_string(nparams) + " parameters defined"));
2281 }
2282 
2284 std::string function::get_name() const
2285 {
2287  return registered_functions()[serial].name;
2288 }
2289 
2290 } // namespace GiNaC
2291 
inifcns.h
Interface to GiNaC's initially known functions.
GiNaC::function_options::power_func
function_options & power_func(power_funcp_1 e)
Definition: function.cpp:792
GiNaC::function::is_equal_same_type
bool is_equal_same_type(const basic &other) const override
Returns true if two objects of same type are equal.
Definition: function.cpp:1967
GiNaC::function::match_same_type
bool match_same_type(const basic &other) const override
Returns true if the attributes of two objects are similar enough for a match.
Definition: function.cpp:1978
GiNaC::golden_ratio_hash
unsigned golden_ratio_hash(uintptr_t n)
Truncated multiplication with golden ratio, for computing hash values.
Definition: utils.h:68
GiNaC::power_funcp_7
ex(* power_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:223
GiNaC::imag_part_funcp_3
ex(* imag_part_funcp_3)(const ex &, const ex &, const ex &)
Definition: function.h:171
GiNaC::print_funcp_13
void(* print_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:297
GiNaC::function_options::series_f
series_funcp series_f
Definition: function.h:632
GiNaC::function::function
function(unsigned ser)
Definition: function.cpp:1198
GiNaC::conjugate_funcp_4
ex(* conjugate_funcp_4)(const ex &, const ex &, const ex &, const ex &)
Definition: function.h:181
GiNaC::conjugate_funcp_8
ex(* conjugate_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:229
GiNaC::remember_table::remember_tables
static std::vector< remember_table > & remember_tables()
Definition: remember.cpp:184
GiNaC::function_options::info_func
function_options & info_func(info_funcp_1 e)
Definition: function.cpp:960
GiNaC::function_options::real_part_use_exvector_args
bool real_part_use_exvector_args
Definition: function.h:650
GiNaC::imag_part_funcp_9
ex(* imag_part_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:243
GiNaC::function_options::remember_strategy
unsigned remember_strategy
Definition: function.h:645
GiNaC::expl_derivative_funcp_3
ex(* expl_derivative_funcp_3)(const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:174
GiNaC::print_funcp_3
void(* print_funcp_3)(const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:177
GiNaC::function::conjugate
ex conjugate() const override
Implementation of ex::conjugate for functions.
Definition: function.cpp:1735
GiNaC::function_options::use_remember
bool use_remember
Definition: function.h:642
r
size_t r
Definition: factor.cpp:770
GiNaC::derivative_funcp_13
ex(* derivative_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:293
GiNaC::remember_table
The remember table is organized like an n-fold associative cache in a microprocessor.
Definition: remember.h:83
GiNaC::real_part_funcp_1
ex(* real_part_funcp_1)(const ex &)
Definition: function.h:146
GiNaC::expl_derivative_funcp_5
ex(* expl_derivative_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:198
GiNaC::derivative_funcp_3
ex(* derivative_funcp_3)(const ex &, const ex &, const ex &, unsigned)
Definition: function.h:173
GiNaC::function_options::expl_derivative_f
expl_derivative_funcp expl_derivative_f
Definition: function.h:630
GiNaC::info_funcp_11
bool(* info_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:274
GiNaC::expand_funcp_5
ex(* expand_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:196
GiNaC::evalf_funcp_exvector
ex(* evalf_funcp_exvector)(const exvector &)
Definition: function.h:316
GiNaC::eval_funcp_8
ex(* eval_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:227
GiNaC::info_funcp_4
bool(* info_funcp_4)(const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:190
GiNaC::power_funcp_10
ex(* power_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:259
GiNaC::function::find_function
static unsigned find_function(const std::string &name, unsigned nparams)
Find serial number of function by name and number of parameters.
Definition: function.cpp:2272
GiNaC::expand_funcp
ex(* expand_funcp)()
Definition: function.h:134
GiNaC::function_options::set_name
function_options & set_name(std::string const &n, std::string const &tn=std::string())
Definition: function.cpp:102
GiNaC::basic::hashvalue
unsigned hashvalue
hash value
Definition: basic.h:303
GiNaC::eval_funcp_3
ex(* eval_funcp_3)(const ex &, const ex &, const ex &)
Definition: function.h:167
GiNaC::status_flags::expanded
@ expanded
.expand(0) has already done its job (other expand() options ignore this flag)
Definition: flags.h:204
GiNaC::_ex0
const ex _ex0
Definition: utils.cpp:177
GiNaC::series_funcp_5
ex(* series_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:200
GiNaC::function::real_part
ex real_part() const override
Implementation of ex::real_part for functions.
Definition: function.cpp:1784
GiNaC::expand_funcp_4
ex(* expand_funcp_4)(const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:184
GiNaC::function::derivative
ex derivative(const symbol &s) const override
Implementation of ex::diff() for functions.
Definition: function.cpp:1931
GiNaC::relational
This class holds a relation consisting of two expressions and a logical relation between them.
Definition: relational.h:35
GiNaC::imag_part_funcp_7
ex(* imag_part_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:219
GiNaC::do_taylor
Exception class thrown by classes which provide their own series expansion to signal that ordinary Ta...
Definition: function.h:668
GiNaC::derivative_funcp_8
ex(* derivative_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:233
GiNaC::function_options::eval_use_exvector_args
bool eval_use_exvector_args
Definition: function.h:647
GiNaC::series_funcp
ex(* series_funcp)()
Definition: function.h:138
GiNaC::print_context
Base class for print_contexts.
Definition: print.h:103
GiNaC::ex::gethash
unsigned gethash() const
Definition: ex.h:233
GiNaC::series_funcp_3
ex(* series_funcp_3)(const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:176
GiNaC::container::precedence
unsigned precedence() const override
Return relative operator precedence (for parenthezing output).
Definition: container.h:117
GiNaC::eval_funcp_14
ex(* eval_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:299
GiNaC::function::print
void print(const print_context &c, unsigned level=0) const override
Output to stream.
Definition: function.cpp:1320
symmetry.h
Interface to GiNaC's symmetry definitions.
GiNaC::print_funcp_14
void(* print_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:309
GiNaC::real_part_funcp_2
ex(* real_part_funcp_2)(const ex &, const ex &)
Definition: function.h:158
GiNaC::info_funcp_12
bool(* info_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:286
GiNaC::real_part_funcp_3
ex(* real_part_funcp_3)(const ex &, const ex &, const ex &)
Definition: function.h:170
GiNaC::series_funcp_11
ex(* series_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:272
GiNaC::derivative_funcp_1
ex(* derivative_funcp_1)(const ex &, unsigned)
Definition: function.h:149
GiNaC::series_funcp_10
ex(* series_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:260
GiNaC::real_part_funcp_exvector
ex(* real_part_funcp_exvector)(const exvector &)
Definition: function.h:318
GiNaC::power_funcp_12
ex(* power_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:283
GiNaC::eval_funcp
ex(* eval_funcp)()
Definition: function.h:129
power.h
Interface to GiNaC's symbolic exponentiation (basis^exponent).
GiNaC::imag_part_funcp_5
ex(* imag_part_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:195
GiNaC::evalf_funcp_9
ex(* evalf_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:240
GiNaC::exvector
std::vector< ex > exvector
Definition: basic.h:46
GiNaC::conjugate_funcp
ex(* conjugate_funcp)()
Definition: function.h:131
GiNaC::info_funcp_9
bool(* info_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:250
GiNaC::derivative_funcp_12
ex(* derivative_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:281
GiNaC::expl_derivative_funcp_8
ex(* expl_derivative_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:234
GiNaC::expl_derivative_funcp_6
ex(* expl_derivative_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:210
GiNaC::derivative_funcp_9
ex(* derivative_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:245
GiNaC::derivative_funcp_2
ex(* derivative_funcp_2)(const ex &, const ex &, unsigned)
Definition: function.h:161
GiNaC::imag_part_funcp_8
ex(* imag_part_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:231
GiNaC::status_flags::evaluated
@ evaluated
.eval() has already done its job
Definition: flags.h:203
GiNaC::imag_part_funcp_2
ex(* imag_part_funcp_2)(const ex &, const ex &)
Definition: function.h:159
GiNaC::evalf_funcp_3
ex(* evalf_funcp_3)(const ex &, const ex &, const ex &)
Definition: function.h:168
GINAC_IMPLEMENT_REGISTERED_CLASS
#define GINAC_IMPLEMENT_REGISTERED_CLASS(classname, supername)
Macro for inclusion in the implementation of each registered class.
Definition: registrar.h:180
GiNaC::derivative_funcp_7
ex(* derivative_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:221
GiNaC::function_options::info_f
info_funcp info_f
Definition: function.h:634
GiNaC::expl_derivative_funcp_2
ex(* expl_derivative_funcp_2)(const ex &, const ex &, const symbol &)
Definition: function.h:162
GiNaC::evalf_funcp
ex(* evalf_funcp)()
Definition: function.h:130
GiNaC::print_funcp_4
void(* print_funcp_4)(const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:189
GiNaC::container_storage::seq
STLT seq
Definition: container.h:57
GiNaC::archive_node
This class stores all properties needed to record/retrieve the state of one object of class basic (or...
Definition: archive.h:49
GiNaC::imag_part_funcp_exvector
ex(* imag_part_funcp_exvector)(const exvector &)
Definition: function.h:319
GiNaC::function::thiscontainer
ex thiscontainer(const exvector &v) const override
Definition: function.cpp:1599
GiNaC::derivative_funcp_10
ex(* derivative_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:257
GiNaC::expand_funcp_9
ex(* expand_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:244
GiNaC::expl_derivative_funcp_4
ex(* expl_derivative_funcp_4)(const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:186
GiNaC::canonicalize
int canonicalize(exvector::iterator v, const symmetry &symm)
Canonicalize the order of elements of an expression vector, according to the symmetry properties defi...
Definition: symmetry.cpp:438
GiNaC::function_options::power_use_exvector_args
bool power_use_exvector_args
Definition: function.h:655
GiNaC::function_options::imag_part_use_exvector_args
bool imag_part_use_exvector_args
Definition: function.h:651
GiNaC::print_funcp_11
void(* print_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:273
GiNaC::real_part_funcp_12
ex(* real_part_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:278
GiNaC::power_funcp_8
ex(* power_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:235
GiNaC::expand_funcp_8
ex(* expand_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:232
GiNaC::real_part_funcp_4
ex(* real_part_funcp_4)(const ex &, const ex &, const ex &, const ex &)
Definition: function.h:182
GiNaC::power_funcp_exvector
ex(* power_funcp_exvector)(const exvector &, const ex &)
Definition: function.h:323
GiNaC::expand_funcp_1
ex(* expand_funcp_1)(const ex &, unsigned)
Definition: function.h:148
options
unsigned options
Definition: factor.cpp:2480
GiNaC::function_options::eval_f
eval_funcp eval_f
Definition: function.h:623
GiNaC::power_funcp_5
ex(* power_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:199
GiNaC::function_options::evalf_func
function_options & evalf_func(evalf_funcp_1 e)
Definition: function.cpp:204
GiNaC::function_options::name
std::string name
Definition: function.h:618
GiNaC::eval_funcp_exvector
ex(* eval_funcp_exvector)(const exvector &)
Definition: function.h:315
GiNaC::GINAC_BIND_UNARCHIVER
GINAC_BIND_UNARCHIVER(add)
GiNaC::conjugate_funcp_14
ex(* conjugate_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:301
GiNaC::evalf_funcp_13
ex(* evalf_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:288
GiNaC::function_options::expand_use_exvector_args
bool expand_use_exvector_args
Definition: function.h:652
GiNaC
Definition: add.cpp:38
GiNaC::container::is_equal_same_type
bool is_equal_same_type(const basic &other) const override
Returns true if two objects of same type are equal.
Definition: container.h:362
GiNaC::series_funcp_7
ex(* series_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:224
GiNaC::expand_funcp_11
ex(* expand_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:268
GiNaC::imag_part_funcp_13
ex(* imag_part_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:291
GiNaC::evalf_funcp_5
ex(* evalf_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:192
GiNaC::expl_derivative_funcp_12
ex(* expl_derivative_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:282
GiNaC::print_funcp_9
void(* print_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:249
GiNaC::print_funcp_2
void(* print_funcp_2)(const ex &, const ex &, const print_context &)
Definition: function.h:165
GiNaC::info_funcp_8
bool(* info_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:238
GiNaC::evalf_funcp_7
ex(* evalf_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:216
GiNaC::derivative_funcp_5
ex(* derivative_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:197
GiNaC::basic::clearflag
const basic & clearflag(unsigned f) const
Clear some status_flags.
Definition: basic.h:291
GiNaC::function::return_type
unsigned return_type() const override
Definition: function.cpp:1986
GiNaC::series_funcp_13
ex(* series_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:296
GiNaC::function::eval
ex eval() const override
Perform automatic non-interruptive term rewriting rules.
Definition: function.cpp:1428
GiNaC::function_options::expand_f
expand_funcp expand_f
Definition: function.h:628
GiNaC::function_options::info_use_exvector_args
bool info_use_exvector_args
Definition: function.h:658
GiNaC::print_funcp
void(* print_funcp)()
Definition: function.h:139
GiNaC::function_options::series_func
function_options & series_func(series_funcp_1 e)
Definition: function.cpp:876
GiNaC::basic::imag_part
virtual ex imag_part() const
Definition: basic.cpp:681
GiNaC::evalf_funcp_12
ex(* evalf_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:276
GiNaC::function::store_remember_table
void store_remember_table(ex const &result) const
Definition: function.cpp:2236
GiNaC::conjugate_funcp_9
ex(* conjugate_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:241
utils.h
Interface to several small and furry utilities needed within GiNaC but not of any interest to the use...
GiNaC::eval_funcp_9
ex(* eval_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:239
GiNaC::expl_derivative_funcp_9
ex(* expl_derivative_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:246
GiNaC::function_options::evalf_use_exvector_args
bool evalf_use_exvector_args
Definition: function.h:648
GiNaC::function_options::remember_size
unsigned remember_size
Definition: function.h:643
GiNaC::power_funcp_2
ex(* power_funcp_2)(const ex &, const ex &, const ex &)
Definition: function.h:163
GiNaC::expand_funcp_14
ex(* expand_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:304
GiNaC::function_options::nparams
unsigned nparams
Definition: function.h:621
GiNaC::function_options::derivative_func
function_options & derivative_func(derivative_funcp_1 e)
Definition: function.cpp:624
GiNaC::real_part_funcp_5
ex(* real_part_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:194
GiNaC::ex
Lightweight wrapper for GiNaC's symbolic objects.
Definition: ex.h:72
GiNaC::basic::info
virtual bool info(unsigned inf) const
Information about the object.
Definition: basic.cpp:222
lst.h
Definition of GiNaC's lst.
GiNaC::basic::compare_same_type
virtual int compare_same_type(const basic &other) const
Returns order relation between two objects of same type.
Definition: basic.cpp:719
GiNaC::expl_derivative_funcp_exvector
ex(* expl_derivative_funcp_exvector)(const exvector &, const symbol &)
Definition: function.h:322
GiNaC::evalf_funcp_10
ex(* evalf_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:252
GiNaC::expand_funcp_10
ex(* expand_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:256
GiNaC::expand_funcp_2
ex(* expand_funcp_2)(const ex &, const ex &, unsigned)
Definition: function.h:160
GiNaC::imag_part_funcp_6
ex(* imag_part_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:207
GiNaC::function::archive
void archive(archive_node &n) const override
Archive the object.
Definition: function.cpp:1305
GiNaC::imag_part_funcp_14
ex(* imag_part_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:303
GiNaC::function::series
ex series(const relational &r, int order, unsigned options=0) const override
Implementation of ex::series for functions.
Definition: function.cpp:1611
GiNaC::power_funcp_3
ex(* power_funcp_3)(const ex &, const ex &, const ex &, const ex &)
Definition: function.h:175
GiNaC::power_funcp_11
ex(* power_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:271
GiNaC::function_options::set_symmetry
function_options & set_symmetry(const symmetry &s)
Definition: function.cpp:1149
GiNaC::info_funcp_2
bool(* info_funcp_2)(const ex &, const ex &, unsigned)
Definition: function.h:166
GiNaC::function_options::functions_with_same_name
unsigned functions_with_same_name
Definition: function.h:660
GiNaC::conjugate_funcp_13
ex(* conjugate_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:289
GiNaC::function_options::test_and_set_nparams
void test_and_set_nparams(unsigned n)
Definition: function.cpp:1155
GiNaC::function_options::latex_name
function_options & latex_name(std::string const &tn)
Definition: function.cpp:113
GiNaC::expl_derivative_funcp_13
ex(* expl_derivative_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:294
GiNaC::status_flags::hash_calculated
@ hash_calculated
.calchash() has already done its job
Definition: flags.h:205
GiNaC::function_options::derivative_f
derivative_funcp derivative_f
Definition: function.h:629
GiNaC::fderivative
This class represents the (abstract) derivative of a symbolic function.
Definition: fderivative.h:38
GiNaC::series_funcp_14
ex(* series_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:308
GiNaC::eval_funcp_6
ex(* eval_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:203
GiNaC::function_options::~function_options
~function_options()
Definition: function.cpp:71
GiNaC::expand
ex expand(const ex &thisex, unsigned options=0)
Definition: ex.h:715
ex.h
Interface to GiNaC's light-weight expression handles.
GiNaC::basic::hold
const basic & hold() const
Stop further evaluation.
Definition: basic.cpp:887
hash_seed.h
Type-specific hash seed.
GiNaC::function::eval_ncmul
ex eval_ncmul(const exvector &v) const override
This method is defined to be in line with behavior of function::return_type()
Definition: function.cpp:1577
GiNaC::function::serial
unsigned serial
Definition: function.h:751
GiNaC::eval_funcp_10
ex(* eval_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:251
GiNaC::function::info
bool info(unsigned inf) const override
Implementation of ex::info for functions.
Definition: function.cpp:1878
GiNaC::function_options::expl_derivative_func
function_options & expl_derivative_func(expl_derivative_funcp_1 e)
Definition: function.cpp:708
GiNaC::eval_funcp_13
ex(* eval_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:287
GiNaC::print_funcp_5
void(* print_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:201
GiNaC::real_part_funcp_11
ex(* real_part_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:266
GiNaC::container::op
ex op(size_t i) const override
Return operand/member at position i.
Definition: container.h:295
GiNaC::function_options::set_return_type
function_options & set_return_type(unsigned rt, const return_type_t *rtt=nullptr)
Definition: function.cpp:1115
GiNaC::evalf_funcp_14
ex(* evalf_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:300
GiNaC::real_part_funcp_13
ex(* real_part_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:290
print.h
Definition of helper classes for expression output.
GiNaC::function_options::real_part_f
real_part_funcp real_part_f
Definition: function.h:626
remember.h
Interface to helper classes for using the remember option in GiNaC functions.
GiNaC::function::registered_functions
static std::vector< function_options > & registered_functions()
Definition: function.cpp:2225
GiNaC::function
The class function is used to implement builtin functions like sin, cos...
Definition: function.h:674
GiNaC::function_options::function_options
function_options()
Definition: function.cpp:53
GiNaC::series_funcp_6
ex(* series_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:212
GiNaC::function_options::imag_part_func
function_options & imag_part_func(imag_part_funcp_1 e)
Definition: function.cpp:456
GiNaC::info_funcp_exvector
bool(* info_funcp_exvector)(const exvector &, unsigned)
Definition: function.h:326
GiNaC::conjugate_funcp_3
ex(* conjugate_funcp_3)(const ex &, const ex &, const ex &)
Definition: function.h:169
GiNaC::series_funcp_1
ex(* series_funcp_1)(const ex &, const relational &, int, unsigned)
Definition: function.h:152
GiNaC::return_type_t
To distinguish between different kinds of non-commutative objects.
Definition: registrar.h:44
GiNaC::print_tree
Context for tree-like output for debugging.
Definition: print.h:147
GiNaC::imag_part_funcp_12
ex(* imag_part_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:279
GiNaC::eval_funcp_11
ex(* eval_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:263
GiNaC::power_funcp
ex(* power_funcp)()
Definition: function.h:137
GiNaC::function_options::use_return_type
bool use_return_type
Definition: function.h:638
GiNaC::function::evalf
ex evalf() const override
Evaluate object numerically.
Definition: function.cpp:1517
GiNaC::info_funcp_7
bool(* info_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:226
GiNaC::expl_derivative_funcp_10
ex(* expl_derivative_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:258
GiNaC::series_funcp_2
ex(* series_funcp_2)(const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:164
GiNaC::real_part_funcp_9
ex(* real_part_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:242
GiNaC::power_funcp_13
ex(* power_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:295
GiNaC::function_options::derivative_use_exvector_args
bool derivative_use_exvector_args
Definition: function.h:653
GiNaC::conjugate_funcp_7
ex(* conjugate_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:217
GiNaC::evalf_funcp_6
ex(* evalf_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:204
GiNaC::function::lookup_remember_table
bool lookup_remember_table(ex &result) const
Definition: function.cpp:2231
GiNaC::function_options::power_f
power_funcp power_f
Definition: function.h:631
GiNaC::expand_funcp_6
ex(* expand_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:208
GiNaC::function_options::initialize
void initialize()
Definition: function.cpp:76
GiNaC::info_funcp_14
bool(* info_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:310
GiNaC::rotate_left
unsigned rotate_left(unsigned n)
Rotate bits of unsigned value by one bit to the left.
Definition: utils.h:48
GiNaC::return_types::commutative
@ commutative
Definition: flags.h:280
GiNaC::derivative_funcp_4
ex(* derivative_funcp_4)(const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:185
GiNaC::function_options::print_use_exvector_args
bool print_use_exvector_args
Definition: function.h:657
GiNaC::real_part_funcp_14
ex(* real_part_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:302
GiNaC::function::read_archive
void read_archive(const archive_node &n, lst &syms) override
Construct object from archive_node.
Definition: function.cpp:1283
GiNaC::basic::setflag
const basic & setflag(unsigned f) const
Set some status_flags.
Definition: basic.h:288
GiNaC::evalf_funcp_4
ex(* evalf_funcp_4)(const ex &, const ex &, const ex &, const ex &)
Definition: function.h:180
GiNaC::series_funcp_9
ex(* series_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:248
GiNaC::print_funcp_1
void(* print_funcp_1)(const ex &, const print_context &)
Definition: function.h:153
GiNaC::derivative_funcp_6
ex(* derivative_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:209
GiNaC::function::power
ex power(const ex &exp) const
Definition: function.cpp:2128
GiNaC::evalf_funcp_8
ex(* evalf_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:228
GiNaC::container
Wrapper template for making GiNaC classes out of STL containers.
Definition: container.h:73
GiNaC::derivative_funcp_exvector
ex(* derivative_funcp_exvector)(const exvector &, unsigned)
Definition: function.h:321
GiNaC::function::precedence
unsigned precedence() const override
Return relative operator precedence (for parenthezing output).
Definition: function.h:707
function.h
Interface to class of symbolic functions.
GiNaC::function::pderivative
ex pderivative(unsigned diff_param) const
Definition: function.cpp:2034
GiNaC::imag_part_funcp_1
ex(* imag_part_funcp_1)(const ex &)
Definition: function.h:147
GiNaC::info_funcp_5
bool(* info_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:202
GiNaC::function_options::expl_derivative_use_exvector_args
bool expl_derivative_use_exvector_args
Definition: function.h:654
GiNaC::imag_part_funcp
ex(* imag_part_funcp)()
Definition: function.h:133
GiNaC::class_info::options
OPT options
Definition: class_info.h:62
c
size_t c
Definition: factor.cpp:770
GiNaC::expl_derivative_funcp_11
ex(* expl_derivative_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:270
GiNaC::function_options::real_part_func
function_options & real_part_func(real_part_funcp_1 e)
Definition: function.cpp:372
GiNaC::expl_derivative_funcp_1
ex(* expl_derivative_funcp_1)(const ex &, const symbol &)
Definition: function.h:150
GiNaC::basic::series
virtual ex series(const relational &r, int order, unsigned options=0) const
Default implementation of ex::series().
Definition: pseries.cpp:612
GiNaC::eval_funcp_5
ex(* eval_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:191
GiNaC::print_funcp_12
void(* print_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:285
GiNaC::container::printseq
virtual void printseq(const print_context &c, char openbracket, char delim, char closebracket, unsigned this_precedence, unsigned upper_precedence=0) const
Print sequence of contained elements.
Definition: container.h:451
GiNaC::function::current_serial
static unsigned current_serial
This can be used as a hook for external applications.
Definition: function.h:742
GiNaC::function_options::evalf_params_first
bool evalf_params_first
Definition: function.h:636
GiNaC::function_options::set_print_func
void set_print_func(unsigned id, print_funcp f)
Definition: function.cpp:1169
GiNaC::function_options::TeX_name
std::string TeX_name
Definition: function.h:619
GiNaC::real_part_funcp_10
ex(* real_part_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:254
GiNaC::evalf_funcp_1
ex(* evalf_funcp_1)(const ex &)
Definition: function.h:144
GiNaC::function_options::conjugate_func
function_options & conjugate_func(conjugate_funcp_1 e)
Definition: function.cpp:288
GiNaC::function_options::imag_part_f
imag_part_funcp imag_part_f
Definition: function.h:627
archive.h
Archiving of GiNaC expressions.
std
Definition: ex.h:972
GiNaC::symbol
Basic CAS symbol.
Definition: symbol.h:39
GiNaC::function_options::return_type
unsigned return_type
Definition: function.h:639
GiNaC::symmetry
This class describes the symmetry of a group of indices.
Definition: symmetry.h:39
GiNaC::conjugate_funcp_exvector
ex(* conjugate_funcp_exvector)(const exvector &)
Definition: function.h:317
n
size_t n
Definition: factor.cpp:1463
GiNaC::evalf_funcp_11
ex(* evalf_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:264
GiNaC::series_funcp_12
ex(* series_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:284
GiNaC::expand_funcp_13
ex(* expand_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:292
GiNaC::real_part_funcp_6
ex(* real_part_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:206
GiNaC::function_options::do_not_evalf_params
function_options & do_not_evalf_params()
Definition: function.cpp:1126
GiNaC::conjugate_funcp_5
ex(* conjugate_funcp_5)(const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:193
GiNaC::expand_funcp_12
ex(* expand_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:280
GiNaC::imag_part_funcp_4
ex(* imag_part_funcp_4)(const ex &, const ex &, const ex &, const ex &)
Definition: function.h:183
GiNaC::expl_derivative_funcp
ex(* expl_derivative_funcp)()
Definition: function.h:136
GiNaC::function::calchash
unsigned calchash() const override
Compute the hash value of an object and if it makes sense to store it in the objects status_flags,...
Definition: function.cpp:1584
GiNaC::conjugate_funcp_1
ex(* conjugate_funcp_1)(const ex &)
Definition: function.h:145
GiNaC::class_info::get_parent
class_info * get_parent() const
Get pointer to class_info of parent class (or nullptr).
Definition: class_info.h:50
GiNaC::function::register_new
static unsigned register_new(function_options const &opt)
Definition: function.cpp:2243
GiNaC::basic
This class is the ABC (abstract base class) of GiNaC's class hierarchy.
Definition: basic.h:105
GiNaC::conjugate_funcp_2
ex(* conjugate_funcp_2)(const ex &, const ex &)
Definition: function.h:157
GiNaC::basic::ex
friend class ex
Definition: basic.h:108
GiNaC::class_info
Definition: class_info.h:41
GiNaC::print_funcp_exvector
void(* print_funcp_exvector)(const exvector &, const print_context &)
Definition: function.h:325
GiNaC::evalf_funcp_2
ex(* evalf_funcp_2)(const ex &, const ex &)
Definition: function.h:156
GiNaC::conjugate_funcp_12
ex(* conjugate_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:277
GiNaC::series_funcp_8
ex(* series_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:236
GiNaC::imag_part_funcp_10
ex(* imag_part_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:255
GiNaC::power_funcp_4
ex(* power_funcp_4)(const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:187
GiNaC::info_funcp_10
bool(* info_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:262
GiNaC::eval_funcp_4
ex(* eval_funcp_4)(const ex &, const ex &, const ex &, const ex &)
Definition: function.h:179
GiNaC::function_options::series_use_exvector_args
bool series_use_exvector_args
Definition: function.h:656
GiNaC::eval_funcp_1
ex(* eval_funcp_1)(const ex &)
Definition: function.h:143
GiNaC::function_options
Definition: function.h:330
GiNaC::ex::is_zero
bool is_zero() const
Definition: ex.h:213
GiNaC::function_options::eval_func
function_options & eval_func(eval_funcp_1 e)
Definition: function.cpp:120
GiNaC::function::imag_part
ex imag_part() const override
Implementation of ex::imag_part for functions.
Definition: function.cpp:1831
GiNaC::conjugate_funcp_11
ex(* conjugate_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:265
GiNaC::info_funcp_1
bool(* info_funcp_1)(const ex &, unsigned)
Definition: function.h:154
GiNaC::function_options::symtree
ex symtree
Definition: function.h:662
GiNaC::power_funcp_6
ex(* power_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:211
GiNaC::expand_funcp_3
ex(* expand_funcp_3)(const ex &, const ex &, const ex &, unsigned)
Definition: function.h:172
GiNaC::print_funcp_8
void(* print_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:237
GiNaC::info_funcp_13
bool(* info_funcp_13)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:298
GiNaC::print_funcp_6
void(* print_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:213
GiNaC::series_funcp_exvector
ex(* series_funcp_exvector)(const exvector &, const relational &, int, unsigned)
Definition: function.h:324
GiNaC::expand_options::expand_function_args
@ expand_function_args
expands the arguments of functions
Definition: flags.h:33
GiNaC::eval_funcp_2
ex(* eval_funcp_2)(const ex &, const ex &)
Definition: function.h:155
GiNaC::expl_derivative_funcp_7
ex(* expl_derivative_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:222
GiNaC::series_funcp_4
ex(* series_funcp_4)(const ex &, const ex &, const ex &, const ex &, const relational &, int, unsigned)
Definition: function.h:188
GiNaC::real_part_funcp_8
ex(* real_part_funcp_8)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:230
GiNaC::expand_funcp_7
ex(* expand_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:220
GiNaC::power_funcp_14
ex(* power_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:307
GiNaC::container::nops
size_t nops() const override
Number of operands/members.
Definition: container.h:118
GiNaC::function_options::print_dispatch_table
std::vector< print_funcp > print_dispatch_table
Definition: function.h:633
GiNaC::expl_derivative_funcp_14
ex(* expl_derivative_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const symbol &)
Definition: function.h:306
GiNaC::basic::flags
unsigned flags
of type status_flags
Definition: basic.h:302
GiNaC::info_funcp
bool(* info_funcp)()
Definition: function.h:140
GiNaC::function::expl_derivative
ex expl_derivative(const symbol &s) const
Definition: function.cpp:2081
GiNaC::imag_part_funcp_11
ex(* imag_part_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:267
GiNaC::info_funcp_3
bool(* info_funcp_3)(const ex &, const ex &, const ex &, unsigned)
Definition: function.h:178
GiNaC::print_funcp_7
void(* print_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:225
GiNaC::expand_funcp_exvector
ex(* expand_funcp_exvector)(const exvector &, unsigned)
Definition: function.h:320
GiNaC::function::get_name
std::string get_name() const
Return the print name of the function.
Definition: function.cpp:2284
order
int order
Definition: integration_kernel.cpp:248
GiNaC::function_options::conjugate_use_exvector_args
bool conjugate_use_exvector_args
Definition: function.h:649
GiNaC::power_funcp_1
ex(* power_funcp_1)(const ex &, const ex &)
Definition: function.h:151
fderivative.h
Interface to abstract derivatives of functions.
GiNaC::conjugate_funcp_6
ex(* conjugate_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:205
GiNaC::make_hash_seed
static unsigned make_hash_seed(const std::type_info &tinfo)
We need a hash function which gives different values for objects of different types.
Definition: hash_seed.h:36
operators.h
Interface to GiNaC's overloaded operators.
GiNaC::power_funcp_9
ex(* power_funcp_9)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:247
GiNaC::conjugate_funcp_10
ex(* conjugate_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:253
GiNaC::function_options::return_type_tinfo
return_type_t return_type_tinfo
Definition: function.h:640
GiNaC::function_options::evalf_f
evalf_funcp evalf_f
Definition: function.h:624
GiNaC::function_options::remember
function_options & remember(unsigned size, unsigned assoc_size=0, unsigned strategy=remember_strategies::delete_never)
Definition: function.cpp:1132
GiNaC::real_part_funcp_7
ex(* real_part_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:218
GiNaC::info_funcp_6
bool(* info_funcp_6)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:214
GiNaC::function::return_type_tinfo
return_type_t return_type_tinfo() const override
Definition: function.cpp:2004
GiNaC::basic::real_part
virtual ex real_part() const
Definition: basic.cpp:676
GiNaC::function_options::conjugate_f
conjugate_funcp conjugate_f
Definition: function.h:625
GINAC_ASSERT
#define GINAC_ASSERT(X)
Assertion macro for checking invariances.
Definition: assertion.h:33
GiNaC::function_options::expand_func
function_options & expand_func(expand_funcp_1 e)
Definition: function.cpp:540
GiNaC::function_options::overloaded
function_options & overloaded(unsigned o)
Definition: function.cpp:1143
GiNaC::function_options::remember_assoc_size
unsigned remember_assoc_size
Definition: function.h:644
GiNaC::eval_funcp_7
ex(* eval_funcp_7)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:215
GiNaC::real_part_funcp
ex(* real_part_funcp)()
Definition: function.h:132
GiNaC::function::expand
ex expand(unsigned options=0) const override
Expand expression, i.e.
Definition: function.cpp:2175
GiNaC::derivative_funcp_14
ex(* derivative_funcp_14)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:305
GiNaC::eval_funcp_12
ex(* eval_funcp_12)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &)
Definition: function.h:275
GiNaC::derivative_funcp
ex(* derivative_funcp)()
Definition: function.h:135
GiNaC::print_funcp_10
void(* print_funcp_10)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const print_context &)
Definition: function.h:261
GiNaC::derivative_funcp_11
ex(* derivative_funcp_11)(const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, const ex &, unsigned)
Definition: function.h:269

This page is part of the GiNaC developer's reference. It was generated automatically by doxygen. For an introduction, see the tutorial.