text:
// Boost.Geometry (aka GGL, Generic Geometry Library)

// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.

// This file was modified by Oracle on 2013, 2014.
// Modifications copyright (c) 2013, 2014 Oracle and/or its affiliates.

// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle

#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RESULT_HPP
#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RESULT_HPP

#include <boost/tuple/tuple.hpp>

#include <boost/mpl/is_sequence.hpp>
#include <boost/mpl/begin.hpp>
#include <boost/mpl/end.hpp>
#include <boost/mpl/next.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/vector_c.hpp>

#include <boost/geometry/core/topological_dimension.hpp>

// TEMP - move this header to geometry/detail
#include <boost/geometry/index/detail/tuples.hpp>

namespace boost { namespace geometry {

#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace relate {

enum field { interior = 0, boundary = 1, exterior = 2 };

// TODO: IF THE RESULT IS UPDATED WITH THE MAX POSSIBLE VALUE FOR SOME PAIR OF GEOEMTRIES
// THE VALUE ALREADY STORED MUSN'T BE CHECKED
// update() calls chould be replaced with set() in those cases
// but for safety reasons (STATIC_ASSERT) we should check if parameter D is valid and set() doesn't do that
// so some additional function could be added, e.g. set_dim()

// matrix

// TODO add height?

template <std::size_t Width>
class matrix
{
    BOOST_STATIC_ASSERT(Width == 2 || Width == 3);

public:

    static const std::size_t size = Width * Width;

    inline matrix()
    {
        ::memset(m_array, 'F', size);
    }

    template <field F1, field F2>
    inline char get() const
    {
        static const bool in_bounds = F1 * Width + F2 < size;
        return get_dispatch<F1, F2>(integral_constant<bool, in_bounds>());
    }

    template <field F1, field F2, char V>
    inline void set()
    {
        static const bool in_bounds = F1 * Width + F2 < size;
        set_dispatch<F1, F2, V>(integral_constant<bool, in_bounds>());
    }

    template <field F1, field F2, char D>
    inline void update()
    {
        static const bool in_bounds = F1 * Width + F2 < size;
        update_dispatch<F1, F2, D>(integral_constant<bool, in_bounds>());
    }

    inline const char * data() const
    {
        return m_array;
    }

private:
    template <field F1, field F2>
    inline char get_dispatch(integral_constant<bool, true>) const
    {
        return m_array[F1 * Width + F2];
    }
    template <field F1, field F2>
    inline char get_dispatch(integral_constant<bool, false>) const
    {
        return 'F';
    }

    template <field F1, field F2, char V>
    inline void set_dispatch(integral_constant<bool, true>)
    {
        BOOST_STATIC_ASSERT(('0' <= V && V <= '9') || V == 'T' || V == 'F');
        m_array[F1 * Width + F2] = V;
    }
    template <field F1, field F2, char V>
    inline void set_dispatch(integral_constant<bool, false>)
    {}

    template <field F1, field F2, char D>
    inline void update_dispatch(integral_constant<bool, true>)
    {
        BOOST_STATIC_ASSERT('0' <= D && D <= '9');
        char c = m_array[F1 * Width + F2];
        if ( D > c || c > '9')
            m_array[F1 * Width + F2] = D;
    }
    template <field F1, field F2, char D>
    inline void update_dispatch(integral_constant<bool, false>)
    {}

    char m_array[size];
};

// TODO add EnableDimensions parameter?

struct matrix9 {};
//struct matrix4 {};

// matrix_width

template <typename MatrixOrMask>
struct matrix_width
    : not_implemented<MatrixOrMask>
{};

template <>
struct matrix_width<matrix9>
{
    static const std::size_t value = 3;
};

// matrix_handler

template <typename Matrix>
class matrix_handler
    : private matrix<matrix_width<Matrix>::value>
{
    typedef matrix<matrix_width<Matrix>::value> base_t;

public:
    typedef std::string result_type;

    static const bool interrupt = false;

    matrix_handler(Matrix const&)
    {}

    result_type result() const
    {
        return std::string(this->data(),
                           this->data() + base_t::size);
    }

    template <field F1, field F2, char D>
    inline bool may_update() const
    {
        BOOST_STATIC_ASSERT('0' <= D && D <= '9');

        char const c = static_cast<base_t const&>(*this).template get<F1, F2>();
        return D > c || c > '9';
    }

    //template <field F1, field F2>
    //inline char get() const
    //{
    //    return static_cast<base_t const&>(*this).template get<F1, F2>();
    //}

    template <field F1, field F2, char V>
    inline void set()
    {
        static_cast<base_t&>(*this).template set<F1, F2, V>();
    }

    template <field F1, field F2, char D>
    inline void update()
    {
        static_cast<base_t&>(*this).template update<F1, F2, D>();
    }
};

// RUN-TIME MASKS

// mask9

class mask9
{
public:
    static const std::size_t width = 3; // TEMP

    inline mask9(std::string const& de9im_mask)
    {
        // TODO: throw an exception here?
        BOOST_ASSERT(de9im_mask.size() == 9);
        ::memcpy(m_mask, de9im_mask.c_str(), 9);
    }

    template <field F1, field F2>
    inline char get() const
    {
        return m_mask[F1 * 3 + F2];
    }

private:
    char m_mask[9];
};

// interrupt()

template <typename Mask, bool InterruptEnabled>
struct interrupt_dispatch
{
    template <field F1, field F2, char V>
    static inline bool apply(Mask const&)
    {
        return false;
    }
};

template <typename Mask>
struct interrupt_dispatch<Mask, true>
{
    template <field F1, field F2, char V>
    static inline bool apply(Mask const& mask)
    {
        char m = mask.template get<F1, F2>();
        return check<V>(m);
    }

    template <char V>
    static inline bool check(char m)
    {
        if ( V >= '0' && V <= '9' )
        {
            return m == 'F' || ( m < V && m >= '0' && m <= '9' );
        }
        else if ( V == 'T' )
        {
            return m == 'F';
        }
        return false;
    }
};

template <typename Masks, int I = 0, int N = boost::tuples::length<Masks>::value>
struct interrupt_dispatch_tuple
{
    template <field F1, field F2, char V>
    static inline bool apply(Masks const& masks)
    {
        typedef typename boost::tuples::element<I, Masks>::type mask_type;
        mask_type const& mask = boost::get<I>(masks);
        return interrupt_dispatch<mask_type, true>::template apply<F1, F2, V>(mask)
            && interrupt_dispatch_tuple<Masks, I+1>::template apply<F1, F2, V>(masks);
    }
};

template <typename Masks, int N>
struct interrupt_dispatch_tuple<Masks, N, N>
{
    template <field F1, field F2, char V>
    static inline bool apply(Masks const& )
    {
        return true;
    }
};

template <typename T0, typename T1, typename T2, typename T3, typename T4,
          typename T5, typename T6, typename T7, typename T8, typename T9>
struct interrupt_dispatch<boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, true>
{
    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> mask_type;

    template <field F1, field F2, char V>
    static inline bool apply(mask_type const& mask)
    {
        return interrupt_dispatch_tuple<mask_type>::template apply<F1, F2, V>(mask);
    }
};

template <typename Head, typename Tail>
struct interrupt_dispatch<boost::tuples::cons<Head, Tail>, true>
{
    typedef boost::tuples::cons<Head, Tail> mask_type;

    template <field F1, field F2, char V>
    static inline bool apply(mask_type const& mask)
    {
        return interrupt_dispatch_tuple<mask_type>::template apply<F1, F2, V>(mask);
    }
};

template <field F1, field F2, char V, bool InterruptEnabled, typename Mask>
inline bool interrupt(Mask const& mask)
{
    return interrupt_dispatch<Mask, InterruptEnabled>
                ::template apply<F1, F2, V>(mask);
}

// may_update()

template <typename Mask>
struct may_update_dispatch
{
    template <field F1, field F2, char D, typename Matrix>
    static inline bool apply(Mask const& mask, Matrix const& matrix)
    {
        BOOST_STATIC_ASSERT('0' <= D && D <= '9');

        char const m = mask.template get<F1, F2>();

        if ( m == 'F' )
        {
            return true;
        }
        else if ( m == 'T' )
        {
            char const c = matrix.template get<F1, F2>();
            return c == 'F'; // if it's T or between 0 and 9, the result will be the same
        }
        else if ( m >= '0' && m <= '9' )
        {
            char const c = matrix.template get<F1, F2>();
            return D > c || c > '9';
        }

        return false;
    }
};

template <typename Masks, int I = 0, int N = boost::tuples::length<Masks>::value>
struct may_update_dispatch_tuple
{
    template <field F1, field F2, char D, typename Matrix>
    static inline bool apply(Masks const& masks, Matrix const& matrix)
    {
        typedef typename boost::tuples::element<I, Masks>::type mask_type;
        mask_type const& mask = boost::get<I>(masks);
        return may_update_dispatch<mask_type>::template apply<F1, F2, D>(mask, matrix)
            || may_update_dispatch_tuple<Masks, I+1>::template apply<F1, F2, D>(masks, matrix);
    }
};

template <typename Masks, int N>
struct may_update_dispatch_tuple<Masks, N, N>
{
    template <field F1, field F2, char D, typename Matrix>
    static inline bool apply(Masks const& , Matrix const& )
    {
        return false;
    }
};

template <typename T0, typename T1, typename T2, typename T3, typename T4,
          typename T5, typename T6, typename T7, typename T8, typename T9>
struct may_update_dispatch< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
{
    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> mask_type;

    template <field F1, field F2, char D, typename Matrix>
    static inline bool apply(mask_type const& mask, Matrix const& matrix)
    {
        return may_update_dispatch_tuple<mask_type>::template apply<F1, F2, D>(mask, matrix);
    }
};

template <typename Head, typename Tail>
struct may_update_dispatch< boost::tuples::cons<Head, Tail> >
{
    typedef boost::tuples::cons<Head, Tail> mask_type;

    template <field F1, field F2, char D, typename Matrix>
    static inline bool apply(mask_type const& mask, Matrix const& matrix)
    {
        return may_update_dispatch_tuple<mask_type>::template apply<F1, F2, D>(mask, matrix);
    }
};

template <field F1, field F2, char D, typename Mask, typename Matrix>
inline bool may_update(Mask const& mask, Matrix const& matrix)
{
    return may_update_dispatch<Mask>
                ::template apply<F1, F2, D>(mask, matrix);
}

// check()

template <typename Mask>
struct check_dispatch
{
    template <typename Matrix>
    static inline bool apply(Mask const& mask, Matrix const& matrix)
    {
        return per_one<interior, interior>(mask, matrix)
            && per_one<interior, boundary>(mask, matrix)
            && per_one<interior, exterior>(mask, matrix)
            && per_one<boundary, interior>(mask, matrix)
            && per_one<boundary, boundary>(mask, matrix)
            && per_one<boundary, exterior>(mask, matrix)
            && per_one<exterior, interior>(mask, matrix)
            && per_one<exterior, boundary>(mask, matrix)
            && per_one<exterior, exterior>(mask, matrix);
    }

    template <field F1, field F2, typename Matrix>
    static inline bool per_one(Mask const& mask, Matrix const& matrix)
    {
        const char mask_el = mask.template get<F1, F2>();
        const char el = matrix.template get<F1, F2>();

        if ( mask_el == 'F' )
        {
            return el == 'F';
        }
        else if ( mask_el == 'T' )
        {
            return el == 'T' || ( el >= '0' && el <= '9' );
        }
        else if ( mask_el >= '0' && mask_el <= '9' )
        {
            return el == mask_el;
        }

        return true;
    }
};

template <typename Masks, int I = 0, int N = boost::tuples::length<Masks>::value>
struct check_dispatch_tuple
{
    template <typename Matrix>
    static inline bool apply(Masks const& masks, Matrix const& matrix)
    {
        typedef typename boost::tuples::element<I, Masks>::type mask_type;
        mask_type const& mask = boost::get<I>(masks);
        return check_dispatch<mask_type>::apply(mask, matrix)
            || check_dispatch_tuple<Masks, I+1>::apply(masks, matrix);
    }
};

template <typename Masks, int N>
struct check_dispatch_tuple<Masks, N, N>
{
    template <typename Matrix>
    static inline bool apply(Masks const&, Matrix const&)
    {
        return false;
    }
};

template <typename T0, typename T1, typename T2, typename T3, typename T4,
          typename T5, typename T6, typename T7, typename T8, typename T9>
struct check_dispatch< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
{
    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> mask_type;

    template <typename Matrix>
    static inline bool apply(mask_type const& mask, Matrix const& matrix)
    {
        return check_dispatch_tuple<mask_type>::apply(mask, matrix);
    }
};

template <typename Head, typename Tail>
struct check_dispatch< boost::tuples::cons<Head, Tail> >
{
    typedef boost::tuples::cons<Head, Tail> mask_type;

    template <typename Matrix>
    static inline bool apply(mask_type const& mask, Matrix const& matrix)
    {
        return check_dispatch_tuple<mask_type>::apply(mask, matrix);
    }
};

template <typename Mask, typename Matrix>
inline bool check(Mask const& mask, Matrix const& matrix)
{
    return check_dispatch<Mask>::apply(mask, matrix);
}

// matrix_width

template <>
struct matrix_width<mask9>
{
    static const std::size_t value = 3;
};

template <typename Tuple,
          int I = 0,
          int N = boost::tuples::length<Tuple>::value>
struct matrix_width_tuple
{
    static const std::size_t
        current = matrix_width<typename boost::tuples::element<I, Tuple>::type>::value;
    static const std::size_t
        next = matrix_width_tuple<Tuple, I+1>::value;

    static const std::size_t
        value = current > next ? current : next;
};

template <typename Tuple, int N>
struct matrix_width_tuple<Tuple, N, N>
{
    static const std::size_t value = 0;
};

template <typename Head, typename Tail>
struct matrix_width< boost::tuples::cons<Head, Tail> >
{
    static const std::size_t
        value = matrix_width_tuple< boost::tuples::cons<Head, Tail> >::value;
};

// matrix_handler

template <typename Mask, bool Interrupt>
class mask_handler
    : private matrix<matrix_width<Mask>::value>
{
    typedef matrix<matrix_width<Mask>::value> base_t;

public:
    typedef bool result_type;

    bool interrupt;

    inline mask_handler(Mask const& m)
        : interrupt(false)
        , m_mask(m)
    {}

    result_type result() const
    {
        return !interrupt
            && check(m_mask, static_cast<base_t const&>(*this));
    }

    template <field F1, field F2, char D>
    inline bool may_update() const
    {
        return detail::relate::may_update<F1, F2, D>(
                    m_mask, static_cast<base_t const&>(*this)
               );
    }

    //template <field F1, field F2>
    //inline char get() const
    //{
    //    return static_cast<base_t const&>(*this).template get<F1, F2>();
    //}

    template <field F1, field F2, char V>
    inline void set()
    {
        if ( relate::interrupt<F1, F2, V, Interrupt>(m_mask) )
        {
            interrupt = true;
        }
        else
        {
            base_t::template set<F1, F2, V>();
        }
    }

    template <field F1, field F2, char V>
    inline void update()
    {
        if ( relate::interrupt<F1, F2, V, Interrupt>(m_mask) )
        {
            interrupt = true;
        }
        else
        {
            base_t::template update<F1, F2, V>();
        }
    }

private:
    Mask const& m_mask;
};

// STATIC MASKS

// static_mask

template <char II, char IB, char IE,
          char BI, char BB, char BE,
          char EI, char EB, char EE>
class static_mask
{
    typedef boost::mpl::vector_c
                <
                    char, II, IB, IE, BI, BB, BE, EI, EB, EE
                > vector_type;

public:
    template <field F1, field F2>
    struct get
    {
        BOOST_STATIC_ASSERT(F1 * 3 + F2 < boost::mpl::size<vector_type>::value);

        static const char value
            = boost::mpl::at_c<vector_type, F1 * 3 + F2>::type::value;
    };
};

// static_should_handle_element

template <typename StaticMask, field F1, field F2, bool IsSequence>
struct static_should_handle_element_dispatch
{
    static const char mask_el = StaticMask::template get<F1, F2>::value;
    static const bool value = mask_el == 'F'
                           || mask_el == 'T'
                           || ( mask_el >= '0' && mask_el <= '9' );
};

template <typename First, typename Last, field F1, field F2>
struct static_should_handle_element_sequence
{
    typedef typename boost::mpl::deref<First>::type StaticMask;

    static const bool value
        = static_should_handle_element_dispatch
            <
                StaticMask,
                F1, F2,
                boost::mpl::is_sequence<StaticMask>::value
            >::value
       || static_should_handle_element_sequence
            <
                typename boost::mpl::next<First>::type,
                Last,
                F1, F2
            >::value;
};

template <typename Last, field F1, field F2>
struct static_should_handle_element_sequence<Last, Last, F1, F2>
{
    static const bool value = false;
};

template <typename StaticMask, field F1, field F2>
struct static_should_handle_element_dispatch<StaticMask, F1, F2, true>
{
    static const bool value
        = static_should_handle_element_sequence
            <
                typename boost::mpl::begin<StaticMask>::type,
                typename boost::mpl::end<StaticMask>::type,
                F1, F2
            >::value;
};

template <typename StaticMask, field F1, field F2>
struct static_should_handle_element
{
    static const bool value
        = static_should_handle_element_dispatch
            <
                StaticMask,
                F1, F2,
                boost::mpl::is_sequence<StaticMask>::value
            >::value;
};

// static_interrupt

template <typename StaticMask, char V, field F1, field F2, bool InterruptEnabled, bool IsSequence>
struct static_interrupt_dispatch
{
    static const bool value = false;
};

template <typename StaticMask, char V, field F1, field F2, bool IsSequence>
struct static_interrupt_dispatch<StaticMask, V, F1, F2, true, IsSequence>
{
    static const char mask_el = StaticMask::template get<F1, F2>::value;

    static const bool value
        = ( V >= '0' && V <= '9' ) ?
          ( mask_el == 'F' || ( mask_el < V && mask_el >= '0' && mask_el <= '9' ) ) :
          ( ( V == 'T' ) ? mask_el == 'F' : false );
};

template <typename First, typename Last, char V, field F1, field F2>
struct static_interrupt_sequence
{
    typedef typename boost::mpl::deref<First>::type StaticMask;

    static const bool value
        = static_interrupt_dispatch
            <
                StaticMask,
                V, F1, F2,
                true,
                boost::mpl::is_sequence<StaticMask>::value
            >::value
       && static_interrupt_sequence
            <
                typename boost::mpl::next<First>::type,
                Last,
                V, F1, F2
            >::value;
};

template <typename Last, char V, field F1, field F2>
struct static_interrupt_sequence<Last, Last, V, F1, F2>
{
    static const bool value = true;
};

template <typename StaticMask, char V, field F1, field F2>
struct static_interrupt_dispatch<StaticMask, V, F1, F2, true, true>
{
    static const bool value
        = static_interrupt_sequence
            <
                typename boost::mpl::begin<StaticMask>::type,
                typename boost::mpl::end<StaticMask>::type,
                V, F1, F2
            >::value;
};

template <typename StaticMask, char V, field F1, field F2, bool EnableInterrupt>
struct static_interrupt
{
    static const bool value
        = static_interrupt_dispatch
            <
                StaticMask,
                V, F1, F2,
                EnableInterrupt,
                boost::mpl::is_sequence<StaticMask>::value
            >::value;
};

// static_may_update

template <typename StaticMask, char D, field F1, field F2, bool IsSequence>
struct static_may_update_dispatch
{
    static const char mask_el = StaticMask::template get<F1, F2>::value;
    static const int version
                        = mask_el == 'F' ? 0
                        : mask_el == 'T' ? 1
                        : mask_el >= '0' && mask_el <= '9' ? 2
                        : 3;

    template <typename Matrix>
    static inline bool apply(Matrix const& matrix)
    {
        return apply_dispatch(matrix, integral_constant<int, version>());
    }

    // mask_el == 'F'
    template <typename Matrix>
    static inline bool apply_dispatch(Matrix const& , integral_constant<int, 0>)
    {
        return true;
    }
    // mask_el == 'T'
    template <typename Matrix>
    static inline bool apply_dispatch(Matrix const& matrix, integral_constant<int, 1>)
    {
        char const c = matrix.template get<F1, F2>();
        return c == 'F'; // if it's T or between 0 and 9, the result will be the same
    }
    // mask_el >= '0' && mask_el <= '9'
    template <typename Matrix>
    static inline bool apply_dispatch(Matrix const& matrix, integral_constant<int, 2>)
    {
        char const c = matrix.template get<F1, F2>();
        return D > c || c > '9';
    }
    // else
    template <typename Matrix>
    static inline bool apply_dispatch(Matrix const&, integral_constant<int, 3>)
    {
        return false;
    }
};

template <typename First, typename Last, char D, field F1, field F2>
struct static_may_update_sequence
{
    typedef typename boost::mpl::deref<First>::type StaticMask;

    template <typename Matrix>
    static inline bool apply(Matrix const& matrix)
    {
        return static_may_update_dispatch
                <
                    StaticMask,
                    D, F1, F2,
                    boost::mpl::is_sequence<StaticMask>::value
                >::apply(matrix)
            || static_may_update_sequence
                <
                    typename boost::mpl::next<First>::type,
                    Last,
                    D, F1, F2
                >::apply(matrix);
    }
};

template <typename Last, char D, field F1, field F2>
struct static_may_update_sequence<Last, Last, D, F1, F2>
{
    template <typename Matrix>
    static inline bool apply(Matrix const& /*matrix*/)
    {
        return false;
    }
};

template <typename StaticMask, char D, field F1, field F2>
struct static_may_update_dispatch<StaticMask, D, F1, F2, true>
{
    template <typename Matrix>
    static inline bool apply(Matrix const& matrix)
    {
        return static_may_update_sequence
                <
                    typename boost::mpl::begin<StaticMask>::type,
                    typename boost::mpl::end<StaticMask>::type,
                    D, F1, F2
                >::apply(matrix);
    }
};

template <typename StaticMask, char D, field F1, field F2>
struct static_may_update
{
    template <typename Matrix>
    static inline bool apply(Matrix const& matrix)
    {
        return static_may_update_dispatch
                <
                    StaticMask,
                    D, F1, F2,
                    boost::mpl::is_sequence<StaticMask>::value
                >::apply(matrix);
    }
};

// static_check

template <typename StaticMask, bool IsSequence>
struct static_check_dispatch
{
    template <typename Matrix>
    static inline bool apply(Matrix const& matrix)
    {
        return per_one<interior, interior>::apply(matrix)
            && per_one<interior, boundary>::apply(matrix)
            && per_one<interior, exterior>::apply(matrix)
            && per_one<boundary, interior>::apply(matrix)
            && per_one<boundary, boundary>::apply(matrix)
            && per_one<boundary, exterior>::apply(matrix)
            && per_one<exterior, interior>::apply(matrix)
            && per_one<exterior, boundary>::apply(matrix)
            && per_one<exterior, exterior>::apply(matrix);
    }

    template <field F1, field F2>
    struct per_one
    {
        static const char mask_el = StaticMask::template get<F1, F2>::value;
        static const int version
                            = mask_el == 'F' ? 0
                            : mask_el == 'T' ? 1
                            : mask_el >= '0' && mask_el <= '9' ? 2
                            : 3;

        template <typename Matrix>
        static inline bool apply(Matrix const& matrix)
        {
            const char el = matrix.template get<F1, F2>();
            return apply_dispatch(el, integral_constant<int, version>());
        }

        // mask_el == 'F'
        static inline bool apply_dispatch(char el, integral_constant<int, 0>)
        {
            return el == 'F';
        }
        // mask_el == 'T'
        static inline bool apply_dispatch(char el, integral_constant<int, 1>)
        {
            return el == 'T' || ( el >= '0' && el <= '9' );
        }
        // mask_el >= '0' && mask_el <= '9'
        static inline bool apply_dispatch(char el, integral_constant<int, 2>)
        {
            return el == mask_el;
        }
        // else
        static inline bool apply_dispatch(char /*el*/, integral_constant<int, 3>)
        {
            return true;
        }
    };
};

template <typename First, typename Last>
struct static_check_sequence
{
    typedef typename boost::mpl::deref<First>::type StaticMask;

    template <typename Matrix>
    static inline bool apply(Matrix const& matrix)
    {
        return static_check_dispatch
                <
                    StaticMask,
                    boost::mpl::is_sequence<StaticMask>::value
                >::apply(matrix)
            || static_check_sequence
                <
                    typename boost::mpl::next<First>::type,
                    Last
                >::apply(matrix);
    }
};

template <typename Last>
struct static_check_sequence<Last, Last>
{
    template <typename Matrix>
    static inline bool apply(Matrix const& /*matrix*/)
    {
        return false;
    }
};

template <typename StaticMask>
struct static_check_dispatch<StaticMask, true>
{
    template <typename Matrix>
    static inline bool apply(Matrix const& matrix)
    {
        return static_check_sequence
                <
                    typename boost::mpl::begin<StaticMask>::type,
                    typename boost::mpl::end<StaticMask>::type
                >::apply(matrix);
    }
};

template <typename StaticMask>
struct static_check
{
    template <typename Matrix>
    static inline bool apply(Matrix const& matrix)
    {
        return static_check_dispatch
                <
                    StaticMask,
                    boost::mpl::is_sequence<StaticMask>::value
                >::apply(matrix);
    }
};

// static_mask_handler

template <typename StaticMask, bool Interrupt>
class static_mask_handler
    : private matrix<3>
{
    typedef matrix<3> base_t;

public:
    typedef bool result_type;

    bool interrupt;

    inline static_mask_handler(StaticMask const& /*dummy*/)
        : interrupt(false)
    {}

    result_type result() const
    {
        return (!Interrupt || !interrupt)
            && static_check<StaticMask>::
                    apply(static_cast<base_t const&>(*this));
    }

    template <field F1, field F2, char D>
    inline bool may_update() const
    {
        return static_may_update<StaticMask, D, F1, F2>::
                    apply(static_cast<base_t const&>(*this));
    }

    template <field F1, field F2>
    static inline bool expects()
    {
        return static_should_handle_element<StaticMask, F1, F2>::value;
    }

    //template <field F1, field F2>
    //inline char get() const
    //{
    //    return base_t::template get<F1, F2>();
    //}

    template <field F1, field F2, char V>
    inline void set()
    {
        static const bool interrupt_c = static_interrupt<StaticMask, V, F1, F2, Interrupt>::value;
        static const bool should_handle = static_should_handle_element<StaticMask, F1, F2>::value;
        static const int version = interrupt_c ? 0
                                 : should_handle ? 1
                                 : 2;

        set_dispatch<F1, F2, V>(integral_constant<int, version>());
    }

    template <field F1, field F2, char V>
    inline void update()
    {
        static const bool interrupt_c = static_interrupt<StaticMask, V, F1, F2, Interrupt>::value;
        static const bool should_handle = static_should_handle_element<StaticMask, F1, F2>::value;
        static const int version = interrupt_c ? 0
                                 : should_handle ? 1
                                 : 2;

        update_dispatch<F1, F2, V>(integral_constant<int, version>());
    }

private:
    // Interrupt && interrupt
    template <field F1, field F2, char V>
    inline void set_dispatch(integral_constant<int, 0>)
    {
        interrupt = true;
    }
    // else should_handle
    template <field F1, field F2, char V>
    inline void set_dispatch(integral_constant<int, 1>)
    {
        base_t::template set<F1, F2, V>();
    }
    // else
    template <field F1, field F2, char V>
    inline void set_dispatch(integral_constant<int, 2>)
    {}

    // Interrupt && interrupt
    template <field F1, field F2, char V>
    inline void update_dispatch(integral_constant<int, 0>)
    {
        interrupt = true;
    }
    // else should_handle
    template <field F1, field F2, char V>
    inline void update_dispatch(integral_constant<int, 1>)
    {
        base_t::template update<F1, F2, V>();
    }
    // else
    template <field F1, field F2, char V>
    inline void update_dispatch(integral_constant<int, 2>)
    {}
};

// OPERATORS

template <typename Mask1, typename Mask2> inline
boost::tuples::cons<
    Mask1,
    boost::tuples::cons<Mask2, boost::tuples::null_type>
>
operator||(Mask1 const& m1, Mask2 const& m2)
{
    namespace bt = boost::tuples;

    return
    bt::cons< Mask1, bt::cons<Mask2, bt::null_type> >
        ( m1, bt::cons<Mask2, bt::null_type>(m2, bt::null_type()) );
}

template <typename Head, typename Tail, typename Mask> inline
typename index::detail::tuples::push_back<
    boost::tuples::cons<Head, Tail>, Mask
>::type
operator||(boost::tuples::cons<Head, Tail> const& t, Mask const& m)
{
    namespace bt = boost::tuples;

    return
    index::detail::tuples::push_back<
        bt::cons<Head, Tail>, Mask
    >::apply(t, m);
}

// PREDEFINED MASKS

// TODO:
// 1. specialize for simplified masks if available
// e.g. for TOUCHES use 1 mask for A/A
// 2. Think about dimensions > 2 e.g. should TOUCHES be true
// if the interior of the Areal overlaps the boundary of the Volumetric
// like it's true for Linear/Areal

// EQUALS
template <typename Geometry1, typename Geometry2>
struct static_mask_equals_type
{
    typedef static_mask<'T', '*', 'F', '*', '*', 'F', 'F', 'F', '*'> type; // wikipedia
    //typedef static_mask<'T', 'F', 'F', 'F', 'T', 'F', 'F', 'F', 'T'> type; // OGC
};

// DISJOINT
typedef static_mask<'F', 'F', '*', 'F', 'F', '*', '*', '*', '*'> static_mask_disjoint;

// TOUCHES - NOT P/P
template <typename Geometry1,
          typename Geometry2,
          std::size_t Dim1 = topological_dimension<Geometry1>::value,
          std::size_t Dim2 = topological_dimension<Geometry2>::value>
struct static_mask_touches_impl
{
    typedef boost::mpl::vector<
                static_mask<'F', 'T', '*', '*', '*', '*', '*', '*', '*'>,
                static_mask<'F', '*', '*', 'T', '*', '*', '*', '*', '*'>,
                static_mask<'F', '*', '*', '*', 'T', '*', '*', '*', '*'>
        > type;
};
// According to OGC, doesn't apply to P/P
// Using the above mask the result would be always false
template <typename Geometry1, typename Geometry2>
struct static_mask_touches_impl<Geometry1, Geometry2, 0, 0>
    : not_implemented<typename geometry::tag<Geometry1>::type,
                      typename geometry::tag<Geometry2>::type>
{};

template <typename Geometry1, typename Geometry2>
struct static_mask_touches_type
    : static_mask_touches_impl<Geometry1, Geometry2>
{};

// WITHIN
typedef static_mask<'T', '*', 'F', '*', '*', 'F', '*', '*', '*'> static_mask_within;

// COVERED_BY (non OGC)
typedef boost::mpl::vector<
            static_mask<'T', '*', 'F', '*', '*', 'F', '*', '*', '*'>,
            static_mask<'*', 'T', 'F', '*', '*', 'F', '*', '*', '*'>,
            static_mask<'*', '*', 'F', 'T', '*', 'F', '*', '*', '*'>,
            static_mask<'*', '*', 'F', '*', 'T', 'F', '*', '*', '*'>
        > static_mask_covered_by;

// CROSSES
// dim(G1) < dim(G2) - P/L P/A L/A
template <typename Geometry1,
          typename Geometry2,
          std::size_t Dim1 = topological_dimension<Geometry1>::value,
          std::size_t Dim2 = topological_dimension<Geometry2>::value,
          bool D1LessD2 = (Dim1 < Dim2)
>
struct static_mask_crosses_impl
{
    typedef static_mask<'T', '*', 'T', '*', '*', '*', '*', '*', '*'> type;
};
// TODO: I'm not sure if this one below should be available!
// dim(G1) > dim(G2) - L/P A/P A/L
template <typename Geometry1, typename Geometry2,
          std::size_t Dim1, std::size_t Dim2
>
struct static_mask_crosses_impl<Geometry1, Geometry2, Dim1, Dim2, false>
{
    typedef static_mask<'T', '*', '*', '*', '*', '*', 'T', '*', '*'> type;
};
// dim(G1) == dim(G2) - P/P A/A
template <typename Geometry1, typename Geometry2,
          std::size_t Dim
>
struct static_mask_crosses_impl<Geometry1, Geometry2, Dim, Dim, false>
    : not_implemented<typename geometry::tag<Geometry1>::type,
                      typename geometry::tag<Geometry2>::type>
{};
// dim(G1) == 1 && dim(G2) == 1 - L/L
template <typename Geometry1, typename Geometry2>
struct static_mask_crosses_impl<Geometry1, Geometry2, 1, 1, false>
{
    typedef static_mask<'0', '*', '*', '*', '*', '*', '*', '*', '*'> type;
};

template <typename Geometry1, typename Geometry2>
struct static_mask_crosses_type
    : static_mask_crosses_impl<Geometry1, Geometry2>
{};

// OVERLAPS

// dim(G1) != dim(G2) - NOT P/P, L/L, A/A
template <typename Geometry1,
          typename Geometry2,
          std::size_t Dim1 = topological_dimension<Geometry1>::value,
          std::size_t Dim2 = topological_dimension<Geometry2>::value
>
struct static_mask_overlaps_impl
    : not_implemented<typename geometry::tag<Geometry1>::type,
                      typename geometry::tag<Geometry2>::type>
{};
// dim(G1) == D && dim(G2) == D - P/P A/A
template <typename Geometry1, typename Geometry2, std::size_t Dim>
struct static_mask_overlaps_impl<Geometry1, Geometry2, Dim, Dim>
{
    typedef static_mask<'T', '*', 'T', '*', '*', '*', 'T', '*', '*'> type;
};
// dim(G1) == 1 && dim(G2) == 1 - L/L
template <typename Geometry1, typename Geometry2>
struct static_mask_overlaps_impl<Geometry1, Geometry2, 1, 1>
{
    typedef static_mask<'1', '*', 'T', '*', '*', '*', 'T', '*', '*'> type;
};

template <typename Geometry1, typename Geometry2>
struct static_mask_overlaps_type
    : static_mask_overlaps_impl<Geometry1, Geometry2>
{};

// RESULTS/HANDLERS UTILS

template <field F1, field F2, char V, typename Result>
inline void set(Result & res)
{
    res.template set<F1, F2, V>();
}

template <field F1, field F2, char V, bool Transpose>
struct set_dispatch
{
    template <typename Result>
    static inline void apply(Result & res)
    {
        res.template set<F1, F2, V>();
    }
};

template <field F1, field F2, char V>
struct set_dispatch<F1, F2, V, true>
{
    template <typename Result>
    static inline void apply(Result & res)
    {
        res.template set<F2, F1, V>();
    }
};

template <field F1, field F2, char V, bool Transpose, typename Result>
inline void set(Result & res)
{
    set_dispatch<F1, F2, V, Transpose>::apply(res);
}

template <char V, typename Result>
inline void set(Result & res)
{
    res.template set<interior, interior, V>();
    res.template set<interior, boundary, V>();
    res.template set<interior, exterior, V>();
    res.template set<boundary, interior, V>();
    res.template set<boundary, boundary, V>();
    res.template set<boundary, exterior, V>();
    res.template set<exterior, interior, V>();
    res.template set<exterior, boundary, V>();
    res.template set<exterior, exterior, V>();
}

template <char II, char IB, char IE, char BI, char BB, char BE, char EI, char EB, char EE, typename Result>
inline void set(Result & res)
{
    res.template set<interior, interior, II>();
    res.template set<interior, boundary, IB>();
    res.template set<interior, exterior, IE>();
    res.template set<boundary, interior, BI>();
    res.template set<boundary, boundary, BB>();
    res.template set<boundary, exterior, BE>();
    res.template set<exterior, interior, EI>();
    res.template set<exterior, boundary, EB>();
    res.template set<exterior, exterior, EE>();
}

template <field F1, field F2, char D, typename Result>
inline void update(Result & res)
{
    res.template update<F1, F2, D>();
}

template <field F1, field F2, char D, bool Transpose>
struct update_result_dispatch
{
    template <typename Result>
    static inline void apply(Result & res)
    {
        update<F1, F2, D>(res);
    }
};

template <field F1, field F2, char D>
struct update_result_dispatch<F1, F2, D, true>
{
    template <typename Result>
    static inline void apply(Result & res)
    {
        update<F2, F1, D>(res);
    }
};

template <field F1, field F2, char D, bool Transpose, typename Result>
inline void update(Result & res)
{
    update_result_dispatch<F1, F2, D, Transpose>::apply(res);
}

template <field F1, field F2, char D, typename Result>
inline bool may_update(Result const& res)
{
    return res.template may_update<F1, F2, D>();
}

template <field F1, field F2, char D, bool Transpose>
struct may_update_result_dispatch
{
    template <typename Result>
    static inline bool apply(Result const& res)
    {
        return may_update<F1, F2, D>(res);
    }
};

template <field F1, field F2, char D>
struct may_update_result_dispatch<F1, F2, D, true>
{
    template <typename Result>
    static inline bool apply(Result const& res)
    {
        return may_update<F2, F1, D>(res);
    }
};

template <field F1, field F2, char D, bool Transpose, typename Result>
inline bool may_update(Result const& res)
{
    return may_update_result_dispatch<F1, F2, D, Transpose>::apply(res);
}

template <typename Result, char II, char IB, char IE, char BI, char BB, char BE, char EI, char EB, char EE>
inline Result return_result()
{
    Result res;
    set<II, IB, IE, BI, BB, BE, EI, EB, EE>(res);
    return res;
}

template <typename Geometry>
struct result_dimension
{
    BOOST_STATIC_ASSERT(geometry::dimension<Geometry>::value >= 0);
    static const char value
        = ( geometry::dimension<Geometry>::value <= 9 ) ?
            ( '0' + geometry::dimension<Geometry>::value ) :
              'T';
};

}} // namespace detail::relate
#endif // DOXYGEN_NO_DETAIL

}} // namespace boost::geometry

#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RESULT_HPP


Some people fall into fall -- and hard. The crisp air, the cozy aromas, the Instagram-friendly light (#nofilter) -- it's your favorite time of year ... and you might just have "fall fever."
See below for the symptoms of "fall fever" and decide if you've got it -- and bad.
When it comes to sweaters, the bigger the better. You see them more as a "wearable blanket" and the more cashmere-ish, the better. Layering is the secret to a fall wardrobe (and by "layering" you mean wearing more than one sweater).
You feel the need for heat on your feet constantly and the only way to warm those frosty toes is a massive and somewhat precarious fire. Marshmallows are not mandatory but they help. Keep a bucket of water handy at all times.
You wake up in the middle of the night screaming "40 minutes at 400!" because you know that's the perfect formula for roasting pretty much anything from the fall veggie bounty. Whole heads of garlic? Easy. Beets? Child's play. Boiling and steaming anything that grows makes your eyes roll into next week.
You masterfully block out the "anti-pumpkin spice" movement because there isn't a product that you haven't tried and enjoyed -- and that's okay. You do, however, hoard products under your bed because you're perfectly fine with sipping a hot pumpkin-spiced tea on a humid summer's day. And you are also well aware of the fact that pumpkin-spice products contain no actual pumpkin (thank you very much) because that would be gross.
Just a typical fall weekend: a bunch of friends head to the local orchard to pick some apples, sip some cider and sit on a bale of hay. Except you are nowhere to be found because you wandered deep into the orchard, never to be seen again -- at least until they track you down using a trail of cider donut holes.


text:
Q: How to select the first 3 rows of every group in pandas? I get a pandas dataframe like this:
    id   prob
0    1   0.5
1    1   0.6
2    1   0.4
3    1   0.2
4    2   0.3
6    2   0.5
...

I want to group it by 'id', sort descending order and get the first 3 prob of every group. Note that some groups contain rows less than 3.
Finally I want to get a 2D array like:
[[1, 0.6, 0.5, 0.4], [2, [0.5, 0.3]]...]

How can I do that with pandas?
Thanks!

A: Use sort_values, groupby, and head:
df.sort_values(by=['id','prob'], ascending=[True,False]).groupby('id').head(3).values

Output:
array([[ 1. ,  0.6],
       [ 1. ,  0.5],
       [ 1. ,  0.4],
       [ 2. ,  0.5],
       [ 2. ,  0.3]])

Following @COLDSPEED lead:
df.sort_values(by=['id','prob'], ascending=[True,False])\
  .groupby('id').agg(lambda x: x.head(3).tolist())\
  .reset_index().values.tolist()

Output:
[[1, [0.6, 0.5, 0.4]], [2, [0.5, 0.3]]]

A: You can use groupby and nlargest
df.groupby('id').prob.nlargest(3).reset_index(1,drop = True)

id
1    0.6
1    0.5
1    0.4
2    0.5
2    0.3

For the array
df1 = df.groupby('id').prob.nlargest(3).unstack(1)#.reset_index(1,drop = True)#.set_index('id')
np.column_stack((df1.index.values, df1.values))

You get
array([[ 1. ,  0.5,  0.6,  0.4,  nan,  nan],
       [ 2. ,  nan,  nan,  nan,  0.3,  0.5]])

A: If you're looking for a dataframe of array columns, you can use np.sort:
df = df.groupby('id').prob.apply(lambda x: np.sort(x.values)[:-4:-1])
df

id
1    [0.6, 0.5, 0.4]
2         [0.5, 0.3]

To retrieve the values, reset_index and access:
df.reset_index().values

array([[1, array([ 0.6,  0.5,  0.4])],
       [2, array([ 0.5,  0.3])]], dtype=object)

A: [[n, g.nlargest(3).tolist()] for n, g in df.groupby('id').prob]

[[1, [0.6, 0.5, 0.4]], [2, [0.5, 0.3]]]

redpajama_set_name: RedPajamaStackExchange


Getting New Update for Smartphones especially Android has become essential because it Added more features to the already in use preexisting ones and can make you sticking longer to your device than you use to be. Current we have seen OEM providing updates for Android Device with the recent update for Oneplus 3 and Oneplus 3T.
OEM providing update is to upgrade the pre existing OS and fixes bug and that is What Tecno has done by providing System update for Tecno Camon CX Android Users. In this article, you will definitely Get to Update Your Tecno Camon CX and Here are the new features you will be enjoying after upgrading the device.
👉 Back up your important Documents or files like Apps on your SD card or External Storage in case something Goes wrong.
How to Update Tecno Camon CX to Android 7.0 Nougat.
3. To Move apps to SD card, Insert the card and perform the moving to and from.
This is how to update Tecno Camon CX, which is already available for the device, The guide above will help you to do it all by yourself but if you are having problem updating to Android 7.0 Nougat, let us know.. Enjoy and we hope more update will be available for Tecno Devices soon.


text:
Free trade talks between Thailand and EU to resume in March
Home/Europe/Prince Harry and the Duchess couldn't do much more than moan about the Royals after the Netflix disaster.
Prince Harry and the Duchess couldn't do much more than moan about the Royals after the Netflix disaster.
jasonmarkramMay 5, 2022
Ruth Wilson says he wears an MBE "every time he goes out"
Ruth Wilson jokes that he wears an MBE "every time he goes out" when he wins a prize at Buckingham Palace.
Winner of two Olivier Awards and a Golden Globe Award for her performance in the TV series "Affair," the actress was named MBE on the 2021 Queen's Birthday Honors list for her service to the drama.
She joined actor and musician Ram John Holder and modern pentathlon at the Olympics gold medalist Kate French, and won a prize from Princess Royal at the Buckingham Palace's inauguration on Wednesday afternoon.
Wilson spoke with PA News Agency, saying the day was "amazing" and added that the award was a "great honor" and a "true privilege."
She was asked where to put the MBE and said, "On my collar-next .. I'll wear it every time I go out.
"No, I don't know. You need to frame or curl your neck."
Wilson describes what this award personally means to her:
"It's a real honor to be awarded it and be among all the other people I've seen in the room today.
"It's really great to see people from all over the country and the services they have done in their communities and in their chosen areas."
When asked about a conversation with Princess Royal, Wilson said she talked about how she would play in the palace as a child.
The actress said, "When I asked if I acted when I was young, I asked if I acted when I was young."
"She said she had, and I asked if they would play in the palace, and she said they actually played in that room," Wilson was awarded. I showed the room and said.
She went on to say that Mrs. Wilson on the television show, who played a real grandmother who discovered that her deceased husband had another family, was the highlight of her career.
Wilson said: "It was a homage to my family, for them, difficult and a lot of pressure.
"I could see how I was returning something to my family and just the conversation as a family. It was very important and there were conversations and discussions. That's what I'm most proud of. I think. ""
https://www.thesun.ie/fabulous/8738567/meghan-markle-news-prince-harry-royal-family/ Prince Harry and the Duchess couldn't do much more than moan about the Royals after the Netflix disaster.
jasonmarkram
Armenian opponents blockade Yerevan's streets during open-ended protests, the report said.
Hungary was able to see the arrival of more refugees after the transcarpati missile attack
Britain's Most Boring Calendar chronicles hopelessly boring landmarks along the M40 motorway
Ministry of Health Launches Nationwide Health and Nutrition Survey
Explainer: Is Russia short of missiles?
Mudslides on Italy's Ischia island leave several dead, others missing
Police crush online scam gang
Slovenian Černivec becomes the first female GM in British basketball
Heavy rains kill three in New Zealand – The Island

redpajama_set_name: RedPajamaCommonCrawl


Have you considered choosing two color combination for bedroom walls?! It is a great solution to create different contrasts, original rooms, and modern decorations. Surely it will give a different air to your room.
When the walls are painted in two new, and beautiful colors, both the style and the feel of the room are transformed.
When choosing two color combination for bedroom walls it is important to take into account that some shades can soothe and relax the body, while others contribute to an active feeling. Therefore it is important to know what colors to choose for the bedroom and what function they perform.
There are infinite possibilities and, logically, your decision will depend on your tastes. However, it is important to take into account a number of aspects before getting down to work, because once it is underway, you can't go backward.
How to choose two color combination for bedroom walls?
When painting two color combination for bedroom walls, a good idea is to opt for the same tone but with different clearness degree. Thus, you will get a coordinated and toned space.
If you prefer something more daring, you can combine two totally different colors, such as red and green, yellow and violet or blue and orange. This type of combination is ideal for active people rooms, which are the most activating colors. Of course, you can also combine the colors between the ceiling and the wall!
When choosing two color combination for bedroom walls it is very important to pay attention to the space and the size of the room, since your choice will depend on having a greater or lesser sense of spaciousness when entering the room.
If your bedroom is small, it will require a lot of light. Therefore, it is best to play with light colors to achieve greater visual amplitude.
However, the spacious rooms will allow you to use bold colors. Another good option for rooms with lots of space is the walls with two-colored stripes, although they could make it look smaller than it really is. If you have enough space, the tones like white and black will give a great touch.
In the first place, designers put a blue color to sleep and according to scientists, people with blue bedrooms sleep longer than people with bedrooms of other colors. You can combine it with white or light blue.
Surprisingly, the second color, suitable for sleep according to the designers, is yellow. The sunny shade stimulates the nervous system, promoting relaxation. In addition, a gentle yellow shade creates instant coziness in any bedroom. The best combination will be with white or darker tone of yellow and orange.
The green color is in the third place in the design of bedrooms. According to scientists, people who sleep in the green bedroom, wake up, feeling optimistic and positive.
According to scientists, people with purple bedrooms are the least rested of all, receiving on average an insignificant five hours and 56 minutes of sleep per night. A rich design in eggplant color stimulates mental activity, which makes it difficult to turn off consciousness after a busy day and potentially causes bright dreams or nightmares. Therefore, designers advise mixing violet with white, creating a gentle shade of it. It is better to use lilac, lavender or plum color in this case, the effect of color will be minimal.
This is not all about how to choose two color combination for bedroom walls but those are the most important tips to help you choose.


text:
Coronavirus Crisis: OSHA Steps Up Enforcement As Businesses Reopen
Posted on May 21, 2020 May 22, 2020 by Robert G. Chadwick, Jr.
Effective May 26, 2020, OSHA is rescinding the Interim Enforcement Response Plan for Coronavirus Disease 2019 (COVID-19), published by the agency on April 13, 2020 (See April 15, 2020 Post), and the Enforcement Guidance for Recording Cases of Coronavirus Disease 2019 (COVID-19), published by the agency on April 10, 2020. As businesses reopen, OSHA will instead be guided by two revised enforcement policies.
Inspection Priorities
First, under an Updated Interim Enforcement Plan for Coronavirus Disease 2019 (COVID-19, OSHA will resume in-person inspections of workplaces. The agency will continue to prioritize COVID-19 cases. "Particular attention for on-site inspections will be given to high-risk workplaces, such as hospitals and other healthcare providers treating patients with COVID-19, as well as workplaces, with high numbers of complaints or known COVID-19 cases."
OSHA will continue to provide enforcement priority to "[h]igh and very high exposure risk jobs." In this regard, the Updated Plan says:
"High and very high exposure risk jobs are those with high potential for exposure to known or suspected sources of SARS-CoV-2 that occurs during specific medical, postmortem, or laboratory procedures. Workplaces considered to have job duties with high risk of exposures to COVID-19 include, but are not limited to, hospitals treating suspected and/or confirmed COVID-19 patients, nursing homes, emergency medical centers, emergency response facilities, settings where home care or hospice care are provided, settings that handle human remains, biomedical laboratories, including clinical laboratories, and medical transport. The aerosol-generating procedures, in particular, present a very high risk of exposure to workers. The aerosol-generating procedures for which engineering controls, administrative controls, and personal protective equipment (PPE) are necessary include, but are not limited to, bronchoscopy, sputum induction, nebulizer therapy, endotracheal intubation and extubation, open suctioning of airways, cardiopulmonary resuscitation and autopsies."
OSHA standards that may be investigated by OSHA as to COVID-19 include:
Recording and Reporting Occupational Injuries and Illness (29 CFR 1904)
General Requirements – Personal Protective Equipment (29 CFR 1910.132)
Eye and Face Protection (29 CFR 1910.133)
Respiratory Protection (29 CFR 1910.134)
Sanitation (29 CFR 1910.141)
Specification for Accident Prevention Signs and Tags (29 CFR 145)
Access to Employee Exposure and Medical Records (29 CFR 1910.145)
General Duty Clause
Recording COVID-19 Cases
Second, under Revised Guidance for Recording Cases of Coronavirus Disease 2019 (COVID-19), COVID-19 is a recordable illness if:
The case is a confirmed case of COVID-19, as defined by the Centers for Disease Control (CDC);
The case is work-related as defined by 29 C.F.R. 1904.5; and
The case involves one or more of the general recording criteria set forth in 29 C.F.R. 1904.7.
The Revised Guidance acknowledges the difficulty of determining whether a COVID-19 illness is work-related. Still, OSHA maintains that an employer must conduct a reasonable investigation as to whether the disease was contracted at work. In this regard the Revised Guidance states:
"Employers, especially small employers, should not be expected to undertake extensive medical inquiries, given employee privacy concerns and most employers' lack of expertise in this area. It is sufficient in most circumstances for the employer, when it learns of an employee's COVID-19 illness, (1) to ask the employee how he believes he contracted the COVID-19 illness; (2) while respecting employee privacy, discuss with the employee his work and out-of-work activities that may have led to the COVID-19 illness; and (3) review the employee's work environment for potential SARS-CoV-2 exposure. The review in (3) should be informed by any other instances of workers in that environment contracting COVID-19 illness."
Even after a reasonable investigation, it may still not be entirely clear whether COVID-19 was contracted at work. In this regard, the Revised Guidance provides:
COVID-19 illnesses are likely work-related when several cases develop among workers who work closely together and there is no alternative explanation.
An employee's COVID-19 illness is likely work-related if it is contracted shortly after lengthy, close exposure to a particular customer or coworker who has a confirmed case of COVID-19 and there is no alternative explanation.
An employee's COVID-19 illness is likely work-related if his job duties include having frequent, close exposure to the general public in a locality with ongoing community transmission and there is no alternative explanation.
An employee's COVID-19 illness is likely not work-related if she is the only worker to contract COVID-19 in her vicinity and her job duties do not include having frequent contact with the general public, regardless of the rate of community spread.
An employee's COVID-19 illness is likely not work-related if he, outside the workplace, closely and frequently associates with someone (e.g., a family member, significant other, or close friend) who (1) has COVID-19; (2) is not a coworker, and (3) exposes the employee during the period in which the individual is likely infectious.
OSHA has already been facing intense political pressure to take more decisive action to safeguard workers in the wake of the COVID-19. This pressure will only become more intense as business previously subject to state and local closure orders reopen. Employers should thus expect OSHA to be considerably more active in the remaining months of 2020.
Most employers already know, moreover, that OSHA obligations do not exist in a vacuum. OSHA inspections and illness recordings are sure to impact exposures other than OSHA citations, such as wrongful death actions, criminal prosecutions and workers' compensation claims.
Previous Post Coronavirus Crisis: OSHA Establishes Interim Inspection Priorities
Next Post Tracking COVID-19-Related Citations By OSHA


Residents of North Dakota can breath a little easier: They're the least likely to be audited by either the Internal Revenue Service or state tax officials, according to an analysis of more than 6,300 actual IRS and state audits by TaxAudit.com.
The Peace Garden State's budget surpluses from the energy boom and its small population tend to help residents keep tax auditors at bay, according to TaxAudit.com, which provides audit defense services for TurboTax users and handled and resolved more than 24,000 audits last year. TaxAudit.com ranked states on the likelihood of a tax audit based on user data from their 2013 tax returns.
The number of IRS personnel in a state, how a state's tax laws differ from the federal tax code and what activities federal and state officials want to target in a given year—for example, the IRS frequently audits horse breeders to see if they are accurately tracking their expenses—affect the volume of audits in each state.
The one thing you can do to avoid being audited by the tax man: "Never leave off income from your tax return," said Dave Du Val, vice president of customer advocacy at TaxAudit.com.
Check out CNBC's Kelli Grant's latest tips on avoiding a tax audit.


Facilities: Laundry Room, Fax (For Guests), Babysitting, Laundry Service, Deposit Box, Secretarial Services, Car Rental, Concierge Services, Currency Exchange, Front Desk (24 Hour), Photocopy Service, Doctor On Call, Room Service, Rooms with Hair Dryer, Wake-up Service, Television, Bidet, Television, Private Bath, Balcony/Terrace, Mini-Bar, Radio/Alarm Clock, Shower, Air Conditioning, Bathtub, Telephone, Non-Smoking Rooms, Internet Access, Daily Maid Service % Safe.
The MELIA ROYAL ALMA BOUTIQUE is a Tourist hotel. Located in City Centre - Arc De Triomphe area. Shopping is accessible by bus/taxi and the nightlife/restaurants are easily accessible by taxi or bus from the hotel.
Descriptionclass="small" style="text-align: justify; font-size:11px;">Facilities: Laundry Room, Fax (For Guests), Babysitting, Laundry Service, Deposit Box, Secretarial Services, Car Rental, Concierge Services, Currency Exchange, Front Desk (24 Hour), Photocopy Service, Doctor On Call, Room Service, Rooms with Hair Dryer, Wake-up Service, Television, Bidet, Television, Private Bath, Balcony/Terrace, Mini-Bar, Radio/Alarm Clock, Shower, Air Conditioning, Bathtub, Telephone, Non-Smoking Rooms, Internet Access, Daily Maid Service % Safe.


text:
Leif "Prinsen" Printzlau (født 16. december 1948 i Nyborg) er en tidligere dansk fodboldspiller.

Printzlau nåede i perioden 1968-1972 at spille syv A-landskampe og fik scoret en enkelt gang samt otte U-landskampe (1967-1973). 1972 var han med til OL i München hvor det blev til indhop mod Marokko (et mål) og Sovjetunionen.

På klubplan spillede han det meste af sin aktive karriere venstre wing i Frem. Han begyndte i klubben som 10-årig. I perioden 1967-1977 spillede han 255 kampe og scorede 33 mål på 1. holdet. Han vandt DM-sølv med Frem i 1967 og 1976 samt bronze 1968 og 1971. Han var med i Frems to nederlag i Landspokalfinalerne 1968 mod KB (0-3) 1971 mod B.1909 (0-1). Han sluttede i Frem som 29 årig, da han ikke ønskede at fortsætte karrieren, da pengefodbolden blev indført i og blev derefter spillende træner i AIK Frederiksholm 1978.

Leif Printzlaus søn Jonathan Printzlau har vundet DM i tennis syv gange.

Printzlau er uddannet speditør i DFDS, hvor han har arbejdet siden. Han boede i mange år i Ølstykke, men flyttede i en årrække til Malmø, Sverige. Bor nu i Farum

Fodboldspillere fra Danmark
Fodboldlandsholdsspillere fra Danmark
Fodboldspillere fra Boldklubben Frem
Personer fra Nyborg

redpajama_set_name: RedPajamaWikipedia


Pristine sushi and a provocative setting add up to a don't-miss experience.
Hi! Sign in to let us know how Sushi Roku was?
by scorpiogirl10 at Citysearch Feb 14 .
used to live in LV and was a regular at that location, everything was amazing. Living in LA, a regular at Katana. Grouchy two toned red haired waitress ruined experience. Sticking w LV location & Katana.
by rm189 at Citysearch Feb 14 .
The food here was definitely better than the average Japanese food I've had... however, the waitress was very unprofessional and the manager was too chicken to step up to handle the situation.
I was with my family and family friends, and we were the first to step in for lunch when the restaurant opened at 11am. The waitress took our order first, but 1 hour later the restaurant was PACKED (noon time) and 1/2 the guests were already eating and we had not yet received any of our orders yet.
We asked the waitress about it, and she said ""you've only been waiting for 10 minutes please be patient."" We reminded her that we had arrived and ordered the second the restaurant had opened, as we had looked at the menu beforehand online, and saw her enter the items into the computer really quickly - she had obviously FORGOTTEN TO SUBMIT OUR ORDER.
We asked to speak to the manager and instead of apologizing, he tried to cover for her.
No hospitality at this place. Order for take-out if you must to avoid the horrible service.
Roberto J. Feb 01 .
Cool setting. My favorite dish: Rock Shrimp and Asparagus Roll. All of their sushi is VERY FRESH.
I also recomend the Tempura with Jalapeno.
Expensive? You bet, and worth every yen. Very attentive service.
by diGitAL9 at Citysearch Feb 14 .
If you like Sushi... No! I mean really like Sushi, then this place isn't no big deal unless you are trying to impress a girl that doesn't know any better. Make sure she glances at the check, she might ...you know. Anyway, the food might look pretty but it's not that great.
by Romano at Citysearch Feb 14 .
I have heard this place is really good, but I haven't actually been there personally. I hope to go some day and enjoy all the food people speak so highly of.
by teddychick at Citysearch Feb 14 .
The lounge area is very nice but the service there is terrible. I went with my boyfriend and the waitresses are always dressed provocatively. This last time I was there the girl kept bending over in front of him showing her cleavage. Every time she would come to our table she would bend over and do this. The other girl was wearing a dress so short that I could see things I did not want to see as she was cleaning the tables. This is very uncomfortable as I am trying to have dinner with my boyfriend.
by Pizzaafan at Citysearch Feb 14 .
Definitely has the look to impress- the dishes are not bad either but a little on the expensive side. The location of this restaurant is obviously superb and the interior design is beautiful. Great for large groups or couples- service can be a bit unpredictable but some very nice dishes are on offer.
by irs2 at Citysearch Feb 14 .
by simplyjg at Citysearch Feb 14 .
I've been here a few times and really like the music they play. Their food is good but not the best if you want fresh sushi or sashimi. A little over priced considering their sushi is not excellent. Stick with the fusion dishes and you will not go wrong.
Fusion sushi dishes are good.
by DISSaPOINTD at Citysearch Feb 14 .
I've gone to Sushi Roku in Pasadena several times( although I urged my party to go elsewhere, I optimistically gave the place a chance again and again-but NO MORE)..and every time it is such a disappointment. The service is so pretentious as if the waiters were to get a beating if the didn't give me their ""forced"" smiles and I felt I was up against an aggressive car salesman than a waiter. The sushi has consistently been horrible. On this particular night I came to see why. Able to understand Japanese I overheard a manager speaking to one of the sushi chefs about the Toro (the most expensive fish) thawing out, and having to sell the older fish that day! I was going to speak up to that manager but he was so rude to begin with, I opted to share the message on this site instead. If I am going to get thawed out fish I'd rather go support a small mom and pop establishment where I will get more appreciation and sincerity.
WORST sushi ever! Don't pay top $ for frozen fish!
by ROKUSUCKS at Citysearch Feb 14 .
by concierge21 at Citysearch Feb 14 .
Good food, nice ambiance, impeccable service. This is the place.
by Nozferat at Citysearch Feb 14 .
Lord knows, there are tons of places like that in LA but this place happens to be close to where I live. We thought it would be a nice place to go but the ludicrious prices for what you get pretty much makes this place worthless.
Made for idiots who like to overpay for sushi.
Pros: Location...you can go to alot of other places around it.
Cons: Pricey, obnoxious, wannabe hang-out.
by HungryInPasadena at Citysearch Feb 14 .
Omakase course turns out to be most interesting and rewarding, despite its high price and my misgivings about the fusion food. I was not disappointed it in the past. The one I had tonight, however, didn't agree with my system for some reason. Three of us ate the same course, and two of us had upset stomach later in the evening. The third is feeling fine, so I cannot say for certain that the food there was the cause. And honestly speaking, I did not find anything suspicious in terms of the taste or the smell in any of the raw items we consumed. We enjoyed them as usual. The dessert was a bit on the rich side, so perhaps the ice cream and rich chocolate didn't agree with hot sake. We will try the Omakase again in a moth or so, and until I find the reason to feel otherwise, I would continue to recommend the place. Go for the Omakase, and enjoy the thrill.
Linda O. Jan 15 .
The food is a little expensive. However it is good. I think they should give you a little bit more for your money. When I was there the customer service was good. I recommend you to go.
by blitz16 at Citysearch Feb 14 .
I'm still on my sushi hunt in Pasadena, and decided to try Sushi Roku. The restaurant had a nice ambience, and I was hopeful. The cocktail selection was interesting, but the food was a bit of a let down. It was ""fine"". Nothing exciting, nothing terrible. It is a bit expensive, and the food that we had didn't seem to justify the price.
by bcosko at Citysearch Feb 14 .
I would definitely reccomend Sushi Roku. Although both locations are great, I would say that overall I've had better experiences at the Pasadena restaurant. The staff is always friendly and welcoming, reservations are easy to make- and even without a reservation they do everything they can to accomodate your party as soon as possible. Not a pretentious place, delicious food, welcoming staff and a great atmostphere. I highly reccomend it!
by gina_jones at Citysearch Feb 14 .
If you want good sushi, don't go here.
by linlaobay at Citysearch Feb 14 .
Nice decor, the the food was just average. If you are really a true sushi fan, you should not expect good sushi. But if you are one of those people who refers to california rolls as ""sushi,"" then you may like this place. I probably would not go back again just for the food, but it's a good place to go with friends or people you want to impress.
by jerzy3 at Citysearch Feb 14 .
by shoediva1739 at Citysearch Feb 14 .
Sushi Roku is not the place to spend your birthday. Large parties aren't welcome here as the service is so slow, no one eats at the same time. The clincher is that you can't bring a birthday cake unless you want to pay an additional $2.50 per person charge for them to serve it for you. I have never heard of a restaurant doing this! I could understand if I was bringing a dessert that they make themselves. With nine people in the party, the bill was $350.00. We'll never go back and this was a regular stop for us. The cake charge just let me know that I need to spend my money elsewhere. Incredible.
by dewydrop at Citysearch Feb 14 .
The omakase definitely makes up for the noisy and wannabe japanese atmosphere.
The foods there are a bit pricey, but its worth it! Great scenery, setting, and service. World class restaurant. Recommended, if willing to spend a few bucks.
by ts125 at Citysearch Feb 14 .
The restaurant is beautiful, really ""Zen."" The servers are professional and freindly. Not to mention prompt, even when it is packed. If you are overwhelmed by the extensive menu just ask them for guidance, they are only to happy to assist. My husband will only eat sushi here (on the East side of town.) The matchbooks are so flipping cute. Well, they are! We eat here once a week or so and have never had a bad meal or a bad dining experience. If you want to have an incredible Japanese dinner, then stroll through the heart of Old Town, look no further. Sushi Roku rocks.
It's Worth It. This Sushi Is Amazing.
Pros: Yum Yum Yummy Sushi, beautiful interior.
by sxzdiva at Citysearch Feb 14 .
This is a great little place to have some sushi with friends, and family. The atmosphere is great! The sushi is okay, nothing out of the ordinary. The service is good.
by joan_mutter at Citysearch Feb 14 .
If you like being part of the ""see and be seen"" crowd, Sushi Roku is for you. This place is all about where you are seated and who might be sitting next to you. The sushi is always fresh but, honestly, it's no better or worse than a dozen other sushi restaurants in the area. The prices though, off the charts. I have been here a few times and always resent the check just a little bit when it arrives. The service is generally fine but I could do without the attitude of about 60% of the customers. One dish that is worth every penny (and, ironically, is not sushi): the filet mignon wrapped asparagus appetizer. I could eat these all day.
by msq at Citysearch Feb 14 .
Me and my boyfriend went there for the first time and my first impression was great. The ambiance is very romantic. Everything we tried was great the and server was very knowledgeable. I asked so many questions and he could answer them all w/ good detail. We had a yellow tail sashimi appetizer plate, he had fillet mignon, I had sushi rolls and Japanese scallops sushi. I even had a sake sampler (recommended for novice sake drinkers). We shared a dessert which was really good and unique.
by tofutratra at Citysearch Feb 14 .
by ashuri at Citysearch Feb 14 .
by aira177 at Citysearch Feb 14 .
ambience ambience ambience! beautiful. this restaurant is beautiful. the food is good, but the plates are small. the sake is good also. the service is a bit slow sometimes, but the food wait isnt too long.
small plates. good food. good sake.
by sushifishlover at Citysearch Feb 14 .
Nice ambience, I love thier bar that you can have nice cocktails while you wait for seating. Appetizers are pretty good but I think the sushi is average and it was too expensive for the avarage sushi.
Too expensive fot what I get.
by karnicwar at Citysearch Feb 14 .
The menu was not as diverse as I had expected for a higher end sushi restaurant, but the basics were fresh, beautifully presented and delicious. The Yellowtail Scallion rolls were fabulous, and the chocolate lava cake for dessert was divine. I would definitely go back as the ambience was very soothing and the service was excellent. However, if you're looking for a long list of novel rolls, I would go elsewhere.
by lynn_nyc at Citysearch Feb 14 .
We ususally don't eat trendy, but this place was recommened, and it was well worth it. Sometimes fushion does not work with sushi, but at this place, the orignal sushi dishes were delicious. The service was friendly and helpful. I even got a beautiful birthday dessert, with a little candle, and the plate said, ""Happy Birthday, Lynn"" What a treat!
by joefromla at Citysearch Feb 14 .
Staff was friendly, although service was sometimes slow. Visually nice, but very loud. The sushi is excellent, but as others have pointed out, the hot dishes may not satisfy. The sea bass was a disappointment. Teriyaki shrimp was mediocre. A trendy kind of place, but overall not great value.
Pros: Great sushi. Parking is validated. Very friendly staff. Nice decor and lighting.
Cons: Very noisy; hot dishes so-so; service can be slow.
by tomdav22 at Citysearch Feb 14 .
by mhuynh at Citysearch Feb 14 .
Nice place to have dinner or grab lunch. Not the most romantic atmosphere, but the food is pretty good. The miso eggplant dengaku is a must-try appetizer and the tempura lobster tail is great too. Sushi is mediocre. Portions are small. However, staff is wonderful. Green tea creme brulee for dessert is a good choice.
andrea p. Jun 27 .
i didn't have sushi here, just saki, drinks and dessert, but it was really fun. i definitely want to go back again. i loved the chairs and atmosphere. i heard the sushi was ok, but I'm gonna go back to try it. worth it just for the atmosphere anyway though.
Mandi B. Jun 27 .
We went here for some drinks and we got a Volcano. Oh my gosh so good it has chocolate thing ice cream and this cheesecake thing. The chocolate thing is to die for, pure heaven. The atmosphere is fun too everyone is there to relax and enjoy their night. It is really pretty inside and i liked the lounge area in the front.
by lonediner at Citysearch Feb 14 .
As with any trendy place, sushi roku is tastefully decorated. If you find that the tables are full, the bar/lounge area is very comfortable as well if you just want a casual place to eat with lots of activity around you. But I would say as all the other reviewers, this is not a pure sushi place, you would probably want to go for somewhere a bit more intimate.
by fudluverseeker at Citysearch Feb 14 .
If you want great traditional sushi go somewhere else, if you want creative items with a nice date atmosphere with money no object, then Roku is recommended.
Great ambience! Better than average at $$$.
by skyzero at Citysearch Feb 14 .
My wife and I had reservations this Valentine's Day for dinner at this restaurant. Very impressed with the freshness of their sushi. Their entrees were very tasty and satisfying. Our server was friendly and patiently explained several dishes to us. Service was prompt and attentive to our needs. Empty glasses and bowls didn't linger more than a couple of minutes before someone took them away or re-filled them. The wait for our food was a bit a long, but it might be because it was Valentine's Day and extremely busy for them.
by romcom at Citysearch Feb 14 .
Simply stated: There are many sushi restaurants in Pasadena. How do they all stay in business? Bar none, Sushi Roku serves the freshest most innovative sushi in town. I love the interior, it is sleek and cool and beautiful all at once. The prices are a little high, but all good sushi seems to be somewhat pricey. I do not care about that at all if the dinner is a memorable one. Sushi Roku has yet to let me down. I love going with a group. It is also a great place for parents- if raw fish turn them off, steer them towards the fab teriyaki chicken.
by sammysamadi at Citysearch Feb 14 .
The regular sushi is good, the specialties sushi is better and more creative.
Even the rib-eye steak is very tasty and juicy.
The only drawback is the service.
Why? My server are very aggressive in asking me for drink orders. They are more attentive if I order and keep ordering more drinks!!!
Surely, Sushi Roku make a lot of profit in their drinks... but that shouldn't be the only way to be attentive to your customer.
I don't drink that much, but I do eat the best and a lot of it.
My sushi food bill alone goes up to $100, that food only, but drink portion is only $10.
Beside that bad service from not ordering enough drinks, the food is very good as well as the surrounding which is hip and trendy. Sure, bring a date and get her drunk while you enjoy that sushi!!!
Pros: Specialty sushi, Rib-eye steak, Trendy and hip place.
by eatingismyfavorite at Citysearch Feb 14 .
I just went here for a special occasion and I can't even begin to describe how wonderful everything was. The food was delicious (we tried almost every roll on the menu as well as tempura and plain sushi) and the service was amazing. Our waiter was very friendly and patient (as we had a large group) and it was one of those places where you drink gets refilled and old plates get taken away without you even noticing. The chefs were all extremely friendly as well. This place is at the top of my list.
by importinsider at Citysearch Feb 14 .
When a restaurant does several things right, somebody will usually attack the ambience, and try to down play the WHOLE experience as being ""foo foo"", ""all hype"", ""trendy"", ""over priced"", etc, etc, but I think if your looking for value than you'll love this place because quality is something thats being over shadowed by the millions of restaurants sprouting up everywhere delivering the cheapest and the biggest kind of california, poki, etc. rolls. Sushi Roku offers a great balance of value thats driven by quality ingredients, experienced Sushi Chefs (Shin'san) and a unexpectedly impressive kitchen menu. The Colorado Lamb was very good! It was prepared perfectly (med. rare)!
Super Ichiban, Foo Foo, Freshest Excellent!
Amy E. Jun 12 .
Today we ate our Sunday lunch at sushi roku in Pasadena, very popular at its other locations, so we decided to try it..... the only sushi we ordered was california roll, it was very good, also edamame was ok (can't go wrong, nothing to add just serve), other than that our hot entrees were absolutely incredible bad, starting with the miso soup, no flavor at all, just like plain boiled water, we had their baked miso cod (I had a similar dish at Nobu in Los Angeles and at Nobu Las Vegas and it was excellent) , here very strange flavor and bones on the fish, the tempura was mushy, we also ordered one of the chef specials, chilean sea bass with spicy bisque sauce, I have no idea what this was, can't describe the flavor because there was no flavor there, the fish was very strange again, totally bland and bad after taste!!!
Please don't waste your money here. Not Recommended!!
Expensive and not good at all, and I don't mind paying when the food is good, but here?????
I should mention that service was good, but with the food being so incredible bad the good service didn't help.
This review is specifically for the Pasadena location, I would hope that the problem is only here!!
c t. Jun 09 .
i agree with the other reviews here. sushi roku has good food, but it is overpriced for sushi. if you're looking for an upscale restaurant, this place has beautiful decor and is very peaceful and serene. it's location is convenient, as it is in old town, in the middle of lots of shops. however, there are many other japanese restaurants in the area that are just as good and better priced. the bottom line is go there if you have the money or want a great date atmosphere and don't mind paying the extra price for it.
mary q. Apr 09 .
Sushi is good there but I think it's over priced. Everyone that I know says it's over priced. It's more for the scenary....can't spell the other word. But always good to try anything the first time.
CaesarTheDay _. Apr 06 .
Much like previous reviewers I found this place expensive for the quality of sushi you get. Decor is absolutely brilliant and a great setting for a dinner with friends or a date. Interior decor is very calming and conveys a sense of Zen.
Sushi choices are plentiful and good. The food is always tasty but the price makes it a place for special occasion rather than your daily sushi fix.
If you've been to or used Sushi Roku, leave a review.


Jeremy Stockman, general manager of Watson's Wine in Hong Kong, is a judge in the Decanter Asia Wine Awards 2018.
Watson's Wine's General Manager Jeremy Stockman started his career in the wine industry in 1989 in London after completing a degree in economics. Following on from this, Jeremy moved to Australia to work for Coles Liquor Group, holding several positions in the management of wine during his fifteen years there.
In his marketing manager role, one of Jeremy's highlights was having the opportunity to grow the Vintage Cellars fine wine stores chain into a national brand with a unique range from around the world.
In 2010 Jeremy moved to Hong Kong and has been with Watson's Wine ever since. Jeremy holds a diploma in wine and has judged at many wine shows in Australia, New Zealand & Europe.


text:
Home » » 3815 MW Grid Connected Renewable Capacity Added During 2011
3815 MW Grid Connected Renewable Capacity Added During 2011
Written By Krishna on Friday, December 30, 2011 | 8:23 PM
Year End Review – 2011
High lights of the year 2011
· The Ministry of New and Renewable Energy has intensified the deployment of various renewable energy technologies in the country for grid connected power generation and to improve energy access in rural areas.
· In the recent competitive solar tariff bidding, the tariff quoted are 50% less than they were when the Jawaharlal Nehru National Solar Mission was launched just two years ago.
· Renewable power is now being extensively propagated and used to provide energy access to the remote, inaccessible and difficult areas of the country. During 2011 around 965 villages have been covered with solar lights and 30 villages have been covered with biomass gasifiers.
· The Ministry has undertaken an intensive exercise during the year to review its programmes through various working groups set up for preparation of the 12th Plan. The Ministry is envisaging a capacity addition of about 30,000 MW from renewable during the 12th Plan.
Major Achievements in 2011
The Year 2011 has seen a significant growth with a number of new initiatives in the renewable energy sector. The wind energy sector picked up momentum again by adding over 2800 MW capacity resulting in grid-connected renewable power capacity crossed the 22,000 MW milestone which is about 11% of the total power generation capacity of the country. During the year grid-connected solar power plants crossing the 100 MW milestone. In fact, SPV power plants of over 180 MW were set up in the country. Over 1000 remote villages were electrified through renewable energy systems during this year. Over 50 MW off-grid installations were completed. Another initiative of the Ministry was to launch a comprehensive project to popularize renewable energy systems in the Ladakh
Jawaharlal Nehru National Solar Mission
The Mission aims at adding 20,000 MW solar power capacity in the country by 2022. Implementation of the Phase – I of the Mission started during the year. One of the target areas is promotion of grid-connected solar power in a big way with the objective to bring cost of solar power generation to grid parity levels. In this year 180 MW of grid-connected solar power projects have been commissioned in the country and this figure will cross 400 MW by the end of this financial year. Projects totaling 350 MW have been allotted in batch-II of phase–I in December,2011 through competitive bidding. The tariff quoted are amongst lowest tariffs anywhere in the World with an average Rs.8.77 per kWh and a bid lowest of Rs.7.49 per kWh. If compared with the tariffs of over Rs.18 per kWh at the start of the Mission, this is a reduction of more than 50%.
The Ministry is giving special focus on research in solar energy. 36 R&D projects in solar thermal and photovoltaic technologies are under implementation. A Centre for Solar Thermal Research has been set up at IIT Rajasthan, Jodhpur. Under R&D Projects sponsored to industries in public-private partnership mode, a 30 ton Solar air conditioning system using concentrating parabolic troughs and triple effect vapor absorption machine has been developed and demonstrated at Solar Energy Centre, MNRE. It is a stand-alone system for day time use and can take care of intermittent clouds through small storage. The system once tested for its satisfactory performance, could be useful for offices and institutions working during day time when solar radiation is also available. In another project, a State of the Art fully automatically tracked paraboloid dish of 90 sq. m. area has also been developed and demonstrated at Solar Energy Centre. The dish is expected to find good opportunity in industries for processed heat applications as it is installed on a pillar and the space below dish could be utilized for other purposes.
Grid Connected Renewable Power
A capacity addition of 3815 MW have been achieved during 2011 from various renewable energy sources. This includes 2827 MW from wind, 310 MW from small hydro, 498 MW from biomass and 180 MW from solar energy. With this, the total installed capacity from renewable has reached 22,447 MW.
Wind power is the fastest growing renewable energy option today. A total capacity of 15,880 MW of wind power has been installed in the country. The progress during the current year has been very good. A capacity of around 2827 MW has been installed during the year. It is expected that it will touch around 3500 MW upto March,2012. It would be a significant improvement as compared to figures of 1485, 1565 and 2350 MW in 2008-09, 2009-10, 2010-11 respectively. As per the recommendations of Working Group for 12th Plan, a target of 15,000 MW has been proposed for 12th Plan.
The Small hydro power programme in India is now by and large private investment driven. 24 States have announced their policies to invite private sector to set up SHP projects. Since SHP projects have reasonably good economic viability, a number of financial institutions and banks are ready to finance these projects. Accordingly, a major part of capacity addition and exploitation of SHP potential in future is expected from private sector projects. With a capacity addition of 310 MW during 2011, the total installed capacity from SHP projects is 3210 MW. The Ministry is also focusing on developing micro hydel projects and watermills for electrification of remote areas. As per the recommendations of Working Group for 12th Plan, a target of 2,100 MW has been proposed for 12th Plan.
The Biomass Power and Bagasse Co-generation Programme is implemented with the main objective of promoting technologies for optimum use of country's biomass resources for grid power generation and maximizing power generation from bagasse produced in sugar mills. During 2011 a capacity of 498 MW have been added. The cumulative biomass power/bagasse cogeneration based power capacity has reached 3056 MW. During the year the Ministry has continued the existing scheme with two modification related to (a) Cogeneration projects through Build, Own, Operate, Transfer (BOOT) model in cooperative sugar mill (b) Boiler upgradation of cogeneration projects in cooperative sugar mills. A target of 2600 MW is proposed for the 12th Plan period.
Off - Grid Renewable Energy applications
Energy Access: Renewable power is now being extensively propagated and used to provide energy access to the remote, inaccessible and difficult areas of the country. Lakhs of solar lights, solar water heating systems ,biogas plants have been installed in the country and so far over 9000 remote villages have been illuminated through solar photovoltaic systems and biomass gasifiers
Biomass Gasifier: During the year, the Ministry has promoted multifaceted Biomass Gasifier with a view to utilize locally available surplus biomass resources such as rice husk, corn cab & stalks, arhar stalks, cotton stalks, small wood chips, other agro-residues available in surplus to meet the unmet demand of electricity for villages for lighting, water pumping and micro enterprises. In addition, it is promoting small biomass gasifier and combustion based power plants up to 2 MW capacities connected at the tail end of grid and captive power and thermal applications in rice mills and other industries. The Ministry is focusing on promoting rice husk based gasifier projects for decentralized and distributed power generation to provide unmet demand of electricity in villages.
During 2011, about 70 remote villages/hamlets of Bihar in District East Champaran, West Champaran, Muzaffarpur and Sitamarhi benefited by installation of about 25 rice husk based gasifier systems for distributed power generation based on a sustainable model. In addition, about 120 rice husk gasifier systems are under installation in various villages of Bihar. In addition, about 30 rice mills have installed rice husk gasifier systems retrofitted with existing diesel generating sets saving about 13 lakh liters of diesel annually and installation are underway in about 60 rice mills in different States. During the year, biomass gasifier based tail end grid connected projects of 1.20 MW in Gujarat and 500 kW in Tamil Nadu have been successfully installed.
Biogas : The National Biogas and Manure Management Programme of the Ministry mainly caters to setting up of family type biogas plants for meeting the cooking energy needs in rural areas of the country. During the year, about 45000 family type biogas plants have been installed. With this the cumulative installation of 4.44 million family type biogas plants, about 35.70% of the estimated potential has been realized so far. Apart from setting up family type biogas plants, the Ministry started a new initiative for demonstration of Integrated Technology package in entrepreneurial mode on medium size mixed feed Biogas-Fertilizer Plants (BGFP) for generation, purification/enrichment, bottling and piped distribution of biogas. 21 such projects with aggregate capacity of 37016 cum/day have been sanctioned, out of which 2 BGFP projects have been commissioned. Under Biogas based Distributed/Grid Power Generation Programme (BPGP) so far 158 projects have been commissioned with a total installed capacity of about 2 MW.
Remote Village Electrification: The Ministry is implementing Remote Village Electrification Programme for providing financial support for lighting/basic electrification through various renewable sources, to those remote unelectrified census villages and unelectrified hamlets of electrified census villages where grid extension is found not feasible by the State Governments and hence are not covered under the Rajiv Gandhi Gramin Vidyutikaran Yojna. The programme is implemented in States by the State notified implementing agencies. During the current year, 836 remote villages and hamlets have been completed.
Electrification/illumination of border Villages of Arunachal Pradesh: Implementation of the project for electrification/ illumination of border Villages of Arunachal Pradesh further progressed and out of 1058 villages, 726 villages have been illuminated / electrified. These include, 523 villages, where all households have been provided with solar home lighting systems and balance villages are given electricity from small / micro hydel projects. Further, work in 107 new micro/ small hydro projects is in progress. The project is being monitored by a Steering committee and is targeted to be completed by March, 2012.
Ladakh Renewable Energy Initiative: The Ministry has initiated the implementation of a Rs. 473 crore Special Project for the Ladakh region for large scale use of renewable energy systems in order to provide energy access and minimize use of diesel in the most difficult part of the country and thereby open the doors for coverage of other similar areas. Solar PV lights and solar water heating systems have been intensively promoted in the last one year and 28 villages and 78 institutions in the district stand covered through solar power plants with over 90% house hold coverage. 930 households are using solar water heaters even at sub-zero temperature for their hot water needs. Over 1800 green houses have also been constructed for growing vegetables.
Human Resource Development: In view of rapid growth of renewable energy sector in the country, Ministry has initiated the process to institutionalize the renewable energy education in the country to enable the existing educational institutions to introduce courses related to renewable energy in their regular curriculum. With this initiation, solar street lights, solar hot water systems and small hydro have already been incorporated in the two-year ITI syllabus. Course material for this has been developed and faculty of it is now being trained. In addition, State Renewable Energy Agencies are being supported to organize short-term training programmes for installation, operation and maintenance and repair of renewable energy systems in such places where intensive RE programme are being implemented. Renewable Energy Chairs have been established in IIT Roorkee and IIT Kharagpur.
National Solar Science Fellowship Programme has been launched and process for selection for the National Solar Science Fellows initiated. These efforts, while generating pool of trained manpower at all levels, will also create a system, under which the ensuing requirement of qualified and trained personnel will be met in future. Solar Energy Centre of the Ministry in collaboration with the Ministry of External Affairs has been providing training to participants from different developing countries.
Renewable Energy and Climate Change:
Renewable energy is central to climate change mitigation efforts. Broad estimates indicate that mitigation from existing renewable energy portfolio is equivalent to around 4-5% of total energy related emissions in the country. Further, the vast market potential and well-developed industrial, financing and business infrastructure, has made India a favorable destination for Clean Development Mechanism (CDM) projects, with renewable energy projects having the major share. National renewable energy plans offer ample opportunity for CDM projects and technological innovations.
India had 727 registered CDM projects, which is around 21% of worldwide registered projects. With 520 projects, renewable constitute around 72% Indian CDM registered projects. Within renewable, wind has the maximum number of 225 projects followed by hydro 82 and 6 for solar energy.


text:
SOEMUSIC
Go direct to the MUSIC
SOEMUSIC presents the music of singer, songwriter, producer and composer Steve Marshall.
JUST STEPHEN
SOEMUSIC embodies the music creation of singer, songwriter, composer and producer, Steve Marshall.
Notably, Steve produced three classic albums with Jamaican legend Lee "Scratch" Perry. Two of these received Grammy nominations. Working with Lee led to projects with Rolling Stone Keith Richards and Godfather of Funk, George Clinton, including mixing Keith Richards' cover of the Gregory Isaacs classic, Love Overdue.
As co-founder of Pyramid Arts Development in East London, Steve performed, recorded and wrote with artists from around the world, including Clifford Jarvis (USA), Alan Weekes (UK), Clive Roper (Jamaica), Ernest Mothle (South Africa), and Jimmy Scott (Nigeria). He was also involved in the development of British hip-hop at grass roots level. These associations with jazz, reggae, soul, RnB, hip-hop, Afro-fusion, rock and electronic music have proved to be a great foundation.
Out of Pyramid, he set up State of Emergency with Deborah Baddoo, which marked the beginning of a long association with dance theatre. His score for Desert Crossings achieved critical acclaim, and the show toured in South Africa, Canada, Germany and the UK. He also composed the score for dance theatre productions Love&Sex, Choices And Consequences and most recently Where Is Home? which toured in the UK, South Africa and the USA.
Recent visits to Los Angeles, Tokyo and Johannesburg have helped to build his reputation as an original artist.
Photo by Irven Lewis
"intuitio: anima pulchera cultura"
State of Emergency Limited
johnsaxon@stateofemergencyltd.com
© 2021 SOEMUSIC