ExaTN
num_server.hpp
1 
23 #ifndef EXATN_NUM_SERVER_HPP_
24 #define EXATN_NUM_SERVER_HPP_
25 
26 #include "tensor_basic.hpp"
27 #include "space_register.hpp"
28 #include "tensor.hpp"
29 #include "tensor_op_factory.hpp"
30 #include "tensor_network.hpp"
31 #include "tensor_symbol.hpp"
32 
33 #include "tensor_runtime.hpp"
34 
35 #include "Identifiable.hpp"
36 #include "tensor_method.hpp"
37 #include "functor_init_val.hpp"
38 
39 #include <memory>
40 #include <vector>
41 #include <string>
42 #include <stack>
43 #include <map>
44 
45 using exatn::Identifiable;
46 
47 namespace exatn{
48 
49 using numerics::VectorSpace;
50 using numerics::Subspace;
51 using numerics::TensorShape;
52 using numerics::TensorSignature;
53 using numerics::TensorLeg;
54 using numerics::Tensor;
55 using numerics::TensorOperation;
56 using numerics::TensorOpFactory;
57 using numerics::TensorNetwork;
58 
59 using TensorMethod = talsh::TensorFunctor<Identifiable>;
60 
61 
62 class NumServer final {
63 
64 public:
65 
66  NumServer();
67  NumServer(const NumServer &) = delete;
68  NumServer & operator=(const NumServer &) = delete;
69  NumServer(NumServer &&) noexcept = delete;
70  NumServer & operator=(NumServer &&) noexcept = delete;
71  ~NumServer();
72 
74  void reconfigureTensorRuntime(const std::string & dag_executor_name,
75  const std::string & node_executor_name);
76 
78  void resetRuntimeLoggingLevel(int level = 0);
79 
81  void registerTensorMethod(const std::string & tag,
82  std::shared_ptr<TensorMethod> method);
83 
85  std::shared_ptr<TensorMethod> getTensorMethod(const std::string & tag);
86 
88  void registerExternalData(const std::string & tag,
89  std::shared_ptr<BytePacket> packet);
90 
92  std::shared_ptr<BytePacket> getExternalData(const std::string & tag);
93 
94 
96  ScopeId openScope(const std::string & scope_name); //new scope name
97 
99  ScopeId closeScope();
100 
101 
104  SpaceId createVectorSpace(const std::string & space_name, //in: vector space name
105  DimExtent space_dim, //in: vector space dimension
106  const VectorSpace ** space_ptr = nullptr); //out: non-owning pointer to the created vector space
107 
109  void destroyVectorSpace(const std::string & space_name); //in: name of the vector space to destroy
110  void destroyVectorSpace(SpaceId space_id); //in: id of the vector space to destroy
111 
114  const VectorSpace * getVectorSpace(const std::string & space_name) const;
115 
116 
119  SubspaceId createSubspace(const std::string & subspace_name, //in: subspace name
120  const std::string & space_name, //in: containing vector space name
121  std::pair<DimOffset,DimOffset> bounds, //in: range of basis vectors defining the created subspace
122  const Subspace ** subspace_ptr = nullptr); //out: non-owning pointer to the created subspace
123 
125  void destroySubspace(const std::string & subspace_name); //in: name of the subspace to destroy
126  void destroySubspace(SubspaceId subspace_id); //in: id of the subspace to destroy
127 
130  const Subspace * getSubspace(const std::string & subspace_name) const;
131 
132 
134  void submit(std::shared_ptr<TensorOperation> operation);
136  void submit(TensorNetwork & network);
137  void submit(std::shared_ptr<TensorNetwork> network);
138 
140  bool sync(const Tensor & tensor,
141  bool wait = true);
143  bool sync(TensorOperation & operation,
144  bool wait = true);
146  bool sync(TensorNetwork & network,
147  bool wait = true);
148 
152  bool sync(const std::string & name, //in: tensor name
153  bool wait = true); //in: wait versus test for completion
154 
156  Tensor & getTensorRef(const std::string & name); //in: tensor name
157 
159  TensorElementType getTensorElementType(const std::string & name) const; //in: tensor name
160 
163  template <typename... Args>
164  bool createTensor(const std::string & name, //in: tensor name
165  TensorElementType element_type, //in: tensor element type
166  Args&&... args); //in: other arguments for Tensor ctor
167 
168  template <typename... Args>
169  bool createTensorSync(const std::string & name, //in: tensor name
170  TensorElementType element_type, //in: tensor element type
171  Args&&... args); //in: other arguments for Tensor ctor
172 
174  bool destroyTensor(const std::string & name); //in: tensor name
175 
176  bool destroyTensorSync(const std::string & name); //in: tensor name
177 
179  template<typename NumericType>
180  bool initTensor(const std::string & name, //in: tensor name
181  NumericType value); //in: scalar value
182 
183  template<typename NumericType>
184  bool initTensorSync(const std::string & name, //in: tensor name
185  NumericType value); //in: scalar value
186 
188  bool transformTensor(const std::string & name, //in: tensor name
189  std::shared_ptr<TensorMethod> functor); //in: functor defining tensor transformation
190 
191  bool transformTensorSync(const std::string & name, //in: tensor name
192  std::shared_ptr<TensorMethod> functor); //in: functor defining tensor transformation
193 
195  template<typename NumericType>
196  bool addTensors(const std::string & addition, //in: symbolic tensor addition specification
197  NumericType alpha); //in: alpha prefactor
198 
199  template<typename NumericType>
200  bool addTensorsSync(const std::string & addition, //in: symbolic tensor addition specification
201  NumericType alpha); //in: alpha prefactor
202 
204  template<typename NumericType>
205  bool contractTensors(const std::string & contraction, //in: symbolic tensor contraction specification
206  NumericType alpha); //in: alpha prefactor
207 
208  template<typename NumericType>
209  bool contractTensorsSync(const std::string & contraction, //in: symbolic tensor contraction specification
210  NumericType alpha); //in: alpha prefactor
211 
213  bool evaluateTensorNetwork(const std::string & name, //in: tensor network name
214  const std::string & network); //in: symbolic tensor network specification
215 
216  bool evaluateTensorNetworkSync(const std::string & name, //in: tensor network name
217  const std::string & network); //in: symbolic tensor network specification
218 
222  std::shared_ptr<talsh::Tensor> getLocalTensor(std::shared_ptr<Tensor> tensor, //in: exatn::numerics::Tensor to get slice of (by copy)
223  const std::vector<std::pair<DimOffset,DimExtent>> & slice_spec); //in: tensor slice specification
225  std::shared_ptr<talsh::Tensor> getLocalTensor(std::shared_ptr<Tensor> tensor);
227  std::shared_ptr<talsh::Tensor> getLocalTensor(const std::string & name, //in: exatn tensor name
228  const std::vector<std::pair<DimOffset,DimExtent>> & slice_spec); //in: tensor slice specification
230  std::shared_ptr<talsh::Tensor> getLocalTensor(const std::string & name); //in: exatn tensor name
231 
232 private:
233 
234  numerics::SpaceRegister space_register_; //register of vector spaces and their named subspaces
235  std::unordered_map<std::string,SpaceId> subname2id_; //maps a subspace name to its parental vector space id
236 
237  std::unordered_map<std::string,std::shared_ptr<Tensor>> tensors_; //registered tensors
238 
239  std::map<std::string,std::shared_ptr<TensorMethod>> ext_methods_; //external tensor methods
240  std::map<std::string,std::shared_ptr<BytePacket>> ext_data_; //external data
241 
242  std::stack<std::pair<std::string,ScopeId>> scopes_; //TAProL scope stack: {Scope name, Scope Id}
243 
244  TensorOpFactory * tensor_op_factory_; //tensor operation factory
245 
246  std::shared_ptr<runtime::TensorRuntime> tensor_rt_; //tensor runtime (for actual execution of tensor operations)
247 };
248 
250 extern std::shared_ptr<NumServer> numericalServer;
251 
252 //TEMPLATE DEFINITIONS:
253 template <typename... Args>
254 bool NumServer::createTensor(const std::string & name,
255  TensorElementType element_type,
256  Args&&... args)
257 {
258  auto res = tensors_.emplace(std::make_pair(name,std::shared_ptr<Tensor>(new Tensor(name,args...))));
259  if(res.second){
260  std::shared_ptr<TensorOperation> op = tensor_op_factory_->createTensorOp(TensorOpCode::CREATE);
261  op->setTensorOperand((res.first)->second);
262  std::dynamic_pointer_cast<numerics::TensorOpCreate>(op)->resetTensorElementType(element_type);
263  submit(op);
264  }else{
265  std::cout << "#ERROR(exatn::NumServer::createTensor): Tensor " << name << " already exists!" << std::endl;
266  }
267  return res.second;
268 }
269 
270 template <typename... Args>
271 bool NumServer::createTensorSync(const std::string & name,
272  TensorElementType element_type,
273  Args&&... args)
274 {
275  auto res = tensors_.emplace(std::make_pair(name,std::shared_ptr<Tensor>(new Tensor(name,args...))));
276  if(res.second){
277  std::shared_ptr<TensorOperation> op = tensor_op_factory_->createTensorOp(TensorOpCode::CREATE);
278  op->setTensorOperand((res.first)->second);
279  std::dynamic_pointer_cast<numerics::TensorOpCreate>(op)->resetTensorElementType(element_type);
280  submit(op);
281  sync(*op);
282  }else{
283  std::cout << "#ERROR(exatn::NumServer::createTensor): Tensor " << name << " already exists!" << std::endl;
284  }
285  return res.second;
286 }
287 
288 template<typename NumericType>
289 bool NumServer::initTensor(const std::string & name,
290  NumericType value)
291 {
292  return transformTensor(name,std::shared_ptr<TensorMethod>(new numerics::FunctorInitVal(value)));
293 }
294 
295 template<typename NumericType>
296 bool NumServer::initTensorSync(const std::string & name,
297  NumericType value)
298 {
299  return transformTensorSync(name,std::shared_ptr<TensorMethod>(new numerics::FunctorInitVal(value)));
300 }
301 
302 template<typename NumericType>
303 bool NumServer::addTensors(const std::string & addition,
304  NumericType alpha)
305 {
306  std::vector<std::string> tensors;
307  auto parsed = parse_tensor_network(addition,tensors);
308  if(parsed){
309  if(tensors.size() == 2){
310  std::string tensor_name;
311  std::vector<IndexLabel> indices;
312  bool complex_conj;
313  parsed = parse_tensor(tensors[0],tensor_name,indices,complex_conj);
314  if(parsed){
315  auto iter = tensors_.find(tensor_name);
316  if(iter != tensors_.end()){
317  auto tensor0 = iter->second;
318  parsed = parse_tensor(tensors[1],tensor_name,indices,complex_conj);
319  if(parsed){
320  iter = tensors_.find(tensor_name);
321  if(iter != tensors_.end()){
322  auto tensor1 = iter->second;
323  std::shared_ptr<TensorOperation> op = tensor_op_factory_->createTensorOp(TensorOpCode::ADD);
324  op->setTensorOperand(tensor0);
325  op->setTensorOperand(tensor1);
326  op->setIndexPattern(addition);
327  op->setScalar(0,std::complex<double>(alpha));
328  submit(op);
329  }else{
330  parsed = false;
331  std::cout << "#ERROR(exatn::NumServer::addTensors): Tensor " << tensor_name << " not found in tensor addition: "
332  << addition << std::endl;
333  }
334  }else{
335  std::cout << "#ERROR(exatn::NumServer::addTensors): Invalid argument#1 in tensor addition: "
336  << addition << std::endl;
337  }
338  }else{
339  parsed = false;
340  std::cout << "#ERROR(exatn::NumServer::addTensors): Tensor " << tensor_name << " not found in tensor addition: "
341  << addition << std::endl;
342  }
343  }else{
344  std::cout << "#ERROR(exatn::NumServer::addTensors): Invalid argument#0 in tensor addition: "
345  << addition << std::endl;
346  }
347  }else{
348  parsed = false;
349  std::cout << "#ERROR(exatn::NumServer::addTensors): Invalid number of arguments in tensor addition: "
350  << addition << std::endl;
351  }
352  }else{
353  std::cout << "#ERROR(exatn::NumServer::addTensors): Invalid tensor addition: " << addition << std::endl;
354  }
355  return parsed;
356 }
357 
358 template<typename NumericType>
359 bool NumServer::addTensorsSync(const std::string & addition,
360  NumericType alpha)
361 {
362  std::vector<std::string> tensors;
363  auto parsed = parse_tensor_network(addition,tensors);
364  if(parsed){
365  if(tensors.size() == 2){
366  std::string tensor_name;
367  std::vector<IndexLabel> indices;
368  bool complex_conj;
369  parsed = parse_tensor(tensors[0],tensor_name,indices,complex_conj);
370  if(parsed){
371  auto iter = tensors_.find(tensor_name);
372  if(iter != tensors_.end()){
373  auto tensor0 = iter->second;
374  parsed = parse_tensor(tensors[1],tensor_name,indices,complex_conj);
375  if(parsed){
376  iter = tensors_.find(tensor_name);
377  if(iter != tensors_.end()){
378  auto tensor1 = iter->second;
379  std::shared_ptr<TensorOperation> op = tensor_op_factory_->createTensorOp(TensorOpCode::ADD);
380  op->setTensorOperand(tensor0);
381  op->setTensorOperand(tensor1);
382  op->setIndexPattern(addition);
383  op->setScalar(0,std::complex<double>(alpha));
384  submit(op);
385  sync(*op);
386  }else{
387  parsed = false;
388  std::cout << "#ERROR(exatn::NumServer::addTensors): Tensor " << tensor_name << " not found in tensor addition: "
389  << addition << std::endl;
390  }
391  }else{
392  std::cout << "#ERROR(exatn::NumServer::addTensors): Invalid argument#1 in tensor addition: "
393  << addition << std::endl;
394  }
395  }else{
396  parsed = false;
397  std::cout << "#ERROR(exatn::NumServer::addTensors): Tensor " << tensor_name << " not found in tensor addition: "
398  << addition << std::endl;
399  }
400  }else{
401  std::cout << "#ERROR(exatn::NumServer::addTensors): Invalid argument#0 in tensor addition: "
402  << addition << std::endl;
403  }
404  }else{
405  parsed = false;
406  std::cout << "#ERROR(exatn::NumServer::addTensors): Invalid number of arguments in tensor addition: "
407  << addition << std::endl;
408  }
409  }else{
410  std::cout << "#ERROR(exatn::NumServer::addTensors): Invalid tensor addition: " << addition << std::endl;
411  }
412  return parsed;
413 }
414 
415 template<typename NumericType>
416 bool NumServer::contractTensors(const std::string & contraction,
417  NumericType alpha)
418 {
419  std::vector<std::string> tensors;
420  auto parsed = parse_tensor_network(contraction,tensors);
421  if(parsed){
422  if(tensors.size() == 3){
423  std::string tensor_name;
424  std::vector<IndexLabel> indices;
425  bool complex_conj;
426  parsed = parse_tensor(tensors[0],tensor_name,indices,complex_conj);
427  if(parsed){
428  auto iter = tensors_.find(tensor_name);
429  if(iter != tensors_.end()){
430  auto tensor0 = iter->second;
431  parsed = parse_tensor(tensors[1],tensor_name,indices,complex_conj);
432  if(parsed){
433  iter = tensors_.find(tensor_name);
434  if(iter != tensors_.end()){
435  auto tensor1 = iter->second;
436  parsed = parse_tensor(tensors[2],tensor_name,indices,complex_conj);
437  if(parsed){
438  iter = tensors_.find(tensor_name);
439  if(iter != tensors_.end()){
440  auto tensor2 = iter->second;
441  std::shared_ptr<TensorOperation> op = tensor_op_factory_->createTensorOp(TensorOpCode::CONTRACT);
442  op->setTensorOperand(tensor0);
443  op->setTensorOperand(tensor1);
444  op->setTensorOperand(tensor2);
445  op->setIndexPattern(contraction);
446  op->setScalar(0,std::complex<double>(alpha));
447  submit(op);
448  }else{
449  parsed = false;
450  std::cout << "#ERROR(exatn::NumServer::contractTensors): Tensor " << tensor_name << " not found in tensor contraction: "
451  << contraction << std::endl;
452  }
453  }else{
454  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid argument#2 in tensor contraction: "
455  << contraction << std::endl;
456  }
457  }else{
458  parsed = false;
459  std::cout << "#ERROR(exatn::NumServer::contractTensors): Tensor " << tensor_name << " not found in tensor contraction: "
460  << contraction << std::endl;
461  }
462  }else{
463  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid argument#1 in tensor contraction: "
464  << contraction << std::endl;
465  }
466  }else{
467  parsed = false;
468  std::cout << "#ERROR(exatn::NumServer::contractTensors): Tensor " << tensor_name << " not found in tensor contraction: "
469  << contraction << std::endl;
470  }
471  }else{
472  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid argument#0 in tensor contraction: "
473  << contraction << std::endl;
474  }
475  }else{
476  parsed = false;
477  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid number of arguments in tensor contraction: "
478  << contraction << std::endl;
479  }
480  }else{
481  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid tensor contraction: " << contraction << std::endl;
482  }
483  return parsed;
484 }
485 
486 template<typename NumericType>
487 bool NumServer::contractTensorsSync(const std::string & contraction,
488  NumericType alpha)
489 {
490  std::vector<std::string> tensors;
491  auto parsed = parse_tensor_network(contraction,tensors);
492  if(parsed){
493  if(tensors.size() == 3){
494  std::string tensor_name;
495  std::vector<IndexLabel> indices;
496  bool complex_conj;
497  parsed = parse_tensor(tensors[0],tensor_name,indices,complex_conj);
498  if(parsed){
499  auto iter = tensors_.find(tensor_name);
500  if(iter != tensors_.end()){
501  auto tensor0 = iter->second;
502  parsed = parse_tensor(tensors[1],tensor_name,indices,complex_conj);
503  if(parsed){
504  iter = tensors_.find(tensor_name);
505  if(iter != tensors_.end()){
506  auto tensor1 = iter->second;
507  parsed = parse_tensor(tensors[2],tensor_name,indices,complex_conj);
508  if(parsed){
509  iter = tensors_.find(tensor_name);
510  if(iter != tensors_.end()){
511  auto tensor2 = iter->second;
512  std::shared_ptr<TensorOperation> op = tensor_op_factory_->createTensorOp(TensorOpCode::CONTRACT);
513  op->setTensorOperand(tensor0);
514  op->setTensorOperand(tensor1);
515  op->setTensorOperand(tensor2);
516  op->setIndexPattern(contraction);
517  op->setScalar(0,std::complex<double>(alpha));
518  submit(op);
519  sync(*op);
520  }else{
521  parsed = false;
522  std::cout << "#ERROR(exatn::NumServer::contractTensors): Tensor " << tensor_name << " not found in tensor contraction: "
523  << contraction << std::endl;
524  }
525  }else{
526  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid argument#2 in tensor contraction: "
527  << contraction << std::endl;
528  }
529  }else{
530  parsed = false;
531  std::cout << "#ERROR(exatn::NumServer::contractTensors): Tensor " << tensor_name << " not found in tensor contraction: "
532  << contraction << std::endl;
533  }
534  }else{
535  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid argument#1 in tensor contraction: "
536  << contraction << std::endl;
537  }
538  }else{
539  parsed = false;
540  std::cout << "#ERROR(exatn::NumServer::contractTensors): Tensor " << tensor_name << " not found in tensor contraction: "
541  << contraction << std::endl;
542  }
543  }else{
544  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid argument#0 in tensor contraction: "
545  << contraction << std::endl;
546  }
547  }else{
548  parsed = false;
549  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid number of arguments in tensor contraction: "
550  << contraction << std::endl;
551  }
552  }else{
553  std::cout << "#ERROR(exatn::NumServer::contractTensors): Invalid tensor contraction: " << contraction << std::endl;
554  }
555  return parsed;
556 }
557 
558 } //namespace exatn
559 
560 #endif //EXATN_NUM_SERVER_HPP_
exatn::numerics::TensorOpFactory::createTensorOp
std::unique_ptr< TensorOperation > createTensorOp(TensorOpCode opcode)
Definition: tensor_op_factory.cpp:28
exatn::numerics::Tensor
Definition: tensor.hpp:63
exatn::numerics::TensorNetwork
Definition: tensor_network.hpp:72
exatn::NumServer::contractTensors
bool contractTensors(const std::string &contraction, NumericType alpha)
Definition: num_server.hpp:416
exatn::NumServer::destroyVectorSpace
void destroyVectorSpace(const std::string &space_name)
Definition: num_server.cpp:101
exatn::numerics::Subspace
Definition: spaces.hpp:84
exatn::NumServer::initTensor
bool initTensor(const std::string &name, NumericType value)
Definition: num_server.hpp:289
exatn::NumServer::addTensors
bool addTensors(const std::string &addition, NumericType alpha)
Definition: num_server.hpp:303
exatn::numerics::FunctorInitVal
Definition: functor_init_val.hpp:28
exatn::NumServer::destroySubspace
void destroySubspace(const std::string &subspace_name)
Definition: num_server.cpp:137
exatn::NumServer::getExternalData
std::shared_ptr< BytePacket > getExternalData(const std::string &tag)
Definition: num_server.cpp:68
exatn::NumServer::createVectorSpace
SpaceId createVectorSpace(const std::string &space_name, DimExtent space_dim, const VectorSpace **space_ptr=nullptr)
Definition: num_server.cpp:92
exatn
Definition: DriverClient.hpp:10
exatn::NumServer
Definition: num_server.hpp:62
exatn::parse_tensor
bool parse_tensor(const std::string &tensor, std::string &tensor_name, std::vector< IndexLabel > &indices, bool &complex_conjugated)
Definition: tensor_symbol.cpp:13
exatn::numerics::SpaceRegister
Definition: space_register.hpp:101
exatn::NumServer::createTensor
bool createTensor(const std::string &name, TensorElementType element_type, Args &&... args)
Definition: num_server.hpp:254
exatn::NumServer::registerExternalData
void registerExternalData(const std::string &tag, std::shared_ptr< BytePacket > packet)
Definition: num_server.cpp:60
exatn::NumServer::registerTensorMethod
void registerTensorMethod(const std::string &tag, std::shared_ptr< TensorMethod > method)
Definition: num_server.cpp:47
exatn::NumServer::resetRuntimeLoggingLevel
void resetRuntimeLoggingLevel(int level=0)
Definition: num_server.cpp:41
exatn::numericalServer
std::shared_ptr< NumServer > numericalServer
Definition: num_server.cpp:17
exatn::NumServer::getTensorMethod
std::shared_ptr< TensorMethod > getTensorMethod(const std::string &tag)
Definition: num_server.cpp:55
exatn::numerics::TensorOperation
Definition: tensor_operation.hpp:36
exatn::NumServer::openScope
ScopeId openScope(const std::string &scope_name)
Definition: num_server.cpp:74
exatn::NumServer::destroyTensor
bool destroyTensor(const std::string &name)
Definition: num_server.cpp:237
exatn::NumServer::getLocalTensor
std::shared_ptr< talsh::Tensor > getLocalTensor(std::shared_ptr< Tensor > tensor, const std::vector< std::pair< DimOffset, DimExtent >> &slice_spec)
Definition: num_server.cpp:371
exatn::NumServer::getTensorRef
Tensor & getTensorRef(const std::string &name)
Definition: num_server.cpp:217
exatn::parse_tensor_network
bool parse_tensor_network(const std::string &network, std::vector< std::string > &tensors)
Definition: tensor_symbol.cpp:92
exatn::NumServer::createSubspace
SubspaceId createSubspace(const std::string &subspace_name, const std::string &space_name, std::pair< DimOffset, DimOffset > bounds, const Subspace **subspace_ptr=nullptr)
Definition: num_server.cpp:121
exatn::NumServer::transformTensor
bool transformTensor(const std::string &name, std::shared_ptr< TensorMethod > functor)
Definition: num_server.cpp:269
exatn::NumServer::getTensorElementType
TensorElementType getTensorElementType(const std::string &name) const
Definition: num_server.cpp:227
exatn::Identifiable
Definition: Identifiable.hpp:9
exatn::numerics::TensorOpFactory
Definition: tensor_op_factory.hpp:29
exatn::NumServer::submit
void submit(std::shared_ptr< TensorOperation > operation)
Definition: num_server.cpp:165
exatn::NumServer::getVectorSpace
const VectorSpace * getVectorSpace(const std::string &space_name) const
Definition: num_server.cpp:115
exatn::NumServer::getSubspace
const Subspace * getSubspace(const std::string &subspace_name) const
Definition: num_server.cpp:151
exatn::NumServer::closeScope
ScopeId closeScope()
Definition: num_server.cpp:82
exatn::NumServer::evaluateTensorNetwork
bool evaluateTensorNetwork(const std::string &name, const std::string &network)
Definition: num_server.cpp:298
exatn::numerics::VectorSpace
Definition: spaces.hpp:32
exatn::NumServer::sync
bool sync(const Tensor &tensor, bool wait=true)
Definition: num_server.cpp:192
exatn::NumServer::reconfigureTensorRuntime
void reconfigureTensorRuntime(const std::string &dag_executor_name, const std::string &node_executor_name)
Definition: num_server.cpp:34
Generated by   doxygen 1.8.16