numpy_nditer.h

Go to the documentation of this file.

#pragma once
 
#include <nlohmann/json.hpp>
#include <util/irep/expr.h>
 
#include <optional>
#include <string>
#include <tuple>
#include <vector>
 
class python_converter;

struct numpy_nditer_operand
{
  nlohmann::json array;
  bool writable = false;
  std::vector<long long> shape;
  std::vector<long long> strides;
  nlohmann::json extent;
  nlohmann::json stride;
  std::vector<long long> axes;
  typet dtype;
  std::string buffer;
};

struct numpy_nditer_state
{
  std::string state;
  std::string alias;
  std::vector<numpy_nditer_operand> operands;
  std::vector<long long> shape;
  std::vector<std::size_t> axes;
  std::vector<bool> flipped;
  bool runtime = false;
  bool flip_negative = false;
  bool multi_index = false;
  std::string index;
  bool external_loop = false;
  bool buffered = false;
  long long chunk = 1;
  long long size = 0;
};

struct numpy_nditer_item
{
  std::string iterator;
  std::size_t operand = 0;
  std::string position;
};

class numpy_nditer
{
public:
  explicit numpy_nditer(python_converter &converter);
 
  static bool
  is_nditer_call(const nlohmann::json &node, const nlohmann::json &ast);

  void create(const std::string &name, const nlohmann::json &call);

  exprt as_list(const nlohmann::json &call);

  bool bind(const nlohmann::json &target, const nlohmann::json &value);
 
  std::optional<exprt> attribute(const nlohmann::json &node);
  std::optional<exprt> call(const nlohmann::json &node);
  std::optional<exprt> read_item(const nlohmann::json &name);
  std::optional<exprt> subscript(const nlohmann::json &node);
  bool write(const nlohmann::json &target, const nlohmann::json &value);

  void keep_sources(const std::string &rebound_id, const std::string &heir_id);
 
  static std::string key(const std::string &function, const std::string &name);
 
private:
  python_converter &converter_;
 
  const numpy_nditer_state *find(const nlohmann::json &node) const;
  const numpy_nditer_item *find_item(const nlohmann::json &node) const;
 
  std::optional<numpy_nditer_state>
  describe(const nlohmann::json &call, const std::string &state);
  std::vector<nlohmann::json> evaluate_operands(
    const std::vector<nlohmann::json> &ops,
    const std::vector<std::vector<std::string>> &op_flags);
  numpy_nditer_operand operand(const nlohmann::json &node, std::size_t index);
  nlohmann::json named_operand(const nlohmann::json &node, std::size_t index);
  template <class Info>
  void view_layout(const Info &info, numpy_nditer_operand &result);
  template <class Info>
  void runtime_layout(const Info &info, numpy_nditer_operand &result);
  std::string invalid_setup(
    const std::vector<std::string> &flag_list,
    const std::string &order_name) const;
  std::string invalid_tracking(const std::vector<std::string> &flag_list) const;
  nlohmann::json flat_index(
    const numpy_nditer_state &it,
    const std::vector<nlohmann::json> &axis_index) const;
  bool writable_operands_fit(
    const numpy_nditer_state &it,
    const std::vector<std::vector<std::string>> &op_flags);
  bool check_size(numpy_nditer_state &it, bool zerosize_ok);
  std::vector<std::string> flags(const nlohmann::json &call);
  std::string order(const nlohmann::json &call);
  void order_axes(numpy_nditer_state &it, const std::string &order) const;
  void set_chunk(numpy_nditer_state &it) const;
  bool broadcast(numpy_nditer_state &it);
  bool apply_op_axes(numpy_nditer_state &it, const nlohmann::json &call);
  std::string invalid_op_axes(
    const numpy_nditer_operand &o,
    const std::vector<long long> &axes,
    std::size_t op) const;
  bool apply_op_dtypes(numpy_nditer_state &it, const nlohmann::json &call);
  typet element_type(const numpy_nditer_operand &o) const;
  nlohmann::json value(
    const numpy_nditer_state &it,
    std::size_t op,
    const nlohmann::json &element_position);
 
  nlohmann::json position(const numpy_nditer_state &it) const;
  nlohmann::json items(const numpy_nditer_state &it) const;
  nlohmann::json finished(const numpy_nditer_state &it) const;
  static std::vector<long long> reported_shape(const numpy_nditer_state &it);
  std::vector<nlohmann::json> indices(
    const numpy_nditer_state &it,
    const nlohmann::json &element_position) const;
  nlohmann::json element(
    const numpy_nditer_state &it,
    std::size_t op,
    const nlohmann::json &element_position) const;
  exprt
  chunk_value(const numpy_nditer_state &it, const numpy_nditer_item &item);
  nlohmann::json prebuilt(const exprt &expr);
  nlohmann::json materialize(const numpy_nditer_item &item);
  bool substitute_chunks(nlohmann::json &node);
 
  void assign(const std::string &name, const nlohmann::json &value);
  void raise(const std::string &exception, const std::string &message);
  void raise_if(
    const nlohmann::json &cond,
    const std::string &exception,
    const std::string &message);
  void advance(const numpy_nditer_state &it);
  bool buffer_writes(numpy_nditer_state &it);
  void fill_buffers(const numpy_nditer_state &it);
  void flush_buffers(const numpy_nditer_state &it, const nlohmann::json &when);
  void bind_name(
    const nlohmann::json &target,
    const numpy_nditer_state &it,
    const std::string &iterator,
    std::size_t op);
  void bind_operand(
    const nlohmann::json &target,
    const numpy_nditer_state &it,
    const std::string &iterator,
    const nlohmann::json &index);
  void bind_items(
    const nlohmann::json &target,
    const numpy_nditer_state &it,
    const std::string &iterator);
  nlohmann::json current_values(const numpy_nditer_state &it);
  nlohmann::json
  layout_attribute(const numpy_nditer_state &it, const std::string &attr) const;
  nlohmann::json
  position_attribute(const numpy_nditer_state &it, const std::string &attr);
  void check_unpack(const numpy_nditer_state &it, long long expected);
  std::optional<
    std::tuple<const numpy_nditer_state *, std::size_t, nlohmann::json>>
  written(const nlohmann::json &target);
  nlohmann::json call_method(
    const numpy_nditer_state &it,
    const std::string &method,
    const nlohmann::json &node);
};