コード例 #1
0
ファイル: overburn.hpp プロジェクト: dmilos/color
 static void process( model_type &result )
  {
   for( index_type index = 0; index < container_trait_type::size(); index ++ )
    {
     if( result.get( index ) <  bound_type::minimum( index ) )
      {
       result.set( index, bound_type::minimum( index ) );
       continue;
      }
     if(  bound_type::maximum( index ) < result.get( index ) )
      {
       result.set( index, bound_type::maximum( index ) );
       continue;
      }
    }
  }
コード例 #2
0
        void operator()(model_type& model, abstract_window_type& parent)
        const
        {
            if (!m_confirm_file_save(parent))
                return;

            model.reset_timetable(tetengo2::stdalt::make_unique<timetable_type>());
        }
コード例 #3
0
ファイル: overburn.hpp プロジェクト: lzs4073/color
 static index_type process( model_type const& m )
  {
   for( index_type index = 0; index < container_trait_type::size(); index ++ )
    {
     if( m.get( index ) <  bound_type::minimum( index ) )
      {
       return index;
       continue;
      }
     if(  bound_type::maximum( index ) < m.get( index ) )
      {
       return index;
       continue;
      }
    }
   return container_trait_type::size();
  }
コード例 #4
0
ファイル: l2.hpp プロジェクト: 0x0all/madlib
void
L2<Model, Hessian>::hessian(
        const model_type                    &model,
        const double                        &lambda, 
        hessian_type                        &hessian) 
{
    int n = model.rows();
    hessian += lambda * hessian.Identity(n, n);
    hessian(n-1, n-1) -= lambda;
}
コード例 #5
0
ファイル: l2.hpp プロジェクト: 0x0all/madlib
void
L2<Model, Hessian>::gradient(
        const model_type                    &model,
        const double                        &lambda, 
        model_type                          &gradient) 
{
    Index i;
    for (i = 0; i < model.rows()-1; i++)
        gradient(i) += lambda * model(i);
}
コード例 #6
0
ファイル: l2.hpp プロジェクト: 0x0all/madlib
double 
L2<Model, Hessian>::loss(
        const model_type                    &model, 
        const double                        &lambda) 
{
    Index i;
    double s = 0.;
    for (i = 0; i < model.rows()-1; i++)
        s += model(i) * model(i);
    return lambda * s / 2.;
}
コード例 #7
0
        void set_message_observers(
            const command_set_type&     command_set,
            diagram_view_type&          diagram_view,
            timetable_view_type&        timetable_down_view,
            timetable_view_type&        timetable_up_view,
            main_window_type&           main_window,
            const message_catalog_type& message_catalog
        )
        {
            m_model.observer_set().reset().connect(
                model_reset_observer_type{ m_model, diagram_view, timetable_down_view, timetable_up_view, main_window }
            );
            m_model.observer_set().changed().connect(
                model_changed_observer_type{
                    m_model, diagram_view, timetable_down_view, timetable_up_view, main_window
                }
            );

            set_diagram_view_message_observers(diagram_view, main_window, message_catalog);
            set_timetable_view_message_observers(
                timetable_down_view, main_window.get_timetable_down_view_picture_box()
            );
            set_timetable_view_message_observers(timetable_up_view, main_window.get_timetable_up_view_picture_box());

            main_window.size_observer_set().resized().connect(
                main_window_window_resized_observer_type{
                    diagram_view,
                    timetable_down_view,
                    timetable_up_view,
                    main_window,
                    main_window.get_tab_frame(),
                    main_window.get_diagram_view_picture_box(),
                    main_window.get_timetable_down_view_picture_box(),
                    main_window.get_timetable_up_view_picture_box(),
                    main_window.get_property_bar()
                }
            );
            main_window.file_drop_observer_set().file_dropped().connect(
                main_window_file_dropped_observer_type{ command_set, m_model, main_window }
            );
        }
コード例 #8
0
        void execute(model_type& model, abstract_window_type& parent)
        const
        {
            file_property_dialog_type dialog{ parent, m_message_catalog };

            dialog.set_company_name(model.timetable().company_name());
            dialog.set_line_name(model.timetable().line_name());
            dialog.set_note(model.timetable().note());
            if (model.has_path())
                dialog.set_file_name(model.path().template string<string_type>());

            dialog.do_modal();
            if (dialog.result() != dialog_type::result_type::accepted)
                return;

            model.timetable().set_company_name(dialog.company_name());
            model.timetable().set_line_name(dialog.line_name());
            model.timetable().set_note(dialog.note());
        }
コード例 #9
0
ファイル: RangeDecoder.hpp プロジェクト: srl147/libmaus
			unsigned int decode(model_type const & model)
			{
				uint32_t const Count = GetCurrentCount(model.getTotal());

				unsigned int Symbol;
				for(Symbol=model.getSigma()-1;model.getLow(Symbol)>Count;Symbol--)
				{
				}

				RemoveRange(model.getLow(Symbol),model.getHigh(Symbol),model.getTotal());
						
				return Symbol;
			}
コード例 #10
0
        void operator()(
            model_type&                                                           model,
            const tetengo2::stdalt::optional<tetengo2::stdalt::filesystem::path>& given_path,
            abstract_window_type&                                                 parent) const
        {
            if (!m_ask_file_path && !model.has_path() && !given_path)
                return;

            if (!m_confirm_file_save(parent))
                return;

            tetengo2::stdalt::filesystem::path path{};
            if (given_path)
            {
                path = *given_path;
            }
            else if (m_ask_file_path)
            {
                file_open_dialog_type dialog{ m_message_catalog.get(TETENGO2_TEXT("Dialog:FileOpenSave:Open")),
                                              make_file_filters(),
                                              parent };
                const auto            ok = dialog.do_modal();
                if (!ok)
                    return;

                path = dialog.result();
            }
            else
            {
                assert(model.has_path());
                path = model.path();
            }

            std::ifstream input_stream{ path, std::ios_base::binary };
            if (!input_stream)
            {
                create_cant_open_file_message_box(path, parent)->do_modal();
                return;
            }

            reader_selector_type reader_selector{ reader_set_type::create_readers(
                parent, path.template string<typename string_type::value_type>(), m_message_catalog) };
            const auto           first = tetengo2::iterator::make_observable_forward_iterator(
                boost::spirit::make_default_multi_pass(std::istreambuf_iterator<char>{ input_stream }));
            const auto last = tetengo2::iterator::make_observable_forward_iterator(
                boost::spirit::make_default_multi_pass(std::istreambuf_iterator<char>{}));
            auto error = reader_error_type::none;
            auto p_timetable = reader_selector.read(first, last, error);
            if (!p_timetable)
            {
                switch (error)
                {
                case reader_error_type::canceled:
                    break; // Do nothing.
                case reader_error_type::corrupted:
                    create_file_broken_message_box(path, parent)->do_modal();
                    break;
                case reader_error_type::unsupported:
                    create_unsupported_format_file_message_box(path, parent)->do_modal();
                    break;
                default:
                    assert(false);
                    BOOST_THROW_EXCEPTION(std::logic_error("Unknown reader error."));
                }
                return;
            }

            model.reset_timetable(std::move(p_timetable), path);
        }
コード例 #11
0
 bool reloadable(
     const model_type&                                                     model,
     const tetengo2::stdalt::optional<tetengo2::stdalt::filesystem::path>& given_path) const
 {
     return m_ask_file_path || model.has_path() || given_path;
 }
コード例 #12
0
ファイル: state_space.hpp プロジェクト: martindemko/pepmc2
	value_type value(std::size_t dim, State const & state, Param const & param) const
	{
		return m_model.value(dim, real_state<State const &>(*this, state), param);
	}
コード例 #13
0
ファイル: maroon.hpp プロジェクト: dmilos/color
         inline static void process( container_output_type & container )
          {
           static model_type  s_model{ rgb_type{ 0.69, 0.19, 0.38 } };

           container = s_model.container();
          }
コード例 #14
0
ファイル: fuchsia.hpp プロジェクト: dmilos/color
 inline static void process( container_output_type & container )
  {
   static model_type  s_model{ rgb_type{ 1, 0, 1 } };
   container = s_model.container();
  } 
コード例 #15
0
ファイル: RangeDecoder.hpp プロジェクト: srl147/libmaus
			unsigned int decodeUpdate(model_type & model)
			{
				unsigned int const Symbol = decode(model);
				model.update(Symbol);
				return Symbol;
			}
コード例 #16
0
ファイル: pink.hpp プロジェクト: dmilos/color
 inline static void process( container_output_type & container )
  {
   static model_type  s_model{ rgb_type{ 0xFF, 0xC0, 0xCB } };
   container = s_model.container();
  } 
コード例 #17
0
ファイル: aquamarine.hpp プロジェクト: dmilos/color
 inline static void process( container_output_type & container )
  {
   static model_type  s_model{ rgb_type{ 0.5, 1, 212.0/255.0 } };
   container = s_model.container();
  } 
コード例 #18
0
ファイル: crimson.hpp プロジェクト: dmilos/color
 inline static void process( container_output_type & container )
  {
   static model_type  s_model{ rgb_type{ 0xDC, 0x14, 0x3C } };
   container = s_model.container();
  }