Meta Manual
Meta-Essentials is a free tool for meta-analysis. It facilitates the integration and synthesis of effect sizes from different studies. The tool consists of a set of workbooks designed for Microsoft Excel that, based on your input, automatically produces all the required statistics, tables, figures, and more. The workbooks can be downloaded from here. We also provide a user manual to guide you in using the tool (PDF / online) and a text on how to interpret the results of meta-analyses (PDF / online).
Meta-Essentials has evolved into a tool that can be used for both research and teaching purposes. Especially for relatively straightforward meta-analyses (excluding for instance meta-regressions and meta-sem), Meta-Essentials is a very easy and intuitive tool to use.
View the manual for the KEF LS50 META here, for free. This manual comes under the category Speakers and has been rated by 1 people with an average of a 7.5. This manual is available in the following languages: English. Do you have a question about the KEF LS50 META or do you need help? This guide shows you how to conduct meta-analyses in R from scratch. The focus of this guide is primarily on clinical outcome research in psychology. It was designed for staff and collaborators of the Protect Lab, which is headed by Prof. The guide will show you how to. EUROKERA ELECTRIC HOB MANUALS DOWNLOAD EUROKERA ELECTRIC HOB MANUALS READ ONLINE Manuals for the category Hobs. Find your specific model and download the manual or view frequently asked questions. Below you can find all brands of Hobs for which we have manuals available. Click on your brand for a list of all models. This is a manual for Wikimedia chapters.It is divided into several parts corresponding to the tasks in a chapter. Please contribute to this manual, by inserting answers, but also questions.
Please also see our Frequently Asked Questions. If you have any other questions, please do not hesitate to contact us.
We designed Meta-Essentials for Microsoft Excel. However, Meta-Essentials also works with the freely available WPS Office 2016 Free and Microsoft Excel Online (free registration required).
Introduction, comparison and validation of Meta-Essentials: A free and simple tool for meta-analysis
A paper describing the Meta-Essentials tool has been published in Research Synthesis Methods. Besides a general introduction and a more technical comparison to other meta-analysis tools, this paper also includes a short tutorial that you may find useful if you are just starting with meta-analysis in Meta-Essentials.
The workbooks and the user manual are licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. That means you can use, share, and adapt the tools all you want, as long as you properly attribute the original effort to us.
If you use this tool for any type of publication, please cite it as follows:
- Suurmond R, van Rhee, H, Hak T. (2017). Introduction, comparison and validation of Meta-Essentials: A free and simple tool for meta-analysis. Research Synthesis Methods. Vol. 8, Iss 4, 537-553. https://doi.org/10.1002/jrsm.1260.
However, if you refer to the material on the website or the user manual in particular, please cite as follows:
- Van Rhee, H.J., Suurmond, R., & Hak, T. (2015). User manual for Meta-Essentials: Workbooks for meta-analysis (Version 1.4) Rotterdam, The Netherlands: Erasmus Research Institute of Management. Retrieved from www.erim.eur.nl/research-support/meta-essentials
Meta is a C++11 tiny metaprogramming library developed by Eric Niebler to facilitate the computation and manipulation of types and lists of types (aka, variadic parameter packs).
It is released under the Boost Software License and it is header only; that is, to compile with meta you just have to:
The documentation of Meta is currently scarce. The best resources are the Reference and the Examples.
As a motivation and introduction to the library you can read Eric's original blog post, but please keep in mind that the library has evolved quite a bit since then.
Quick Start
TODO show some simple uses. Make sure we show what Meta is good for before diving into terminology and esoteric concepts.
Tutorial
Meta Manual Dg Shipping
The tutorial begins with a brief introduction to traits, aliases, and callables. Then it moves to trait composition and currying. Finally, it covers type list algorithms and algorithms for working on integer sequences.
TODO This feels backwards. Algorithms come first. Everything else is in support of them.
Traits
Traits are class templates that have a nested type alias called (by convention) type
. For example,
is a trait taking an arbitrary number of types that always 'returns' void
. There are many familiar examples of traits in the Standard Library; std::remove_reference
and std::is_void
to name two.
Aliases
An alias is a synonym for a type. C++11 introduced alias templates, which are names that refer to a family of types. Alias templates simplify template syntax and smooth out interface differences. Below is an example of an alias template:
Notice how t_t<int, double>
becomes a synonym for void
. The C++14 standard library provides _t
alias templates for all the traits in the standard library.
Meta provides meta::_t<T>
, which evaluates the trait T
by aliasing the nested T::type
alias. This allows us to alias the nested type
of a trait as follows:
- Note
- Alias templates have primacy in Meta. This is different from other metaprogramming libraries you may be familiar with, which make traits (aka metafunctions) the prime abstraction. The rest of this guide uses the term 'alias' to mean 'alias template'.
Callables
A Callable is a kind of alias suitable for higher-order metaprogramming. It is a class (not a template!) with a nested alias called (by convention) invoke
:
All of the algorithms that take 'functions' as arguments expect Callables instead of raw aliases. Meta provides the meta::invoke<F, Args...>
alias that evaluates the Callable F
with the arguments Args
:
To turn an ordinary alias into a Callable Meta provides the meta::quote<F>
trait:
Note that in the first case we create a Callable that evaluates to the trait itself, while in the second case we create a Callable that evaluates to the nested type
of the trait.
When 'quoting' a trait, it is often desirable for the resulting Callable to refer to the nested type
instead of the trait itself. For that we can use meta::quote_trait
. Consider:
Notice that meta::quote<std::add_pointer_t>
and meta::quote_trait<std::add_pointer>
mean the same thing.
- Note
- You may wonder what advantage Callables have over alias templates. A Callable is a type that represents a computation. Much of Meta revolves around types and the computation of types. Sometimes it's desirable to compute a computation, or to use a computation as an argument to another computation. In those cases, it's very handy for computations to themselves be types and not templates.
Composition
Multiple Callables can be composed into a single Callable using meta::compose<F0, F1, ..., FN>
, which names a new Callable that performs F0(F1(...(FN(Args...))))
:
Partial function application
You can turn a Callable expecting N arguments into a Callable expecting N-M arguments by binding M arguments to the front or the back of its argument list. You can use meta::bind_front
and meta::bind_back
for that. Below we create a Callable that tests whether a type is float
by reusing the std::is_same
trait:
- Note
- If
std::is_same
is a trait, why did we usemeta::quote
instead ofmeta::quote_trait
? In this case, it makes no difference. In addition to being a trait,std::is_same<X, Y>
inherits fromstd::integral_constant<bool, true-or-false>
so we can construct an instance ofstd::is_same<X, Y>
and test it in aconstexr
Boolean context.
Logical operations
The traits meta::if_
, meta::and_
, meta::or_
, and meta::not_
cover the basic logical operations with types:
Eager and lazy evaluation
TODO aliases are eager, meta::defer
, meta::lazy
namespace.
Lambdas
Lambda functions allow you to define Callables in place:
Type lists
A list of types Ts...
can be stored in the type meta::list<Ts...>
. It provides a O(1) static member function meta::list::size()
that returns the size of the list.
As you can see, the meta::front<List>
, meta::back<List>
, and meta::at_c<List, std::size_t>
aliases provide access to the elements of the list. The meta::empty<List>
alias is std::true_type
if the list is empty. The meta::at<List, meta::size_t<N>>
alias differs from meta::at_c
in that it takes a meta::size_t<N>
(std::integral_constant<std::size_t, N>
) instead of an integer:
You can add and remove elements from a list by using the transformation algorithms:
Meta Manual Pdf
You can concatenate, flatten, and zip multiple lists using meta::concat<Lists...>
, meta::join<ListOfLists>
, and meta::zip<ListOfLists>
:
TODO: meta::zip_with
examples
Other typical operations on type lists include iteration, reductions, finding elements, removing duplicates:
To convert other type sequences into a meta::list
, the utility trait meta::as_list<Sequence>
is provided. For example:
Meta Manual Dg Shipping Free Download
To use meta with your own data types you can specialize the meta::extension::apply
trait for your own data type. For example, to use meta with C++14 std::integer_sequence
, you can:
Metatrader 4 Manual
Overview
This is a brief overview of the functionality in meta:
- Trait:
meta::_t
,meta::_v
,meta::invoke
,meta::defer
,meta::quote
,meta::quote_trait
,meta::id
,meta::compose
,meta::bind_front
,meta::bind_back
,meta::curry
,meta::uncurry
,meta::lambda
,meta::let
,meta::apply
. - List:
meta::list
,meta::front
,meta::back
,meta::at
,meta::at_c
.meta::empty
,meta::size
. - Logical:
meta::if_
,meta::and_
,meta::or_
,meta::not_
. - Query and search:
meta::all_of
,meta::any_of
,meta::none_of
,meta::in
,meta::find
,meta::reverse_find
,meta::find_if
,meta::reverse_find_if
,meta::cout
. - Transformation:
meta::concat
,meta::join
,meta::zip
,meta::zip_with
,meta::as_list
,meta::push_front
,meta::push_back
,meta::drop
,meta::drop_c
,meta::pop_front
,meta::fold
,meta::reverse_fold
,meta::accumulate
,meta::unique
,meta::replace
,meta::replace_if
,meta::filter
,meta::transform
,meta::reverse
,meta::cartesian_product
. - Math:
meta::plus
,meta::minus
,meta::multiplies
,meta::divides
,meta::negate
,meta::modulus
,meta::equal_to
,meta::not_equal_to
,meta::greater
,meta::less
,meta::greater_equal
,meta::less_equal
,meta::bit_and
,meta::bit_or
,meta::bit_xor
,meta::bit_not
,meta::min
,meta::max
,meta::inc
,meta::dec
. - Run time:
meta::for_each
.
See the reference section for more details.