// Get accuracy of the predicted results
float accuracy(const array& predicted, const array& target)
{
    return 100 * count<float>(predicted == target) / target.elements();
}

 array::array(const array& in) : arr(0), isRef(false)
 {
     AF_THROW(af_weak_copy(&arr, in.get()));
 }

constexpr bool operator<(array<T, M> a, array<U, N> b) {
    return M < N || detail::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
}

inline void swap (array<T,N>& x, array<T,N>& y) {
    x.swap(y);
}

	void stack_push_back_value( array<as_value> & stack, T value )
	{
		stack.push_back( value );
	}

array rgb2ycbcr(const array& in, const YCCStd standard) {
    af_array temp = 0;
    AF_THROW(af_rgb2ycbcr(&temp, in.get(), standard));
    return array(temp);
}

bool operator== (const array<T,N>& x, const array<T,N>& y) {
    return std::equal(x.begin(), x.end(), y.begin());
}

template<> AFAPI af_cdouble var(const array& in, const array weights)
{
    double real, imag;
    AF_THROW(af_var_all_weighted(&real, &imag, in.get(), weights.get()));
    return std::complex<double>(real, imag);
}

void print(const array<T,N>& a)
{
	for (size_t i=0; i!=a.size(); ++i)
		cout << a[i] << '\n';
}

 explicit array(const array<U, N>& that) {
   std::uninitialized_copy(that.begin(), that.end(), begin());
 }

 void swap(array<U, N>& that) {
   swap_ranges(begin(), end(), that.begin());
 }

float abserr(const array& predicted, const array& target)
{
    return 100 * sum<float>(abs(predicted - target)) / predicted.elements();
}

bool operator< (const array<T,N>& x, const array<T,N>& y) {
    return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
}

std::size_t hash_value(const array<T,N>& arr)
{
    return boost::hash_range(arr.begin(), arr.end());
}

bool operator!=(const array<T, N>& left, const array<U, N>& right) {
  return !equal(left.begin(), left.end(), right.begin());
}

	void stack_push_back_ref( array<as_value> & stack, T & value )
	{
		stack.push_back( value );
	}

bool operator<(const array<T, M>& left, const array<U, N>& right) {
  return lexicographical_compare(left.begin(), left.end(), right.begin(),
                                 right.end());
}

void Pass::add(PassType type, array<Pass>& passes)
{
	for(size_t i = 0; i < passes.size(); i++)
		if(passes[i].type == type)
			return;

	Pass pass;

	pass.type = type;
	pass.filter = true;
	pass.exposure = false;
	pass.divide_type = PASS_NONE;

	switch(type) {
		case PASS_NONE:
			pass.components = 0;
			break;
		case PASS_COMBINED:
			pass.components = 4;
			pass.exposure = true;
			break;
		case PASS_DEPTH:
			pass.components = 1;
			pass.filter = false;
			break;
		case PASS_MIST:
			pass.components = 1;
			break;
		case PASS_NORMAL:
			pass.components = 4;
			break;
		case PASS_UV:
			pass.components = 4;
			break;
		case PASS_MOTION:
			pass.components = 4;
			pass.divide_type = PASS_MOTION_WEIGHT;
			break;
		case PASS_MOTION_WEIGHT:
			pass.components = 1;
			break;
		case PASS_OBJECT_ID:
		case PASS_MATERIAL_ID:
			pass.components = 1;
			pass.filter = false;
			break;

		case PASS_EMISSION:
		case PASS_BACKGROUND:
			pass.components = 4;
			pass.exposure = true;
			break;
		case PASS_AO:
			pass.components = 4;
			break;
		case PASS_SHADOW:
			pass.components = 4;
			pass.exposure = false;
			break;
		case PASS_LIGHT:
			/* This isn't a real pass, used by baking to see whether
			 * light data is needed or not.
			 *
			 * Set components to 0 so pass sort below happens in a
			 * determined way.
			 */
			pass.components = 0;
			break;
#ifdef WITH_CYCLES_DEBUG
		case PASS_BVH_TRAVERSED_NODES:
		case PASS_BVH_TRAVERSED_INSTANCES:
		case PASS_BVH_INTERSECTIONS:
		case PASS_RAY_BOUNCES:
			pass.components = 1;
			pass.exposure = false;
			break;
#endif
		case PASS_RENDER_TIME:
			/* This pass is handled entirely on the host side. */
			pass.components = 0;
			break;

		case PASS_DIFFUSE_COLOR:
		case PASS_GLOSSY_COLOR:
		case PASS_TRANSMISSION_COLOR:
		case PASS_SUBSURFACE_COLOR:
			pass.components = 4;
			break;
		case PASS_DIFFUSE_DIRECT:
		case PASS_DIFFUSE_INDIRECT:
			pass.components = 4;
			pass.exposure = true;
			pass.divide_type = PASS_DIFFUSE_COLOR;
			break;
		case PASS_GLOSSY_DIRECT:
		case PASS_GLOSSY_INDIRECT:
			pass.components = 4;
			pass.exposure = true;
			pass.divide_type = PASS_GLOSSY_COLOR;
			break;
//.........这里部分代码省略.........

 mapped_type val() const {
   return ary_->get_val_at_id(id(), w_, o_, true, false);
 }

 size_t pos() const { return key_.get_bits(0, ary_->lsize()); }