//+
// C++ equality functions for Tao / C++ structure interface.
//
// This file is generated as part of the Tao/C++ interface code generation.
// The code generation files can be found in cpp_tao_interface.
//
// DO NOT EDIT THIS FILE DIRECTLY! 
//-

#include <iostream>
#include <stdlib.h>
#include "cpp_tao_classes.h"

using namespace std;

//---------------------------------------------------

template <class T> bool is_all_equal (const valarray<T>& vec1, const valarray<T>& vec2) {
  bool is_eq = true;
  if (vec1.size() != vec2.size()) return false;
  for (unsigned int i = 0; i < vec1.size(); i++) {
    is_eq = is_eq && (vec1[i] == vec2[i]);
  }
  return is_eq;
}

template <class T> bool is_all_equal (const valarray< valarray<T> >& mat1, const valarray< valarray<T> >& mat2) {
  bool is_eq = true;
  if (mat1.size() != mat2.size()) return false;
  for (unsigned int i = 0; i < mat1.size(); i++) {
    if (mat1[i].size() != mat2[i].size()) return false;
    for (unsigned int j = 0; j < mat1[i].size(); j++) {
      is_eq = is_eq && (mat1[i][j] == mat2[i][j]);
    }
  }
  return is_eq;
};

template <class T> bool is_all_equal (const valarray< valarray< valarray<T> > >& tensor1, const valarray< valarray< valarray<T> > >& tensor2) {
  bool is_eq = true;
  if (tensor1.size() != tensor2.size()) return false;
  for (unsigned int i = 0; i < tensor1.size(); i++) {
    if (tensor1[i].size() != tensor2[i].size()) return false;
    for (unsigned int j = 0; j < tensor1[i].size(); j++) {
      if (tensor1[i][j].size() != tensor2[i][j].size()) return false;
      for (unsigned int k = 0; k < tensor1[i][j].size(); k++) {
        is_eq = is_eq && (tensor1[i][j][k] == tensor2[i][j][k]);
      }
    }
  }
  return is_eq;
};

//---------------------------------------------------

template bool is_all_equal (const Bool_ARRAY&,     const Bool_ARRAY&);
template bool is_all_equal (const Complex_ARRAY&,  const Complex_ARRAY&);
template bool is_all_equal (const Real_ARRAY&,     const Real_ARRAY&);
template bool is_all_equal (const Int_ARRAY&,      const Int_ARRAY&);
template bool is_all_equal (const String_ARRAY&,   const String_ARRAY&);

template bool is_all_equal (const Bool_MATRIX&,     const Bool_MATRIX&);
template bool is_all_equal (const Complex_MATRIX&,  const Complex_MATRIX&);
template bool is_all_equal (const Real_MATRIX&,     const Real_MATRIX&);
template bool is_all_equal (const Int_MATRIX&,      const Int_MATRIX&);

template bool is_all_equal (const Complex_TENSOR&,  const Complex_TENSOR&);
template bool is_all_equal (const Real_TENSOR&,     const Real_TENSOR&);
template bool is_all_equal (const Int_TENSOR&,      const Int_TENSOR&);


//--------------------------------------------------------------

bool operator== (const CPP_qp_rect& x, const CPP_qp_rect& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.x1 == y.x1);
  is_eq = is_eq && (x.x2 == y.x2);
  is_eq = is_eq && (x.y1 == y.y1);
  is_eq = is_eq && (x.y2 == y.y2);
  is_eq = is_eq && (x.units == y.units);
  return is_eq;
};

template bool is_all_equal (const CPP_qp_rect_ARRAY&, const CPP_qp_rect_ARRAY&);
template bool is_all_equal (const CPP_qp_rect_MATRIX&, const CPP_qp_rect_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_qp_line& x, const CPP_qp_line& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.width == y.width);
  is_eq = is_eq && (x.color == y.color);
  is_eq = is_eq && (x.pattern == y.pattern);
  return is_eq;
};

template bool is_all_equal (const CPP_qp_line_ARRAY&, const CPP_qp_line_ARRAY&);
template bool is_all_equal (const CPP_qp_line_MATRIX&, const CPP_qp_line_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_qp_symbol& x, const CPP_qp_symbol& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.type == y.type);
  is_eq = is_eq && (x.height == y.height);
  is_eq = is_eq && (x.color == y.color);
  is_eq = is_eq && (x.fill_pattern == y.fill_pattern);
  is_eq = is_eq && (x.line_width == y.line_width);
  return is_eq;
};

template bool is_all_equal (const CPP_qp_symbol_ARRAY&, const CPP_qp_symbol_ARRAY&);
template bool is_all_equal (const CPP_qp_symbol_MATRIX&, const CPP_qp_symbol_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_qp_point& x, const CPP_qp_point& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.x == y.x);
  is_eq = is_eq && (x.y == y.y);
  is_eq = is_eq && (x.units == y.units);
  return is_eq;
};

template bool is_all_equal (const CPP_qp_point_ARRAY&, const CPP_qp_point_ARRAY&);
template bool is_all_equal (const CPP_qp_point_MATRIX&, const CPP_qp_point_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_qp_axis& x, const CPP_qp_axis& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.label == y.label);
  is_eq = is_eq && (x.min == y.min);
  is_eq = is_eq && (x.max == y.max);
  is_eq = is_eq && (x.number_offset == y.number_offset);
  is_eq = is_eq && (x.label_offset == y.label_offset);
  is_eq = is_eq && (x.major_tick_len == y.major_tick_len);
  is_eq = is_eq && (x.minor_tick_len == y.minor_tick_len);
  is_eq = is_eq && (x.label_color == y.label_color);
  is_eq = is_eq && (x.major_div == y.major_div);
  is_eq = is_eq && (x.major_div_nominal == y.major_div_nominal);
  is_eq = is_eq && (x.minor_div == y.minor_div);
  is_eq = is_eq && (x.minor_div_max == y.minor_div_max);
  is_eq = is_eq && (x.places == y.places);
  is_eq = is_eq && (x.type == y.type);
  is_eq = is_eq && (x.bounds == y.bounds);
  is_eq = is_eq && (x.tick_side == y.tick_side);
  is_eq = is_eq && (x.number_side == y.number_side);
  is_eq = is_eq && (x.draw_label == y.draw_label);
  is_eq = is_eq && (x.draw_numbers == y.draw_numbers);
  return is_eq;
};

template bool is_all_equal (const CPP_qp_axis_ARRAY&, const CPP_qp_axis_ARRAY&);
template bool is_all_equal (const CPP_qp_axis_MATRIX&, const CPP_qp_axis_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_cmd_history& x, const CPP_tao_cmd_history& y) {
  bool is_eq = true;
  is_eq = is_eq && ((x.cmd == NULL) == (y.cmd == NULL));
  if (!is_eq) return false;
  if (x.cmd != NULL) is_eq = (*x.cmd == *y.cmd);
  is_eq = is_eq && (x.ix == y.ix);
  is_eq = is_eq && (x.cmd_file == y.cmd_file);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_cmd_history_ARRAY&, const CPP_tao_cmd_history_ARRAY&);
template bool is_all_equal (const CPP_tao_cmd_history_MATRIX&, const CPP_tao_cmd_history_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_real_pointer& x, const CPP_tao_real_pointer& y) {
  bool is_eq = true;
  is_eq = is_eq && ((x.good_value == NULL) == (y.good_value == NULL));
  if (!is_eq) return false;
  if (x.good_value != NULL) is_eq = (*x.good_value == *y.good_value);
  is_eq = is_eq && ((x.good_user == NULL) == (y.good_user == NULL));
  if (!is_eq) return false;
  if (x.good_user != NULL) is_eq = (*x.good_user == *y.good_user);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_real_pointer_ARRAY&, const CPP_tao_real_pointer_ARRAY&);
template bool is_all_equal (const CPP_tao_real_pointer_MATRIX&, const CPP_tao_real_pointer_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_logical_array& x, const CPP_tao_logical_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_logical_array_ARRAY&, const CPP_tao_logical_array_ARRAY&);
template bool is_all_equal (const CPP_tao_logical_array_MATRIX&, const CPP_tao_logical_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_integer_array& x, const CPP_tao_integer_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_integer_array_ARRAY&, const CPP_tao_integer_array_ARRAY&);
template bool is_all_equal (const CPP_tao_integer_array_MATRIX&, const CPP_tao_integer_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_expression_info& x, const CPP_tao_expression_info& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.good == y.good);
  is_eq = is_eq && (x.ix_ele == y.ix_ele);
  is_eq = is_eq && (x.s == y.s);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_expression_info_ARRAY&, const CPP_tao_expression_info_ARRAY&);
template bool is_all_equal (const CPP_tao_expression_info_MATRIX&, const CPP_tao_expression_info_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_eval_stack1& x, const CPP_tao_eval_stack1& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.type == y.type);
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.scale == y.scale);
  is_eq = is_eq && is_all_equal(x.value, y.value);
  is_eq = is_eq && is_all_equal(x.info, y.info);
  is_eq = is_eq && is_all_equal(x.value_ptr, y.value_ptr);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_eval_stack1_ARRAY&, const CPP_tao_eval_stack1_ARRAY&);
template bool is_all_equal (const CPP_tao_eval_stack1_MATRIX&, const CPP_tao_eval_stack1_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_ele_shape& x, const CPP_tao_ele_shape& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.ele_id == y.ele_id);
  is_eq = is_eq && (x.shape == y.shape);
  is_eq = is_eq && (x.color == y.color);
  is_eq = is_eq && (x.size == y.size);
  is_eq = is_eq && (x.label == y.label);
  is_eq = is_eq && (x.draw == y.draw);
  is_eq = is_eq && (x.multi == y.multi);
  is_eq = is_eq && (x.ix_ele_key == y.ix_ele_key);
  is_eq = is_eq && (x.name_ele == y.name_ele);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_ele_shape_ARRAY&, const CPP_tao_ele_shape_ARRAY&);
template bool is_all_equal (const CPP_tao_ele_shape_MATRIX&, const CPP_tao_ele_shape_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_pattern_point& x, const CPP_tao_pattern_point& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.s == y.s);
  is_eq = is_eq && (x.x == y.x);
  is_eq = is_eq && (x.radius == y.radius);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_pattern_point_ARRAY&, const CPP_tao_pattern_point_ARRAY&);
template bool is_all_equal (const CPP_tao_pattern_point_MATRIX&, const CPP_tao_pattern_point_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_pattern_curve& x, const CPP_tao_pattern_curve& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.line == y.line);
  is_eq = is_eq && is_all_equal(x.pt, y.pt);
  is_eq = is_eq && (x.scale == y.scale);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_pattern_curve_ARRAY&, const CPP_tao_pattern_curve_ARRAY&);
template bool is_all_equal (const CPP_tao_pattern_curve_MATRIX&, const CPP_tao_pattern_curve_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_shape_pattern& x, const CPP_tao_shape_pattern& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && is_all_equal(x.curve, y.curve);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_shape_pattern_ARRAY&, const CPP_tao_shape_pattern_ARRAY&);
template bool is_all_equal (const CPP_tao_shape_pattern_MATRIX&, const CPP_tao_shape_pattern_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_drawing& x, const CPP_tao_drawing& y) {
  bool is_eq = true;
  is_eq = is_eq && is_all_equal(x.ele_shape, y.ele_shape);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_drawing_ARRAY&, const CPP_tao_drawing_ARRAY&);
template bool is_all_equal (const CPP_tao_drawing_MATRIX&, const CPP_tao_drawing_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_wave_kick_pt& x, const CPP_tao_wave_kick_pt& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.phi_s == y.phi_s);
  is_eq = is_eq && (x.phi_r == y.phi_r);
  is_eq = is_eq && (x.phi == y.phi);
  is_eq = is_eq && (x.amp == y.amp);
  is_eq = is_eq && (x.ix_dat == y.ix_dat);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_wave_kick_pt_ARRAY&, const CPP_tao_wave_kick_pt_ARRAY&);
template bool is_all_equal (const CPP_tao_wave_kick_pt_MATRIX&, const CPP_tao_wave_kick_pt_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_wave& x, const CPP_tao_wave& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.data_type == y.data_type);
  is_eq = is_eq && (x.rms_rel_a == y.rms_rel_a);
  is_eq = is_eq && (x.rms_rel_b == y.rms_rel_b);
  is_eq = is_eq && (x.rms_rel_as == y.rms_rel_as);
  is_eq = is_eq && (x.rms_rel_bs == y.rms_rel_bs);
  is_eq = is_eq && (x.rms_rel_ar == y.rms_rel_ar);
  is_eq = is_eq && (x.rms_rel_br == y.rms_rel_br);
  is_eq = is_eq && (x.rms_rel_k == y.rms_rel_k);
  is_eq = is_eq && (x.rms_rel_ks == y.rms_rel_ks);
  is_eq = is_eq && (x.rms_rel_kr == y.rms_rel_kr);
  is_eq = is_eq && (x.rms_phi == y.rms_phi);
  is_eq = is_eq && (x.rms_phi_s == y.rms_phi_s);
  is_eq = is_eq && (x.rms_phi_r == y.rms_phi_r);
  is_eq = is_eq && (x.amp_ba_s == y.amp_ba_s);
  is_eq = is_eq && (x.amp_ba_r == y.amp_ba_r);
  is_eq = is_eq && (x.chi_a == y.chi_a);
  is_eq = is_eq && (x.chi_c == y.chi_c);
  is_eq = is_eq && (x.chi_ba == y.chi_ba);
  is_eq = is_eq && is_all_equal(x.amp_a, y.amp_a);
  is_eq = is_eq && is_all_equal(x.amp_b, y.amp_b);
  is_eq = is_eq && is_all_equal(x.amp_ba, y.amp_ba);
  is_eq = is_eq && is_all_equal(x.coef_a, y.coef_a);
  is_eq = is_eq && is_all_equal(x.coef_b, y.coef_b);
  is_eq = is_eq && is_all_equal(x.coef_ba, y.coef_ba);
  is_eq = is_eq && (x.n_func == y.n_func);
  is_eq = is_eq && (x.ix_a1 == y.ix_a1);
  is_eq = is_eq && (x.ix_a2 == y.ix_a2);
  is_eq = is_eq && (x.ix_b1 == y.ix_b1);
  is_eq = is_eq && (x.ix_b2 == y.ix_b2);
  is_eq = is_eq && (x.i_a1 == y.i_a1);
  is_eq = is_eq && (x.i_a2 == y.i_a2);
  is_eq = is_eq && (x.i_b1 == y.i_b1);
  is_eq = is_eq && (x.i_b2 == y.i_b2);
  is_eq = is_eq && (x.n_a == y.n_a);
  is_eq = is_eq && (x.n_b == y.n_b);
  is_eq = is_eq && (x.i_wrap_pt == y.i_wrap_pt);
  is_eq = is_eq && is_all_equal(x.ix_data, y.ix_data);
  is_eq = is_eq && (x.n_kick == y.n_kick);
  is_eq = is_eq && is_all_equal(x.kick, y.kick);
  is_eq = is_eq && (x.graph == y.graph);
  is_eq = is_eq && (x.ele == y.ele);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_wave_ARRAY&, const CPP_tao_wave_ARRAY&);
template bool is_all_equal (const CPP_tao_wave_MATRIX&, const CPP_tao_wave_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_title& x, const CPP_tao_title& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.title == y.title);
  is_eq = is_eq && (x.x == y.x);
  is_eq = is_eq && (x.y == y.y);
  is_eq = is_eq && (x.units == y.units);
  is_eq = is_eq && (x.justify == y.justify);
  is_eq = is_eq && (x.draw_it == y.draw_it);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_title_ARRAY&, const CPP_tao_title_ARRAY&);
template bool is_all_equal (const CPP_tao_title_MATRIX&, const CPP_tao_title_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_data_var_component& x, const CPP_tao_data_var_component& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.sign == y.sign);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_data_var_component_ARRAY&, const CPP_tao_data_var_component_ARRAY&);
template bool is_all_equal (const CPP_tao_data_var_component_MATRIX&, const CPP_tao_data_var_component_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_histogram& x, const CPP_tao_histogram& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.density_normalized == y.density_normalized);
  is_eq = is_eq && (x.weight_by_charge == y.weight_by_charge);
  is_eq = is_eq && (x.minimum == y.minimum);
  is_eq = is_eq && (x.maximum == y.maximum);
  is_eq = is_eq && (x.width == y.width);
  is_eq = is_eq && (x.center == y.center);
  is_eq = is_eq && (x.number == y.number);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_histogram_ARRAY&, const CPP_tao_histogram_ARRAY&);
template bool is_all_equal (const CPP_tao_histogram_MATRIX&, const CPP_tao_histogram_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_curve& x, const CPP_tao_curve& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.data_source == y.data_source);
  is_eq = is_eq && (x.data_index == y.data_index);
  is_eq = is_eq && (x.data_type_x == y.data_type_x);
  is_eq = is_eq && (x.data_type_z == y.data_type_z);
  is_eq = is_eq && (x.data_type == y.data_type);
  is_eq = is_eq && (x.ele_ref_name == y.ele_ref_name);
  is_eq = is_eq && (x.legend_text == y.legend_text);
  is_eq = is_eq && (x.message_text == y.message_text);
  is_eq = is_eq && (x.units == y.units);
  is_eq = is_eq && (x.component == y.component);
  is_eq = is_eq && (x.hist == y.hist);
  is_eq = is_eq && is_all_equal(x.x_line, y.x_line);
  is_eq = is_eq && is_all_equal(x.y_line, y.y_line);
  is_eq = is_eq && is_all_equal(x.y2_line, y.y2_line);
  is_eq = is_eq && is_all_equal(x.ix_line, y.ix_line);
  is_eq = is_eq && is_all_equal(x.x_symb, y.x_symb);
  is_eq = is_eq && is_all_equal(x.y_symb, y.y_symb);
  is_eq = is_eq && is_all_equal(x.z_symb, y.z_symb);
  is_eq = is_eq && is_all_equal(x.symb_size, y.symb_size);
  is_eq = is_eq && is_all_equal(x.ix_symb, y.ix_symb);
  is_eq = is_eq && (x.y_axis_scale_factor == y.y_axis_scale_factor);
  is_eq = is_eq && (x.s == y.s);
  is_eq = is_eq && (x.z_color0 == y.z_color0);
  is_eq = is_eq && (x.z_color1 == y.z_color1);
  is_eq = is_eq && (x.line == y.line);
  is_eq = is_eq && (x.symbol == y.symbol);
  is_eq = is_eq && (x.ix_universe == y.ix_universe);
  is_eq = is_eq && (x.symbol_every == y.symbol_every);
  is_eq = is_eq && (x.ix_branch == y.ix_branch);
  is_eq = is_eq && (x.ix_ele_ref == y.ix_ele_ref);
  is_eq = is_eq && (x.ix_ele_ref_track == y.ix_ele_ref_track);
  is_eq = is_eq && (x.ix_bunch == y.ix_bunch);
  is_eq = is_eq && (x.use_y2 == y.use_y2);
  is_eq = is_eq && (x.draw_line == y.draw_line);
  is_eq = is_eq && (x.draw_symbols == y.draw_symbols);
  is_eq = is_eq && (x.draw_symbol_index == y.draw_symbol_index);
  is_eq = is_eq && (x.smooth_line_calc == y.smooth_line_calc);
  is_eq = is_eq && (x.use_z_color == y.use_z_color);
  is_eq = is_eq && (x.autoscale_z_color == y.autoscale_z_color);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_curve_ARRAY&, const CPP_tao_curve_ARRAY&);
template bool is_all_equal (const CPP_tao_curve_MATRIX&, const CPP_tao_curve_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_graph& x, const CPP_tao_graph& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.type == y.type);
  is_eq = is_eq && (x.title == y.title);
  is_eq = is_eq && (x.title_suffix == y.title_suffix);
  is_eq = is_eq && is_all_equal(x.text_legend, y.text_legend);
  is_eq = is_eq && (x.component == y.component);
  is_eq = is_eq && (x.why_invalid == y.why_invalid);
  is_eq = is_eq && (x.floor_plan_view == y.floor_plan_view);
  is_eq = is_eq && (x.floor_plan_orbit_color == y.floor_plan_orbit_color);
  is_eq = is_eq && is_all_equal(x.curve, y.curve);
  is_eq = is_eq && (x.text_legend_origin == y.text_legend_origin);
  is_eq = is_eq && (x.curve_legend_origin == y.curve_legend_origin);
  is_eq = is_eq && (x.x == y.x);
  is_eq = is_eq && (x.y == y.y);
  is_eq = is_eq && (x.y2 == y.y2);
  is_eq = is_eq && (x.margin == y.margin);
  is_eq = is_eq && (x.scale_margin == y.scale_margin);
  is_eq = is_eq && (x.x_axis_scale_factor == y.x_axis_scale_factor);
  is_eq = is_eq && (x.symbol_size_scale == y.symbol_size_scale);
  is_eq = is_eq && (x.floor_plan_rotation == y.floor_plan_rotation);
  is_eq = is_eq && (x.floor_plan_orbit_scale == y.floor_plan_orbit_scale);
  is_eq = is_eq && is_all_equal(x.box, y.box);
  is_eq = is_eq && (x.ix_branch == y.ix_branch);
  is_eq = is_eq && (x.ix_universe == y.ix_universe);
  is_eq = is_eq && (x.clip == y.clip);
  is_eq = is_eq && (x.valid == y.valid);
  is_eq = is_eq && (x.y2_mirrors_y == y.y2_mirrors_y);
  is_eq = is_eq && (x.limited == y.limited);
  is_eq = is_eq && (x.draw_axes == y.draw_axes);
  is_eq = is_eq && (x.correct_xy_distortion == y.correct_xy_distortion);
  is_eq = is_eq && (x.floor_plan_size_is_absolute == y.floor_plan_size_is_absolute);
  is_eq = is_eq && (x.floor_plan_draw_only_first_pass == y.floor_plan_draw_only_first_pass);
  is_eq = is_eq && (x.draw_curve_legend == y.draw_curve_legend);
  is_eq = is_eq && (x.draw_grid == y.draw_grid);
  is_eq = is_eq && (x.allow_wrap_around == y.allow_wrap_around);
  is_eq = is_eq && (x.draw_only_good_user_data_or_vars == y.draw_only_good_user_data_or_vars);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_graph_ARRAY&, const CPP_tao_graph_ARRAY&);
template bool is_all_equal (const CPP_tao_graph_MATRIX&, const CPP_tao_graph_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_plot& x, const CPP_tao_plot& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.description == y.description);
  is_eq = is_eq && is_all_equal(x.graph, y.graph);
  is_eq = is_eq && (x.x == y.x);
  is_eq = is_eq && (x.n_curve_pts == y.n_curve_pts);
  is_eq = is_eq && (x.type == y.type);
  is_eq = is_eq && (x.x_axis_type == y.x_axis_type);
  is_eq = is_eq && (x.autoscale_x == y.autoscale_x);
  is_eq = is_eq && (x.autoscale_y == y.autoscale_y);
  is_eq = is_eq && (x.autoscale_gang_x == y.autoscale_gang_x);
  is_eq = is_eq && (x.autoscale_gang_y == y.autoscale_gang_y);
  is_eq = is_eq && (x.list_with_show_plot_command == y.list_with_show_plot_command);
  is_eq = is_eq && (x.phantom == y.phantom);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_plot_ARRAY&, const CPP_tao_plot_ARRAY&);
template bool is_all_equal (const CPP_tao_plot_MATRIX&, const CPP_tao_plot_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_plot_region& x, const CPP_tao_plot_region& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.plot == y.plot);
  is_eq = is_eq && is_all_equal(x.location, y.location);
  is_eq = is_eq && (x.visible == y.visible);
  is_eq = is_eq && (x.list_with_show_plot_command == y.list_with_show_plot_command);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_plot_region_ARRAY&, const CPP_tao_plot_region_ARRAY&);
template bool is_all_equal (const CPP_tao_plot_region_MATRIX&, const CPP_tao_plot_region_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_plot_page& x, const CPP_tao_plot_page& y) {
  bool is_eq = true;
  is_eq = is_eq && is_all_equal(x.title, y.title);
  is_eq = is_eq && (x.border == y.border);
  is_eq = is_eq && (x.floor_plan == y.floor_plan);
  is_eq = is_eq && (x.lat_layout == y.lat_layout);
  is_eq = is_eq && is_all_equal(x.pattern, y.pattern);
  is_eq = is_eq && is_all_equal(x.plot_template, y.plot_template);
  is_eq = is_eq && is_all_equal(x.region, y.region);
  is_eq = is_eq && (x.plot_display_type == y.plot_display_type);
  is_eq = is_eq && (x.ps_scale == y.ps_scale);
  is_eq = is_eq && is_all_equal(x.size, y.size);
  is_eq = is_eq && (x.text_height == y.text_height);
  is_eq = is_eq && (x.main_title_text_scale == y.main_title_text_scale);
  is_eq = is_eq && (x.graph_title_text_scale == y.graph_title_text_scale);
  is_eq = is_eq && (x.axis_number_text_scale == y.axis_number_text_scale);
  is_eq = is_eq && (x.axis_label_text_scale == y.axis_label_text_scale);
  is_eq = is_eq && (x.legend_text_scale == y.legend_text_scale);
  is_eq = is_eq && (x.key_table_text_scale == y.key_table_text_scale);
  is_eq = is_eq && (x.curve_legend_line_len == y.curve_legend_line_len);
  is_eq = is_eq && (x.curve_legend_text_offset == y.curve_legend_text_offset);
  is_eq = is_eq && (x.floor_plan_shape_scale == y.floor_plan_shape_scale);
  is_eq = is_eq && (x.lat_layout_shape_scale == y.lat_layout_shape_scale);
  is_eq = is_eq && (x.n_curve_pts == y.n_curve_pts);
  is_eq = is_eq && (x.id_window == y.id_window);
  is_eq = is_eq && (x.delete_overlapping_plots == y.delete_overlapping_plots);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_plot_page_ARRAY&, const CPP_tao_plot_page_ARRAY&);
template bool is_all_equal (const CPP_tao_plot_page_MATRIX&, const CPP_tao_plot_page_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_plot_array& x, const CPP_tao_plot_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_plot_array_ARRAY&, const CPP_tao_plot_array_ARRAY&);
template bool is_all_equal (const CPP_tao_plot_array_MATRIX&, const CPP_tao_plot_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_graph_array& x, const CPP_tao_graph_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_graph_array_ARRAY&, const CPP_tao_graph_array_ARRAY&);
template bool is_all_equal (const CPP_tao_graph_array_MATRIX&, const CPP_tao_graph_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_curve_array& x, const CPP_tao_curve_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_curve_array_ARRAY&, const CPP_tao_curve_array_ARRAY&);
template bool is_all_equal (const CPP_tao_curve_array_MATRIX&, const CPP_tao_curve_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_data& x, const CPP_tao_data& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.ele_name == y.ele_name);
  is_eq = is_eq && (x.ele_start_name == y.ele_start_name);
  is_eq = is_eq && (x.ele_ref_name == y.ele_ref_name);
  is_eq = is_eq && (x.data_type == y.data_type);
  is_eq = is_eq && (x.merit_type == y.merit_type);
  is_eq = is_eq && (x.data_source == y.data_source);
  is_eq = is_eq && (x.ix_bunch == y.ix_bunch);
  is_eq = is_eq && (x.ix_branch == y.ix_branch);
  is_eq = is_eq && (x.ix_ele == y.ix_ele);
  is_eq = is_eq && (x.ix_ele_start == y.ix_ele_start);
  is_eq = is_eq && (x.ix_ele_ref == y.ix_ele_ref);
  is_eq = is_eq && (x.ix_ele_merit == y.ix_ele_merit);
  is_eq = is_eq && (x.ix_d1 == y.ix_d1);
  is_eq = is_eq && (x.ix_data == y.ix_data);
  is_eq = is_eq && (x.ix_dmodel == y.ix_dmodel);
  is_eq = is_eq && (x.eval_point == y.eval_point);
  is_eq = is_eq && (x.meas_value == y.meas_value);
  is_eq = is_eq && (x.ref_value == y.ref_value);
  is_eq = is_eq && (x.model_value == y.model_value);
  is_eq = is_eq && (x.design_value == y.design_value);
  is_eq = is_eq && (x.old_value == y.old_value);
  is_eq = is_eq && (x.base_value == y.base_value);
  is_eq = is_eq && (x.delta_merit == y.delta_merit);
  is_eq = is_eq && (x.weight == y.weight);
  is_eq = is_eq && (x.invalid_value == y.invalid_value);
  is_eq = is_eq && (x.merit == y.merit);
  is_eq = is_eq && (x.s == y.s);
  is_eq = is_eq && (x.s_offset == y.s_offset);
  is_eq = is_eq && (x.exists == y.exists);
  is_eq = is_eq && (x.good_model == y.good_model);
  is_eq = is_eq && (x.good_base == y.good_base);
  is_eq = is_eq && (x.good_design == y.good_design);
  is_eq = is_eq && (x.good_meas == y.good_meas);
  is_eq = is_eq && (x.good_ref == y.good_ref);
  is_eq = is_eq && (x.good_user == y.good_user);
  is_eq = is_eq && (x.good_opt == y.good_opt);
  is_eq = is_eq && (x.good_plot == y.good_plot);
  is_eq = is_eq && (x.useit_plot == y.useit_plot);
  is_eq = is_eq && (x.useit_opt == y.useit_opt);
  is_eq = is_eq && is_all_equal(x.stack, y.stack);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_data_ARRAY&, const CPP_tao_data_ARRAY&);
template bool is_all_equal (const CPP_tao_data_MATRIX&, const CPP_tao_data_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_d1_data& x, const CPP_tao_d1_data& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_d1_data_ARRAY&, const CPP_tao_d1_data_ARRAY&);
template bool is_all_equal (const CPP_tao_d1_data_MATRIX&, const CPP_tao_d1_data_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_d2_data& x, const CPP_tao_d2_data& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.data_file_name == y.data_file_name);
  is_eq = is_eq && (x.ref_file_name == y.ref_file_name);
  is_eq = is_eq && (x.data_date == y.data_date);
  is_eq = is_eq && (x.ref_date == y.ref_date);
  is_eq = is_eq && is_all_equal(x.descrip, y.descrip);
  is_eq = is_eq && is_all_equal(x.d1, y.d1);
  is_eq = is_eq && (x.ix_uni == y.ix_uni);
  is_eq = is_eq && (x.ix_d2_data == y.ix_d2_data);
  is_eq = is_eq && (x.ix_data == y.ix_data);
  is_eq = is_eq && (x.ix_ref == y.ix_ref);
  is_eq = is_eq && (x.data_read_in == y.data_read_in);
  is_eq = is_eq && (x.ref_read_in == y.ref_read_in);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_d2_data_ARRAY&, const CPP_tao_d2_data_ARRAY&);
template bool is_all_equal (const CPP_tao_d2_data_MATRIX&, const CPP_tao_d2_data_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_data_array& x, const CPP_tao_data_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_data_array_ARRAY&, const CPP_tao_data_array_ARRAY&);
template bool is_all_equal (const CPP_tao_data_array_MATRIX&, const CPP_tao_data_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_d1_data_array& x, const CPP_tao_d1_data_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_d1_data_array_ARRAY&, const CPP_tao_d1_data_array_ARRAY&);
template bool is_all_equal (const CPP_tao_d1_data_array_MATRIX&, const CPP_tao_d1_data_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_d2_data_array& x, const CPP_tao_d2_data_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_d2_data_array_ARRAY&, const CPP_tao_d2_data_array_ARRAY&);
template bool is_all_equal (const CPP_tao_d2_data_array_MATRIX&, const CPP_tao_d2_data_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_var_slave& x, const CPP_tao_var_slave& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.ix_uni == y.ix_uni);
  is_eq = is_eq && (x.ix_branch == y.ix_branch);
  is_eq = is_eq && (x.ix_ele == y.ix_ele);
  is_eq = is_eq && ((x.model_value == NULL) == (y.model_value == NULL));
  if (!is_eq) return false;
  if (x.model_value != NULL) is_eq = (*x.model_value == *y.model_value);
  is_eq = is_eq && ((x.base_value == NULL) == (y.base_value == NULL));
  if (!is_eq) return false;
  if (x.base_value != NULL) is_eq = (*x.base_value == *y.base_value);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_var_slave_ARRAY&, const CPP_tao_var_slave_ARRAY&);
template bool is_all_equal (const CPP_tao_var_slave_MATRIX&, const CPP_tao_var_slave_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_var& x, const CPP_tao_var& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.ele_name == y.ele_name);
  is_eq = is_eq && (x.attrib_name == y.attrib_name);
  is_eq = is_eq && is_all_equal(x.slave, y.slave);
  is_eq = is_eq && (x.common_slave == y.common_slave);
  is_eq = is_eq && (x.ix_v1 == y.ix_v1);
  is_eq = is_eq && (x.ix_var == y.ix_var);
  is_eq = is_eq && (x.ix_dvar == y.ix_dvar);
  is_eq = is_eq && (x.ix_attrib == y.ix_attrib);
  is_eq = is_eq && (x.ix_key_table == y.ix_key_table);
  is_eq = is_eq && (x.design_value == y.design_value);
  is_eq = is_eq && (x.scratch_value == y.scratch_value);
  is_eq = is_eq && (x.old_value == y.old_value);
  is_eq = is_eq && (x.meas_value == y.meas_value);
  is_eq = is_eq && (x.ref_value == y.ref_value);
  is_eq = is_eq && (x.correction_value == y.correction_value);
  is_eq = is_eq && (x.high_lim == y.high_lim);
  is_eq = is_eq && (x.low_lim == y.low_lim);
  is_eq = is_eq && (x.step == y.step);
  is_eq = is_eq && (x.weight == y.weight);
  is_eq = is_eq && (x.delta_merit == y.delta_merit);
  is_eq = is_eq && (x.merit == y.merit);
  is_eq = is_eq && (x.dmerit_dvar == y.dmerit_dvar);
  is_eq = is_eq && (x.key_val0 == y.key_val0);
  is_eq = is_eq && (x.key_delta == y.key_delta);
  is_eq = is_eq && (x.s == y.s);
  is_eq = is_eq && (x.merit_type == y.merit_type);
  is_eq = is_eq && (x.exists == y.exists);
  is_eq = is_eq && (x.good_var == y.good_var);
  is_eq = is_eq && (x.good_user == y.good_user);
  is_eq = is_eq && (x.good_opt == y.good_opt);
  is_eq = is_eq && (x.good_plot == y.good_plot);
  is_eq = is_eq && (x.useit_opt == y.useit_opt);
  is_eq = is_eq && (x.useit_plot == y.useit_plot);
  is_eq = is_eq && (x.key_bound == y.key_bound);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_var_ARRAY&, const CPP_tao_var_ARRAY&);
template bool is_all_equal (const CPP_tao_var_MATRIX&, const CPP_tao_var_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_v1_var& x, const CPP_tao_v1_var& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.ix_v1_var == y.ix_v1_var);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_v1_var_ARRAY&, const CPP_tao_v1_var_ARRAY&);
template bool is_all_equal (const CPP_tao_v1_var_MATRIX&, const CPP_tao_v1_var_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_var_array& x, const CPP_tao_var_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_var_array_ARRAY&, const CPP_tao_var_array_ARRAY&);
template bool is_all_equal (const CPP_tao_var_array_MATRIX&, const CPP_tao_var_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_v1_var_array& x, const CPP_tao_v1_var_array& y) {
  bool is_eq = true;
  return is_eq;
};

template bool is_all_equal (const CPP_tao_v1_var_array_ARRAY&, const CPP_tao_v1_var_array_ARRAY&);
template bool is_all_equal (const CPP_tao_v1_var_array_MATRIX&, const CPP_tao_v1_var_array_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_building_wall_point& x, const CPP_tao_building_wall_point& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.z == y.z);
  is_eq = is_eq && (x.x == y.x);
  is_eq = is_eq && (x.radius == y.radius);
  is_eq = is_eq && (x.z_center == y.z_center);
  is_eq = is_eq && (x.x_center == y.x_center);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_building_wall_point_ARRAY&, const CPP_tao_building_wall_point_ARRAY&);
template bool is_all_equal (const CPP_tao_building_wall_point_MATRIX&, const CPP_tao_building_wall_point_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_building_wall_section& x, const CPP_tao_building_wall_section& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.constraint == y.constraint);
  is_eq = is_eq && is_all_equal(x.point, y.point);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_building_wall_section_ARRAY&, const CPP_tao_building_wall_section_ARRAY&);
template bool is_all_equal (const CPP_tao_building_wall_section_MATRIX&, const CPP_tao_building_wall_section_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_building_wall& x, const CPP_tao_building_wall& y) {
  bool is_eq = true;
  is_eq = is_eq && is_all_equal(x.section, y.section);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_building_wall_ARRAY&, const CPP_tao_building_wall_ARRAY&);
template bool is_all_equal (const CPP_tao_building_wall_MATRIX&, const CPP_tao_building_wall_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_global& x, const CPP_tao_global& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.y_axis_plot_dmin == y.y_axis_plot_dmin);
  is_eq = is_eq && (x.lm_opt_deriv_reinit == y.lm_opt_deriv_reinit);
  is_eq = is_eq && (x.de_lm_step_ratio == y.de_lm_step_ratio);
  is_eq = is_eq && (x.de_var_to_population_factor == y.de_var_to_population_factor);
  is_eq = is_eq && (x.lmdif_eps == y.lmdif_eps);
  is_eq = is_eq && (x.svd_cutoff == y.svd_cutoff);
  is_eq = is_eq && (x.unstable_penalty == y.unstable_penalty);
  is_eq = is_eq && (x.merit_stop_value == y.merit_stop_value);
  is_eq = is_eq && (x.random_sigma_cutoff == y.random_sigma_cutoff);
  is_eq = is_eq && (x.delta_e_chrom == y.delta_e_chrom);
  is_eq = is_eq && (x.n_opti_cycles == y.n_opti_cycles);
  is_eq = is_eq && (x.n_opti_loops == y.n_opti_loops);
  is_eq = is_eq && (x.phase_units == y.phase_units);
  is_eq = is_eq && (x.bunch_to_plot == y.bunch_to_plot);
  is_eq = is_eq && (x.random_seed == y.random_seed);
  is_eq = is_eq && (x.n_top10 == y.n_top10);
  is_eq = is_eq && (x.random_engine == y.random_engine);
  is_eq = is_eq && (x.random_gauss_converter == y.random_gauss_converter);
  is_eq = is_eq && (x.track_type == y.track_type);
  is_eq = is_eq && (x.prompt_string == y.prompt_string);
  is_eq = is_eq && (x.prompt_color == y.prompt_color);
  is_eq = is_eq && (x.optimizer == y.optimizer);
  is_eq = is_eq && (x.print_command == y.print_command);
  is_eq = is_eq && (x.var_out_file == y.var_out_file);
  is_eq = is_eq && (x.initialized == y.initialized);
  is_eq = is_eq && (x.opt_with_ref == y.opt_with_ref);
  is_eq = is_eq && (x.opt_with_base == y.opt_with_base);
  is_eq = is_eq && (x.label_lattice_elements == y.label_lattice_elements);
  is_eq = is_eq && (x.label_keys == y.label_keys);
  is_eq = is_eq && (x.derivative_recalc == y.derivative_recalc);
  is_eq = is_eq && (x.derivative_uses_design == y.derivative_uses_design);
  is_eq = is_eq && (x.init_plot_needed == y.init_plot_needed);
  is_eq = is_eq && (x.orm_analysis == y.orm_analysis);
  is_eq = is_eq && (x.plot_on == y.plot_on);
  is_eq = is_eq && (x.lattice_calc_on == y.lattice_calc_on);
  is_eq = is_eq && (x.svd_retreat_on_merit_increase == y.svd_retreat_on_merit_increase);
  is_eq = is_eq && (x.stop_on_error == y.stop_on_error);
  is_eq = is_eq && (x.command_file_print_on == y.command_file_print_on);
  is_eq = is_eq && (x.box_plots == y.box_plots);
  is_eq = is_eq && (x.beam_timer_on == y.beam_timer_on);
  is_eq = is_eq && (x.var_limits_on == y.var_limits_on);
  is_eq = is_eq && (x.only_limit_opt_vars == y.only_limit_opt_vars);
  is_eq = is_eq && (x.optimizer_var_limit_warn == y.optimizer_var_limit_warn);
  is_eq = is_eq && (x.rf_on == y.rf_on);
  is_eq = is_eq && (x.draw_curve_off_scale_warn == y.draw_curve_off_scale_warn);
  is_eq = is_eq && (x.wait_for_cr_in_single_mode == y.wait_for_cr_in_single_mode);
  is_eq = is_eq && (x.disable_smooth_line_calc == y.disable_smooth_line_calc);
  is_eq = is_eq && (x.debug_on == y.debug_on);
  is_eq = is_eq && (x.single_step == y.single_step);
  is_eq = is_eq && (x.optimizer_allow_user_abort == y.optimizer_allow_user_abort);
  is_eq = is_eq && (x.quiet == y.quiet);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_global_ARRAY&, const CPP_tao_global_ARRAY&);
template bool is_all_equal (const CPP_tao_global_MATRIX&, const CPP_tao_global_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_alias& x, const CPP_tao_alias& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.expanded_str == y.expanded_str);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_alias_ARRAY&, const CPP_tao_alias_ARRAY&);
template bool is_all_equal (const CPP_tao_alias_MATRIX&, const CPP_tao_alias_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_command_file& x, const CPP_tao_command_file& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.name == y.name);
  is_eq = is_eq && (x.ix_unit == y.ix_unit);
  is_eq = is_eq && is_all_equal(x.cmd_arg, y.cmd_arg);
  is_eq = is_eq && (x.paused == y.paused);
  is_eq = is_eq && (x.n_line == y.n_line);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_command_file_ARRAY&, const CPP_tao_command_file_ARRAY&);
template bool is_all_equal (const CPP_tao_command_file_MATRIX&, const CPP_tao_command_file_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_common& x, const CPP_tao_common& y) {
  bool is_eq = true;
  is_eq = is_eq && is_all_equal(x.alias, y.alias);
  is_eq = is_eq && is_all_equal(x.key, y.key);
  is_eq = is_eq && is_all_equal(x.cmd_file, y.cmd_file);
  is_eq = is_eq && is_all_equal(x.covar, y.covar);
  is_eq = is_eq && is_all_equal(x.alpha, y.alpha);
  is_eq = is_eq && (x.dummy_target == y.dummy_target);
  is_eq = is_eq && (x.ix_ref_taylor == y.ix_ref_taylor);
  is_eq = is_eq && (x.ix_ele_taylor == y.ix_ele_taylor);
  is_eq = is_eq && (x.n_alias == y.n_alias);
  is_eq = is_eq && (x.cmd_file_level == y.cmd_file_level);
  is_eq = is_eq && (x.ix_key_bank == y.ix_key_bank);
  is_eq = is_eq && (x.n_universes == y.n_universes);
  is_eq = is_eq && (x.default_universe == y.default_universe);
  is_eq = is_eq && (x.default_branch == y.default_branch);
  is_eq = is_eq && (x.ix_history == y.ix_history);
  is_eq = is_eq && (x.n_history == y.n_history);
  is_eq = is_eq && (x.cmd_file_paused == y.cmd_file_paused);
  is_eq = is_eq && (x.use_cmd_here == y.use_cmd_here);
  is_eq = is_eq && (x.multi_commands_here == y.multi_commands_here);
  is_eq = is_eq && (x.cmd_from_cmd_file == y.cmd_from_cmd_file);
  is_eq = is_eq && (x.use_saved_beam_in_tracking == y.use_saved_beam_in_tracking);
  is_eq = is_eq && (x.single_mode == y.single_mode);
  is_eq = is_eq && (x.combine_consecutive_elements_of_like_name == y.combine_consecutive_elements_of_like_name);
  is_eq = is_eq && (x.common_lattice == y.common_lattice);
  is_eq = is_eq && (x.init_beam == y.init_beam);
  is_eq = is_eq && (x.init_var == y.init_var);
  is_eq = is_eq && (x.init_read_lat_info == y.init_read_lat_info);
  is_eq = is_eq && (x.init_data == y.init_data);
  is_eq = is_eq && (x.parse_cmd_args == y.parse_cmd_args);
  is_eq = is_eq && (x.optimizer_running == y.optimizer_running);
  is_eq = is_eq && (x.have_datums_using_expressions == y.have_datums_using_expressions);
  is_eq = is_eq && (x.noplot_arg_set == y.noplot_arg_set);
  is_eq = is_eq && (x.init_tao_file_arg_set == y.init_tao_file_arg_set);
  is_eq = is_eq && (x.log_startup == y.log_startup);
  is_eq = is_eq && (x.print_to_terminal == y.print_to_terminal);
  is_eq = is_eq && (x.cmd == y.cmd);
  is_eq = is_eq && (x.init_name == y.init_name);
  is_eq = is_eq && (x.lat_file == y.lat_file);
  is_eq = is_eq && (x.init_tao_file == y.init_tao_file);
  is_eq = is_eq && (x.init_tao_file_path == y.init_tao_file_path);
  is_eq = is_eq && (x.beam_file == y.beam_file);
  is_eq = is_eq && (x.beam_all_file == y.beam_all_file);
  is_eq = is_eq && (x.beam0_file == y.beam0_file);
  is_eq = is_eq && (x.data_file == y.data_file);
  is_eq = is_eq && (x.plot_file == y.plot_file);
  is_eq = is_eq && (x.startup_file == y.startup_file);
  is_eq = is_eq && (x.var_file == y.var_file);
  is_eq = is_eq && (x.building_wall_file == y.building_wall_file);
  is_eq = is_eq && (x.hook_init_file == y.hook_init_file);
  is_eq = is_eq && (x.plot_geometry == y.plot_geometry);
  is_eq = is_eq && (x.single_mode_buffer == y.single_mode_buffer);
  is_eq = is_eq && (x.unique_name_suffix == y.unique_name_suffix);
  is_eq = is_eq && is_all_equal(x.valid_plot_who, y.valid_plot_who);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_common_ARRAY&, const CPP_tao_common_ARRAY&);
template bool is_all_equal (const CPP_tao_common_MATRIX&, const CPP_tao_common_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_lat_mode& x, const CPP_tao_lat_mode& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.chrom == y.chrom);
  is_eq = is_eq && (x.growth_rate == y.growth_rate);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_lat_mode_ARRAY&, const CPP_tao_lat_mode_ARRAY&);
template bool is_all_equal (const CPP_tao_lat_mode_MATRIX&, const CPP_tao_lat_mode_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_sigma_mat& x, const CPP_tao_sigma_mat& y) {
  bool is_eq = true;
  is_eq = is_eq && is_all_equal(x.sigma, y.sigma);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_sigma_mat_ARRAY&, const CPP_tao_sigma_mat_ARRAY&);
template bool is_all_equal (const CPP_tao_sigma_mat_MATRIX&, const CPP_tao_sigma_mat_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_lattice_branch& x, const CPP_tao_lattice_branch& y) {
  bool is_eq = true;
  is_eq = is_eq && is_all_equal(x.bunch_params, y.bunch_params);
  is_eq = is_eq && is_all_equal(x.linear, y.linear);
  is_eq = is_eq && is_all_equal(x.orbit, y.orbit);
  is_eq = is_eq && (x.orb0 == y.orb0);
  is_eq = is_eq && (x.high_e_lat == y.high_e_lat);
  is_eq = is_eq && (x.low_e_lat == y.low_e_lat);
  is_eq = is_eq && (x.track_state == y.track_state);
  is_eq = is_eq && (x.has_open_match_element == y.has_open_match_element);
  is_eq = is_eq && (x.modes == y.modes);
  is_eq = is_eq && (x.rad_int == y.rad_int);
  is_eq = is_eq && (x.a == y.a);
  is_eq = is_eq && (x.b == y.b);
  is_eq = is_eq && (x.ix_rad_int_cache == y.ix_rad_int_cache);
  is_eq = is_eq && (x.modes_rf_on == y.modes_rf_on);
  is_eq = is_eq && (x.rad_int_rf_on == y.rad_int_rf_on);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_lattice_branch_ARRAY&, const CPP_tao_lattice_branch_ARRAY&);
template bool is_all_equal (const CPP_tao_lattice_branch_MATRIX&, const CPP_tao_lattice_branch_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_lattice& x, const CPP_tao_lattice& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.lat == y.lat);
  is_eq = is_eq && is_all_equal(x.tao_branch, y.tao_branch);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_lattice_ARRAY&, const CPP_tao_lattice_ARRAY&);
template bool is_all_equal (const CPP_tao_lattice_MATRIX&, const CPP_tao_lattice_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_element& x, const CPP_tao_element& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.beam == y.beam);
  is_eq = is_eq && (x.save_beam == y.save_beam);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_element_ARRAY&, const CPP_tao_element_ARRAY&);
template bool is_all_equal (const CPP_tao_element_MATRIX&, const CPP_tao_element_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_ping_scale& x, const CPP_tao_ping_scale& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.a_mode_meas == y.a_mode_meas);
  is_eq = is_eq && (x.a_mode_ref == y.a_mode_ref);
  is_eq = is_eq && (x.b_mode_meas == y.b_mode_meas);
  is_eq = is_eq && (x.b_mode_ref == y.b_mode_ref);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_ping_scale_ARRAY&, const CPP_tao_ping_scale_ARRAY&);
template bool is_all_equal (const CPP_tao_ping_scale_MATRIX&, const CPP_tao_ping_scale_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_universe_branch& x, const CPP_tao_universe_branch& y) {
  bool is_eq = true;
  is_eq = is_eq && is_all_equal(x.ele, y.ele);
  is_eq = is_eq && (x.track_start == y.track_start);
  is_eq = is_eq && (x.track_end == y.track_end);
  is_eq = is_eq && (x.ix_track_start == y.ix_track_start);
  is_eq = is_eq && (x.ix_track_end == y.ix_track_end);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_universe_branch_ARRAY&, const CPP_tao_universe_branch_ARRAY&);
template bool is_all_equal (const CPP_tao_universe_branch_MATRIX&, const CPP_tao_universe_branch_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_beam& x, const CPP_tao_beam& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.beam_init == y.beam_init);
  is_eq = is_eq && (x.start == y.start);
  is_eq = is_eq && (x.init_beam0 == y.init_beam0);
  is_eq = is_eq && (x.beam_all_file == y.beam_all_file);
  is_eq = is_eq && (x.beam0_file == y.beam0_file);
  is_eq = is_eq && (x.saved_at == y.saved_at);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_beam_ARRAY&, const CPP_tao_beam_ARRAY&);
template bool is_all_equal (const CPP_tao_beam_MATRIX&, const CPP_tao_beam_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_universe_calc& x, const CPP_tao_universe_calc& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.rad_int_for_data == y.rad_int_for_data);
  is_eq = is_eq && (x.rad_int_for_plotting == y.rad_int_for_plotting);
  is_eq = is_eq && (x.chrom_for_data == y.chrom_for_data);
  is_eq = is_eq && (x.chrom_for_plotting == y.chrom_for_plotting);
  is_eq = is_eq && (x.beam_sigma_for_data == y.beam_sigma_for_data);
  is_eq = is_eq && (x.beam_sigma_for_plotting == y.beam_sigma_for_plotting);
  is_eq = is_eq && (x.dynamic_aperture == y.dynamic_aperture);
  is_eq = is_eq && (x.one_turn_map == y.one_turn_map);
  is_eq = is_eq && (x.lattice == y.lattice);
  is_eq = is_eq && (x.mat6 == y.mat6);
  is_eq = is_eq && (x.track == y.track);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_universe_calc_ARRAY&, const CPP_tao_universe_calc_ARRAY&);
template bool is_all_equal (const CPP_tao_universe_calc_MATRIX&, const CPP_tao_universe_calc_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_mpi& x, const CPP_tao_mpi& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.on == y.on);
  is_eq = is_eq && (x.master == y.master);
  is_eq = is_eq && (x.rank == y.rank);
  is_eq = is_eq && (x.max_rank == y.max_rank);
  is_eq = is_eq && (x.host_name == y.host_name);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_mpi_ARRAY&, const CPP_tao_mpi_ARRAY&);
template bool is_all_equal (const CPP_tao_mpi_MATRIX&, const CPP_tao_mpi_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_dynamic_aperture& x, const CPP_tao_dynamic_aperture& y) {
  bool is_eq = true;
  is_eq = is_eq && is_all_equal(x.scan, y.scan);
  is_eq = is_eq && is_all_equal(x.pz, y.pz);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_dynamic_aperture_ARRAY&, const CPP_tao_dynamic_aperture_ARRAY&);
template bool is_all_equal (const CPP_tao_dynamic_aperture_MATRIX&, const CPP_tao_dynamic_aperture_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_universe& x, const CPP_tao_universe& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.beam == y.beam);
  is_eq = is_eq && (x.dynamic_aperture == y.dynamic_aperture);
  is_eq = is_eq && is_all_equal(x.d2_data, y.d2_data);
  is_eq = is_eq && is_all_equal(x.data, y.data);
  is_eq = is_eq && (x.ping_scale == y.ping_scale);
  is_eq = is_eq && (x.scratch_lat == y.scratch_lat);
  is_eq = is_eq && (x.calc == y.calc);
  is_eq = is_eq && is_all_equal(x.dmodel_dvar, y.dmodel_dvar);
  is_eq = is_eq && (x.ix_uni == y.ix_uni);
  is_eq = is_eq && (x.n_d2_data_used == y.n_d2_data_used);
  is_eq = is_eq && (x.n_data_used == y.n_data_used);
  is_eq = is_eq && (x.reverse_tracking == y.reverse_tracking);
  is_eq = is_eq && (x.is_on == y.is_on);
  is_eq = is_eq && (x.picked_uni == y.picked_uni);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_universe_ARRAY&, const CPP_tao_universe_ARRAY&);
template bool is_all_equal (const CPP_tao_universe_MATRIX&, const CPP_tao_universe_MATRIX&);

//--------------------------------------------------------------

bool operator== (const CPP_tao_super_universe& x, const CPP_tao_super_universe& y) {
  bool is_eq = true;
  is_eq = is_eq && (x.global == y.global);
  is_eq = is_eq && (x.com == y.com);
  is_eq = is_eq && (x.plot_page == y.plot_page);
  is_eq = is_eq && is_all_equal(x.v1_var, y.v1_var);
  is_eq = is_eq && is_all_equal(x.var, y.var);
  is_eq = is_eq && is_all_equal(x.u, y.u);
  is_eq = is_eq && (x.mpi == y.mpi);
  is_eq = is_eq && is_all_equal(x.key, y.key);
  is_eq = is_eq && (x.building_wall == y.building_wall);
  is_eq = is_eq && (x.wave == y.wave);
  is_eq = is_eq && (x.n_var_used == y.n_var_used);
  is_eq = is_eq && (x.n_v1_var_used == y.n_v1_var_used);
  is_eq = is_eq && is_all_equal(x.history, y.history);
  return is_eq;
};

template bool is_all_equal (const CPP_tao_super_universe_ARRAY&, const CPP_tao_super_universe_ARRAY&);
template bool is_all_equal (const CPP_tao_super_universe_MATRIX&, const CPP_tao_super_universe_MATRIX&);