Clean up doxygen and source

2024-11-22 08:54:35 +00:00 · 2015-08-02 01:39:00 +02:00 · 2015-08-02 01:39:00 +02:00 · e0c4a71016
commit e0c4a71016
parent 96824ffcf5
33 changed files with 1025 additions and 1127 deletions
--- a/doc/man.doxy
+++ b/doc/man.doxy
@ -1,4 +1,4 @@
-# Doxyfile 1.8.8
+# Doxyfile 1.8.10

 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@ -32,7 +32,7 @@ DOXYFILE_ENCODING      = UTF-8
 # title of most generated pages and in a few other places.
 # The default value is: My Project.

-PROJECT_NAME           = 0.9.6
+PROJECT_NAME           = 0.9.7

 # The PROJECT_NUMBER tag can be used to enter a project or revision number. This
 # could be handy for archiving the generated documentation or if some version
@ -46,10 +46,10 @@ PROJECT_NUMBER         =

 PROJECT_BRIEF          = 

-# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
-# the documentation. The maximum height of the logo should not exceed 55 pixels
-# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
-# to the output directory.
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.

 PROJECT_LOGO           = E:/Source/G-Truc/glm/doc/logo.png

@ -60,7 +60,7 @@ PROJECT_LOGO           = E:/Source/G-Truc/glm/doc/logo.png

 OUTPUT_DIRECTORY       = .

-# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
 # directories (in 2 levels) under the output directory of each output format and
 # will distribute the generated files over these directories. Enabling this
 # option can be useful when feeding doxygen a huge amount of source files, where
@ -93,14 +93,14 @@ ALLOW_UNICODE_NAMES    = NO

 OUTPUT_LANGUAGE        = English

-# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
 # descriptions after the members that are listed in the file and class
 # documentation (similar to Javadoc). Set to NO to disable this.
 # The default value is: YES.

 BRIEF_MEMBER_DESC      = NO

-# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
 # description of a member or function before the detailed description
 #
 # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
@ -145,7 +145,7 @@ ALWAYS_DETAILED_SEC    = NO

 INLINE_INHERITED_MEMB  = NO

-# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
 # before files name in the file list and in the header files. If set to NO the
 # shortest path that makes the file name unique will be used
 # The default value is: YES.
@ -215,9 +215,9 @@ MULTILINE_CPP_IS_BRIEF = NO

 INHERIT_DOCS           = YES

-# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
-# new page for each member. If set to NO, the documentation of a member will be
-# part of the file/class/namespace that contains it.
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
 # The default value is: NO.

 SEPARATE_MEMBER_PAGES  = NO
@ -286,7 +286,7 @@ OPTIMIZE_OUTPUT_VHDL   = NO
 # instance to make doxygen treat .inc files as Fortran files (default is PHP),
 # and .f files as C (default is Fortran), use: inc=Fortran f=C.
 #
-# Note For files without extension you can use no_extension as a placeholder.
+# Note: For files without extension you can use no_extension as a placeholder.
 #
 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
 # the files are not read by doxygen.
@ -305,8 +305,8 @@ MARKDOWN_SUPPORT       = YES

 # When enabled doxygen tries to link words that correspond to documented
 # classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by by putting a % sign in front of the word
-# or globally by setting AUTOLINK_SUPPORT to NO.
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
 # The default value is: YES.

 AUTOLINK_SUPPORT       = YES
@ -346,13 +346,20 @@ SIP_SUPPORT            = NO
 IDL_PROPERTY_SUPPORT   = YES

 # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES, then doxygen will reuse the documentation of the first
+# tag is set to YES then doxygen will reuse the documentation of the first
 # member in the group (if any) for the other members of the group. By default
 # all members of a group must be documented explicitly.
 # The default value is: NO.

 DISTRIBUTE_GROUP_DOC   = NO

+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
 # Set the SUBGROUPING tag to YES to allow class member groups of the same type
 # (for instance a group of public functions) to be put as a subgroup of that
 # type (e.g. under the Public Functions section). Set it to NO to prevent
@ -411,7 +418,7 @@ LOOKUP_CACHE_SIZE      = 0
 # Build related configuration options
 #---------------------------------------------------------------------------

-# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
 # documentation are documented, even if no documentation was available. Private
 # class members and static file members will be hidden unless the
 # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
@ -421,35 +428,35 @@ LOOKUP_CACHE_SIZE      = 0

 EXTRACT_ALL            = NO

-# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
 # be included in the documentation.
 # The default value is: NO.

 EXTRACT_PRIVATE        = NO

-# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
 # scope will be included in the documentation.
 # The default value is: NO.

 EXTRACT_PACKAGE        = NO

-# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
 # included in the documentation.
 # The default value is: NO.

 EXTRACT_STATIC         = YES

-# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
-# locally in source files will be included in the documentation. If set to NO
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
 # only classes defined in header files are included. Does not have any effect
 # for Java sources.
 # The default value is: YES.

 EXTRACT_LOCAL_CLASSES  = NO

-# This flag is only useful for Objective-C code. When set to YES local methods,
+# This flag is only useful for Objective-C code. If set to YES, local methods,
 # which are defined in the implementation section but not in the interface are
-# included in the documentation. If set to NO only methods in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
 # included.
 # The default value is: NO.

@ -474,21 +481,21 @@ HIDE_UNDOC_MEMBERS     = YES

 # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
 # undocumented classes that are normally visible in the class hierarchy. If set
-# to NO these classes will be included in the various overviews. This option has
-# no effect if EXTRACT_ALL is enabled.
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
 # The default value is: NO.

 HIDE_UNDOC_CLASSES     = YES

 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO these declarations will be
+# (class|struct|union) declarations. If set to NO, these declarations will be
 # included in the documentation.
 # The default value is: NO.

 HIDE_FRIEND_COMPOUNDS  = YES

 # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
-# documentation blocks found inside the body of a function. If set to NO these
+# documentation blocks found inside the body of a function. If set to NO, these
 # blocks will be appended to the function's detailed documentation block.
 # The default value is: NO.

@ -502,7 +509,7 @@ HIDE_IN_BODY_DOCS      = YES
 INTERNAL_DOCS          = NO

 # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES upper-case letters are also
+# names in lower-case letters. If set to YES, upper-case letters are also
 # allowed. This is useful if you have classes or files whose names only differ
 # in case and if your file system supports case sensitive file names. Windows
 # and Mac users are advised to set this option to NO.
@ -511,12 +518,19 @@ INTERNAL_DOCS          = NO
 CASE_SENSE_NAMES       = YES

 # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
-# their full class and namespace scopes in the documentation. If set to YES the
+# their full class and namespace scopes in the documentation. If set to YES, the
 # scope will be hidden.
 # The default value is: NO.

 HIDE_SCOPE_NAMES       = YES

+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
 # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
 # the files that are included by a file in the documentation of that file.
 # The default value is: YES.
@ -544,14 +558,14 @@ INLINE_INFO            = NO

 # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
 # (detailed) documentation of file and class members alphabetically by member
-# name. If set to NO the members will appear in declaration order.
+# name. If set to NO, the members will appear in declaration order.
 # The default value is: YES.

 SORT_MEMBER_DOCS       = YES

 # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
 # descriptions of file, namespace and class members alphabetically by member
-# name. If set to NO the members will appear in declaration order. Note that
+# name. If set to NO, the members will appear in declaration order. Note that
 # this will also influence the order of the classes in the class list.
 # The default value is: NO.

@ -596,27 +610,25 @@ SORT_BY_SCOPE_NAME     = YES

 STRICT_PROTO_MATCHING  = NO

-# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
-# todo list. This list is created by putting \todo commands in the
-# documentation.
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
 # The default value is: YES.

 GENERATE_TODOLIST      = YES

-# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
-# test list. This list is created by putting \test commands in the
-# documentation.
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
 # The default value is: YES.

 GENERATE_TESTLIST      = YES

-# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
 # list. This list is created by putting \bug commands in the documentation.
 # The default value is: YES.

 GENERATE_BUGLIST       = YES

-# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
 # the deprecated list. This list is created by putting \deprecated commands in
 # the documentation.
 # The default value is: YES.
@ -641,8 +653,8 @@ ENABLED_SECTIONS       =
 MAX_INITIALIZER_LINES  = 30

 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
-# the bottom of the documentation of classes and structs. If set to YES the list
-# will mention the files that were used to generate the documentation.
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
 # The default value is: YES.

 SHOW_USED_FILES        = NO
@ -706,7 +718,7 @@ CITE_BIB_FILES         =
 QUIET                  = NO

 # The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
 # this implies that the warnings are on.
 #
 # Tip: Turn warnings on while writing the documentation.
@ -714,7 +726,7 @@ QUIET                  = NO

 WARNINGS               = YES

-# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
 # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
 # will automatically be disabled.
 # The default value is: YES.
@ -731,8 +743,8 @@ WARN_IF_DOC_ERROR      = YES

 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
 # are documented, but have no documentation for their parameters or return
-# value. If set to NO doxygen will only warn about wrong or incomplete parameter
-# documentation, but not about the absence of documentation.
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation.
 # The default value is: NO.

 WARN_NO_PARAMDOC       = NO
@ -760,7 +772,7 @@ WARN_LOGFILE           =
 # The INPUT tag is used to specify the files and/or directories that contain
 # documented source files. You may enter file names like myfile.cpp or
 # directories like /usr/src/myproject. Separate the files or directories with
-# spaces.
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.

 INPUT                  = ../glm \
@ -777,12 +789,17 @@ INPUT_ENCODING         = UTF-8

 # If the value of the INPUT tag contains directories, you can use the
 # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank the
-# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
-# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
-# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
-# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
-# *.qsf, *.as and *.js.
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd,
+# *.vhdl, *.ucf, *.qsf, *.as and *.js.

 FILE_PATTERNS          = *.hpp \
                         *.doxy
@ -882,7 +899,7 @@ INPUT_FILTER           =
 FILTER_PATTERNS        = 

 # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER ) will also be used to filter the input files that are used for
+# INPUT_FILTER) will also be used to filter the input files that are used for
 # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
 # The default value is: NO.

@ -942,7 +959,7 @@ REFERENCED_BY_RELATION = YES
 REFERENCES_RELATION    = YES

 # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
-# to YES, then the hyperlinks from functions in REFERENCES_RELATION and
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
 # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
 # link to the documentation.
 # The default value is: YES.
@ -989,25 +1006,6 @@ USE_HTAGS              = NO

 VERBATIM_HEADERS       = YES

-# If the CLANG_ASSISTED_PARSING tag is set to YES, then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
-# Note: The availability of this option depends on whether or not doxygen was
-# compiled with the --with-libclang option.
-# The default value is: NO.
-
-CLANG_ASSISTED_PARSING = NO
-
-# If clang assisted parsing is enabled you can provide the compiler with command
-# line options that you would normally use when invoking the compiler. Note that
-# the include paths will already be set by doxygen for the files and directories
-# specified with INPUT and INCLUDE_PATH.
-# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
-
-CLANG_OPTIONS          = 
-
 #---------------------------------------------------------------------------
 # Configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
@ -1038,7 +1036,7 @@ IGNORE_PREFIX          =
 # Configuration options related to the HTML output
 #---------------------------------------------------------------------------

-# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
 # The default value is: YES.

 GENERATE_HTML          = YES
@ -1104,10 +1102,10 @@ HTML_STYLESHEET        =
 # cascading style sheets that are included after the standard style sheets
 # created by doxygen. Using this option one can overrule certain style aspects.
 # This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefor more robust against future updates.
+# standard style sheet and is therefore more robust against future updates.
 # Doxygen will copy the style sheet files to the output directory.
-# Note: The order of the extra stylesheet files is of importance (e.g. the last
-# stylesheet in the list overrules the setting of the previous ones in the
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
 # list). For an example see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.

@ -1124,7 +1122,7 @@ HTML_EXTRA_STYLESHEET  =
 HTML_EXTRA_FILES       = 

 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
-# will adjust the colors in the stylesheet and background images according to
+# will adjust the colors in the style sheet and background images according to
 # this color. Hue is specified as an angle on a colorwheel, see
 # http://en.wikipedia.org/wiki/Hue for more information. For instance the value
 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
@ -1155,8 +1153,9 @@ HTML_COLORSTYLE_GAMMA  = 80

 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
 # page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: YES.
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.

 HTML_TIMESTAMP         = NO
@ -1252,28 +1251,28 @@ GENERATE_HTMLHELP      = NO
 CHM_FILE               = 

 # The HHC_LOCATION tag can be used to specify the location (absolute path
-# including file name) of the HTML help compiler ( hhc.exe). If non-empty
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
 # doxygen will try to run the HTML help compiler on the generated index.hhp.
 # The file has to be specified with full path.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.

 HHC_LOCATION           = 

-# The GENERATE_CHI flag controls if a separate .chi index file is generated (
-# YES) or that it should be included in the master .chm file ( NO).
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the master .chm file (NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.

 GENERATE_CHI           = NO

-# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
 # and project file content.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.

 CHM_INDEX_ENCODING     = 

-# The BINARY_TOC flag controls whether a binary table of contents is generated (
-# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
 # enables the Previous and Next buttons.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
@ -1387,7 +1386,7 @@ DISABLE_INDEX          = NO
 # index structure (just like the one that is generated for HTML Help). For this
 # to work a browser that supports JavaScript, DHTML, CSS and frames is required
 # (i.e. any modern browser). Windows users are probably better off using the
-# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
 # further fine-tune the look of the index. As an example, the default style
 # sheet generated by doxygen has an example that shows how to put an image at
 # the root of the tree instead of the PROJECT_NAME. Since the tree basically has
@ -1415,7 +1414,7 @@ ENUM_VALUES_PER_LINE   = 4

 TREEVIEW_WIDTH         = 250

-# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
 # external symbols imported via tag files in a separate window.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
@ -1444,7 +1443,7 @@ FORMULA_TRANSPARENT    = YES

 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
 # http://www.mathjax.org) which uses client side Javascript for the rendering
-# instead of using prerendered bitmaps. Use this if you do not have LaTeX
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
 # installed or if you want to formulas look prettier in the HTML output. When
 # enabled you may also need to install MathJax separately and configure the path
 # to it using the MATHJAX_RELPATH option.
@ -1530,7 +1529,7 @@ SERVER_BASED_SEARCH    = NO
 # external search engine pointed to by the SEARCHENGINE_URL option to obtain the
 # search results.
 #
-# Doxygen ships with an example indexer ( doxyindexer) and search engine
+# Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
 # Xapian (see: http://xapian.org/).
 #
@ -1543,7 +1542,7 @@ EXTERNAL_SEARCH        = NO
 # The SEARCHENGINE_URL should point to a search engine hosted by a web server
 # which will return the search results when EXTERNAL_SEARCH is enabled.
 #
-# Doxygen ships with an example indexer ( doxyindexer) and search engine
+# Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
 # Xapian (see: http://xapian.org/). See the section "External Indexing and
 # Searching" for details.
@ -1581,7 +1580,7 @@ EXTRA_SEARCH_MAPPINGS  =
 # Configuration options related to the LaTeX output
 #---------------------------------------------------------------------------

-# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
 # The default value is: YES.

 GENERATE_LATEX         = NO
@ -1612,7 +1611,7 @@ LATEX_CMD_NAME         = latex

 MAKEINDEX_CMD_NAME     = makeindex

-# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
 # documents. This may be useful for small projects and may help to save some
 # trees in general.
 # The default value is: NO.
@ -1630,9 +1629,12 @@ COMPACT_LATEX          = NO
 PAPER_TYPE             = a4wide

 # The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. To get the times font for
-# instance you can specify
-# EXTRA_PACKAGES=times
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
 # If left blank no extra packages will be included.
 # This tag requires that the tag GENERATE_LATEX is set to YES.

@ -1647,9 +1649,9 @@ EXTRA_PACKAGES         =
 # Note: Only use a user-defined header if you know what you are doing! The
 # following commands have a special meaning inside the header: $title,
 # $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empy string,
-# for the replacement values of the other commands the user is refered to
-# HTML_HEADER.
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
 # This tag requires that the tag GENERATE_LATEX is set to YES.

 LATEX_HEADER           = 
@ -1665,6 +1667,17 @@ LATEX_HEADER           =

 LATEX_FOOTER           = 

+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET = 
+
 # The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
 # other source files which should be copied to the LATEX_OUTPUT output
 # directory. Note that the files will be copied as-is; there are no commands or
@ -1683,7 +1696,7 @@ LATEX_EXTRA_FILES      =
 PDF_HYPERLINKS         = NO

 # If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES to get a
+# the PDF file directly from the LaTeX files. Set this option to YES, to get a
 # higher quality PDF documentation.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
@ -1728,7 +1741,7 @@ LATEX_BIB_STYLE        = plain
 # Configuration options related to the RTF output
 #---------------------------------------------------------------------------

-# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
 # RTF output is optimized for Word 97 and may not look too pretty with other RTF
 # readers/editors.
 # The default value is: NO.
@ -1743,7 +1756,7 @@ GENERATE_RTF           = NO

 RTF_OUTPUT             = glm.rtf

-# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
 # documents. This may be useful for small projects and may help to save some
 # trees in general.
 # The default value is: NO.
@ -1780,11 +1793,21 @@ RTF_STYLESHEET_FILE    =

 RTF_EXTENSIONS_FILE    = 

+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
 #---------------------------------------------------------------------------
 # Configuration options related to the man page output
 #---------------------------------------------------------------------------

-# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
 # classes and files.
 # The default value is: NO.

@ -1828,7 +1851,7 @@ MAN_LINKS              = NO
 # Configuration options related to the XML output
 #---------------------------------------------------------------------------

-# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
 # captures the structure of the code including all documentation.
 # The default value is: NO.

@ -1842,7 +1865,7 @@ GENERATE_XML           = NO

 XML_OUTPUT             = xml

-# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
 # listings (including syntax highlighting and cross-referencing information) to
 # the XML output. Note that enabling this will significantly increase the size
 # of the XML output.
@ -1855,7 +1878,7 @@ XML_PROGRAMLISTING     = YES
 # Configuration options related to the DOCBOOK output
 #---------------------------------------------------------------------------

-# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
 # that can be used to generate PDF.
 # The default value is: NO.

@ -1869,7 +1892,7 @@ GENERATE_DOCBOOK       = NO

 DOCBOOK_OUTPUT         = docbook

-# If the DOCBOOK_PROGRAMLISTING tag is set to YES doxygen will include the
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
 # program listings (including syntax highlighting and cross-referencing
 # information) to the DOCBOOK output. Note that enabling this will significantly
 # increase the size of the DOCBOOK output.
@ -1882,10 +1905,10 @@ DOCBOOK_PROGRAMLISTING = NO
 # Configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------

-# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
-# Definitions (see http://autogen.sf.net) file that captures the structure of
-# the code including all documentation. Note that this feature is still
-# experimental and incomplete at the moment.
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sf.net) file that captures the
+# structure of the code including all documentation. Note that this feature is
+# still experimental and incomplete at the moment.
 # The default value is: NO.

 GENERATE_AUTOGEN_DEF   = NO
@ -1894,7 +1917,7 @@ GENERATE_AUTOGEN_DEF   = NO
 # Configuration options related to the Perl module output
 #---------------------------------------------------------------------------

-# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
 # file that captures the structure of the code including all documentation.
 #
 # Note that this feature is still experimental and incomplete at the moment.
@ -1902,7 +1925,7 @@ GENERATE_AUTOGEN_DEF   = NO

 GENERATE_PERLMOD       = NO

-# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
 # Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
 # output from the Perl module output.
 # The default value is: NO.
@ -1910,9 +1933,9 @@ GENERATE_PERLMOD       = NO

 PERLMOD_LATEX          = NO

-# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
 # formatted so it can be parsed by a human reader. This is useful if you want to
-# understand what is going on. On the other hand, if this tag is set to NO the
+# understand what is going on. On the other hand, if this tag is set to NO, the
 # size of the Perl module output will be much smaller and Perl will parse it
 # just the same.
 # The default value is: YES.
@ -1932,14 +1955,14 @@ PERLMOD_MAKEVAR_PREFIX =
 # Configuration options related to the preprocessor
 #---------------------------------------------------------------------------

-# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
 # C-preprocessor directives found in the sources and include files.
 # The default value is: YES.

 ENABLE_PREPROCESSING   = YES

-# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
-# in the source code. If set to NO only conditional compilation will be
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
 # performed. Macro expansion can be done in a controlled way by setting
 # EXPAND_ONLY_PREDEF to YES.
 # The default value is: NO.
@ -1955,7 +1978,7 @@ MACRO_EXPANSION        = NO

 EXPAND_ONLY_PREDEF     = NO

-# If the SEARCH_INCLUDES tag is set to YES the includes files in the
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
 # INCLUDE_PATH will be searched if a #include is found.
 # The default value is: YES.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
@ -2031,20 +2054,21 @@ TAGFILES               =

 GENERATE_TAGFILE       = 

-# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
-# class index. If set to NO only the inherited external classes will be listed.
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
 # The default value is: NO.

 ALLEXTERNALS           = NO

-# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
-# the modules index. If set to NO, only the current project's groups will be
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
 # listed.
 # The default value is: YES.

 EXTERNAL_GROUPS        = YES

-# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
 # the related pages index. If set to NO, only the current project's pages will
 # be listed.
 # The default value is: YES.
@ -2061,7 +2085,7 @@ PERL_PATH              = /usr/bin/perl
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------

-# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
 # (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
 # NO turns the diagrams off. Note that this option also works with HAVE_DOT
 # disabled, but it is recommended to install and use dot, since it yields more
@ -2086,7 +2110,7 @@ MSCGEN_PATH            =

 DIA_PATH               = 

-# If set to YES, the inheritance and collaboration graphs will hide inheritance
+# If set to YES the inheritance and collaboration graphs will hide inheritance
 # and usage relations if the target is undocumented or is not a class.
 # The default value is: YES.

@ -2119,7 +2143,7 @@ DOT_NUM_THREADS        = 0
 # The default value is: Helvetica.
 # This tag requires that the tag HAVE_DOT is set to YES.

-DOT_FONTNAME           = 
+DOT_FONTNAME           = Helvetica

 # The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
 # dot graphs.
@ -2159,7 +2183,7 @@ COLLABORATION_GRAPH    = YES

 GROUP_GRAPHS           = YES

-# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
 # collaboration diagrams in a style similar to the OMG's Unified Modeling
 # Language.
 # The default value is: NO.
@ -2211,7 +2235,8 @@ INCLUDED_BY_GRAPH      = YES
 #
 # Note that enabling this option will significantly increase the time of a run.
 # So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command.
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.

@ -2222,7 +2247,8 @@ CALL_GRAPH             = YES
 #
 # Note that enabling this option will significantly increase the time of a run.
 # So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command.
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
 # The default value is: NO.
 # This tag requires that the tag HAVE_DOT is set to YES.

@ -2245,11 +2271,15 @@ GRAPHICAL_HIERARCHY    = YES
 DIRECTORY_GRAPH        = YES

 # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot.
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
 # Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
 # to make the SVG files visible in IE 9+ (other browsers do not have this
 # requirement).
-# Possible values are: png, jpg, gif and svg.
+# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
 # The default value is: png.
 # This tag requires that the tag HAVE_DOT is set to YES.

@ -2297,10 +2327,14 @@ DIAFILE_DIRS           =
 # PlantUML is not used or called during a preprocessing step. Doxygen will
 # generate a warning when it encounters a \startuml command in this case and
 # will not generate output for the diagram.
-# This tag requires that the tag HAVE_DOT is set to YES.

 PLANTUML_JAR_PATH      = 

+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  = 
+
 # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
 # that will be shown in the graph. If the number of nodes in a graph becomes
 # larger than this value, doxygen will truncate the graph, which is visualized
@ -2337,7 +2371,7 @@ MAX_DOT_GRAPH_DEPTH    = 1000

 DOT_TRANSPARENT        = NO

-# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10) support
 # this, this feature is disabled by default.
@ -2354,7 +2388,7 @@ DOT_MULTI_TARGETS      = NO

 GENERATE_LEGEND        = YES

-# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
 # files that are used to generate the various graphs.
 # The default value is: YES.
 # This tag requires that the tag HAVE_DOT is set to YES.
--- a/glm/detail/type_mat2x2.hpp
+++ b/glm/detail/type_mat2x2.hpp
@ -65,8 +65,7 @@ namespace glm
 		col_type value[2];

 	public:
-		//////////////////////////////////////
-		// Constructors
+		// -- Constructors --

 		GLM_FUNC_DECL tmat2x2() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> const & m) GLM_DEFAULT;
@ -82,8 +81,7 @@ namespace glm
 			col_type const & v1,
 			col_type const & v2);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --

 		template <typename U, typename V, typename M, typename N>
 		GLM_FUNC_DECL tmat2x2(
@ -95,8 +93,7 @@ namespace glm
 			tvec2<U, P> const & v1,
 			tvec2<V, P> const & v2);

-		//////////////////////////////////////
-		// Matrix conversions
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x2<U, Q> const & m);
@ -110,8 +107,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -127,8 +123,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<T, P> const & v) GLM_DEFAULT;;

@ -151,8 +146,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(tmat2x2<U, P> const & m);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat2x2<T, P> & operator++ ();
 		GLM_FUNC_DECL tmat2x2<T, P> & operator-- ();
@ -160,7 +154,13 @@ namespace glm
 		GLM_FUNC_DECL tmat2x2<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x2<T, P> const operator-(tmat2x2<T, P> const & m);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T const & s);

@ -215,9 +215,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> const operator-(tmat2x2<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
 } //namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat2x2.inl
+++ b/glm/detail/type_mat2x2.inl
@ -50,8 +50,7 @@ namespace detail
 	}
 }//namespace detail

-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -110,8 +109,7 @@ namespace detail
 		this->value[1] = v1;
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversion constructors --

 	template <typename T, precision P>
 	template <typename X1, typename Y1, typename X2, typename Y2>
@ -133,8 +131,7 @@ namespace detail
 		this->value[1] = col_type(v2);
 	}

-	//////////////////////////////////////////////////////////////
-	// mat2x2 matrix conversions
+	// -- mat2x2 matrix conversions --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -200,8 +197,7 @@ namespace detail
 		this->value[1] = col_type(m[1]);
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -245,8 +241,7 @@ namespace detail
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
+	// -- Unary updatable operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -335,6 +330,8 @@ namespace detail
 		return (*this = *this * detail::compute_inverse<T, P>(m));
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator++()
 	{
@ -367,8 +364,17 @@ namespace detail
 		return Result;
 	}

-	//////////////////////////////////////////////////////////////
-	// Binary operators
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> const operator-(tmat2x2<T, P> const & m)
+	{
+		return tmat2x2<T, P>(
+			-m[0], 
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T const & s)
@ -529,17 +535,7 @@ namespace detail
 		return m1_copy /= m2;
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> const operator-(tmat2x2<T, P> const & m)
-	{
-		return tmat2x2<T, P>(
-			-m[0], 
-			-m[1]);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
--- a/glm/detail/type_mat2x3.hpp
+++ b/glm/detail/type_mat2x3.hpp
@ -61,7 +61,7 @@ namespace glm
 		col_type value[2];

 	public:
-		// Constructors
+		// -- Constructors --

 		GLM_FUNC_DECL tmat2x3() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> const & m) GLM_DEFAULT;
@ -77,8 +77,7 @@ namespace glm
 			col_type const & v0,
 			col_type const & v1);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --

 		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
 		GLM_FUNC_DECL tmat2x3(
@ -90,8 +89,7 @@ namespace glm
 			tvec3<U, P> const & v1,
 			tvec3<V, P> const & v2);

-		//////////////////////////////////////
-		// Matrix conversion
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x3<U, Q> const & m);
@ -105,8 +103,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -122,8 +119,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<T, P> const & m) GLM_DEFAULT;

@ -142,8 +138,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat2x3<T, P> & operator/=(U s);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat2x3<T, P> & operator++ ();
 		GLM_FUNC_DECL tmat2x3<T, P> & operator-- ();
@ -151,7 +146,12 @@ namespace glm
 		GLM_FUNC_DECL tmat2x3<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x3<T, P> const operator-(tmat2x3<T, P> const & m);
+
+	// -- Binary operators --

 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m, T const & s);
@ -192,9 +192,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x3<T, P> operator/(T const & s, tmat2x3<T, P> const & m);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> const operator-(tmat2x3<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat2x3.inl
+++ b/glm/detail/type_mat2x3.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P> 
@ -92,8 +91,7 @@ namespace glm
 		this->value[1] = v1;
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversion constructors --

 	template <typename T, precision P>
 	template <
@ -117,8 +115,7 @@ namespace glm
 		this->value[1] = col_type(v2);
 	}

-	//////////////////////////////////////
-	// Matrix conversions
+	// -- Matrix conversions --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -184,8 +181,7 @@ namespace glm
 		this->value[1] = m[1];
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -229,8 +225,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
+	// -- Unary updatable operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -305,6 +300,8 @@ namespace glm
 		return *this;
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator++()
 	{
@ -337,8 +334,17 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////////////////////////////
-	// Binary operators
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x3<T, P> const operator-(tmat2x3<T, P> const & m)
+	{
+		return tmat2x3<T, P>(
+			-m[0],
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P> 
 	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator+(tmat2x3<T, P> const & m, T const & s)
@ -487,17 +493,7 @@ namespace glm
 			s / m[1]);
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> const operator-(tmat2x3<T, P> const & m)
-	{
-		return tmat2x3<T, P>(
-			-m[0],
-			-m[1]);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
--- a/glm/detail/type_mat2x4.hpp
+++ b/glm/detail/type_mat2x4.hpp
@ -61,7 +61,7 @@ namespace glm
 		col_type value[2];

 	public:
-		// Constructors
+		// -- Constructors --

 		GLM_FUNC_DECL tmat2x4() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat2x4(tmat2x4<T, P> const & m) GLM_DEFAULT;
@ -77,8 +77,8 @@ namespace glm
 			col_type const & v0,
 			col_type const & v1);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --
+
 		template <
 			typename X1, typename Y1, typename Z1, typename W1,
 			typename X2, typename Y2, typename Z2, typename W2>
@ -91,8 +91,7 @@ namespace glm
 			tvec4<U, P> const & v1,
 			tvec4<V, P> const & v2);

-		//////////////////////////////////////
-		// Matrix conversions
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x4<U, Q> const & m);
@ -106,8 +105,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -123,8 +121,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat2x4<T, P> & operator=(tmat2x4<T, P> const & m) GLM_DEFAULT;

@ -143,8 +140,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat2x4<T, P> & operator/=(U s);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat2x4<T, P> & operator++ ();
 		GLM_FUNC_DECL tmat2x4<T, P> & operator-- ();
@ -152,7 +148,12 @@ namespace glm
 		GLM_FUNC_DECL tmat2x4<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat2x4<T, P> const operator-(tmat2x4<T, P> const & m);
+
+	// -- Binary operators --

 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m, T const & s);
@ -193,9 +194,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x4<T, P> operator/(T s, tmat2x4<T, P> const & m);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> const operator-(tmat2x4<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat2x4.inl
+++ b/glm/detail/type_mat2x4.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -93,8 +92,7 @@ namespace glm
 		this->value[1] = v1;
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversion constructors --

 	template <typename T, precision P>
 	template <
@ -118,8 +116,7 @@ namespace glm
 		this->value[1] = col_type(v2);
 	}

-	//////////////////////////////////////
-	// Matrix conversions
+	// -- Matrix conversions --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -185,8 +182,7 @@ namespace glm
 		this->value[1] = col_type(m[1], 0);
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -230,8 +226,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
+	// -- Unary updatable operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -306,6 +301,8 @@ namespace glm
 		return *this;
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator++()
 	{
@ -338,8 +335,17 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////////////////////////////
-	// Binary operators
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat2x4<T, P> const operator-(tmat2x4<T, P> const & m)
+	{
+		return tmat2x4<T, P>(
+			-m[0], 
+			-m[1]);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator+(tmat2x4<T, P> const & m, T const & s)
@ -496,17 +502,7 @@ namespace glm
 			s / m[1]);
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> const operator-(tmat2x4<T, P> const & m)
-	{
-		return tmat2x4<T, P>(
-			-m[0], 
-			-m[1]);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
--- a/glm/detail/type_mat3x2.hpp
+++ b/glm/detail/type_mat3x2.hpp
@ -61,7 +61,7 @@ namespace glm
 		col_type value[3];

 	public:
-		// Constructors
+		// -- Constructors --

 		GLM_FUNC_DECL tmat3x2() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat3x2(tmat3x2<T, P> const & m) GLM_DEFAULT;
@ -79,8 +79,7 @@ namespace glm
 			col_type const & v1,
 			col_type const & v2);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --

 		template<
 			typename X1, typename Y1,
@ -97,8 +96,7 @@ namespace glm
 			tvec2<V2, P> const & v2,
 			tvec2<V3, P> const & v3);

-		//////////////////////////////////////
-		// Matrix conversions
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat3x2(tmat3x2<U, Q> const & m);
@ -112,8 +110,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -129,8 +126,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat3x2<T, P> & operator=(tmat3x2<T, P> const & m) GLM_DEFAULT;

@ -149,8 +145,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat3x2<T, P> & operator/=(U s);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat3x2<T, P> & operator++ ();
 		GLM_FUNC_DECL tmat3x2<T, P> & operator-- ();
@ -158,7 +153,13 @@ namespace glm
 		GLM_FUNC_DECL tmat3x2<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat3x2<T, P> const operator-(tmat3x2<T, P> const & m);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x2<T, P> operator+(tmat3x2<T, P> const & m, T const & s);

@ -198,9 +199,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x2<T, P> operator/(T const & s, tmat3x2<T, P> const & m);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> const operator-(tmat3x2<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat3x2.inl
+++ b/glm/detail/type_mat3x2.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P> 
@ -104,8 +103,7 @@ namespace glm
 		this->value[2] = v2;
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversion constructors --

 	template <typename T, precision P>
 	template <
@ -138,8 +136,7 @@ namespace glm
 		this->value[2] = col_type(v3);
 	}

-	//////////////////////////////////////////////////////////////
-	// mat3x2 matrix conversions
+	// -- Matrix conversions --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -214,8 +211,7 @@ namespace glm
 		this->value[2] = col_type(m[2]);
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -259,8 +255,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
+	// -- Unary updatable operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -343,6 +338,8 @@ namespace glm
 		return *this;
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x2<T, P>& tmat3x2<T, P>::operator++()
 	{
@ -377,8 +374,18 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////////////////////////////
-	// Binary operators
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P> 
+	GLM_FUNC_QUALIFIER tmat3x2<T, P> const operator-(tmat3x2<T, P> const & m)
+	{
+		return tmat3x2<T, P>(
+			-m[0],
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator+(tmat3x2<T, P> const & m, T const & s)
@ -520,18 +527,7 @@ namespace glm
 			s / m[2]);
 	}

-	// Unary constant operators
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> const operator-(tmat3x2<T, P> const & m)
-	{
-		return tmat3x2<T, P>(
-			-m[0],
-			-m[1],
-			-m[2]);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat3x2<T, P> const & m1, tmat3x2<T, P> const & m2)
--- a/glm/detail/type_mat3x3.hpp
+++ b/glm/detail/type_mat3x3.hpp
@ -62,12 +62,10 @@ namespace glm
 		friend tvec3<U, Q> operator/(tvec3<U, Q> const & v, tmat3x3<U, Q> const & m);

 	private:
-		/// @cond DETAIL
 		col_type value[3];
-		/// @endcond

 	public:
-		// Constructors
+		// -- Constructors --

 		GLM_FUNC_DECL tmat3x3() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat3x3(tmat3x3<T, P> const & m) GLM_DEFAULT;
@ -85,8 +83,7 @@ namespace glm
 			col_type const & v1,
 			col_type const & v2);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --

 		template<
 			typename X1, typename Y1, typename Z1,
@ -103,8 +100,7 @@ namespace glm
 			tvec3<V2, P> const & v2,
 			tvec3<V3, P> const & v3);

-		//////////////////////////////////////
-		// Matrix conversions
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat3x3(tmat3x3<U, Q> const & m);
@ -118,8 +114,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -135,8 +130,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat3x3<T, P> & operator=(tmat3x3<T, P> const & m) GLM_DEFAULT;

@ -159,8 +153,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat3x3<T, P> & operator/=(tmat3x3<U, P> const & m);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat3x3<T, P> & operator++();
 		GLM_FUNC_DECL tmat3x3<T, P> & operator--();
@ -168,7 +161,13 @@ namespace glm
 		GLM_FUNC_DECL tmat3x3<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat3x3<T, P> const operator-(tmat3x3<T, P> const & m);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x3<T, P> operator+(tmat3x3<T, P> const & m, T const & s);

@ -223,9 +222,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x3<T, P> operator/(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> const operator-(tmat3x3<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat3x3.inl
+++ b/glm/detail/type_mat3x3.inl
@ -56,8 +56,7 @@ namespace detail
 	}
 }//namespace detail

-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -128,8 +127,8 @@ namespace detail
 		this->value[2] = v2;
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversion constructors --
+
 	template <typename T, precision P>
 	template <
 		typename X1, typename Y1, typename Z1,
@ -161,8 +160,7 @@ namespace detail
 		this->value[2] = col_type(v3);
 	}

-	//////////////////////////////////////////////////////////////
-	// Conversions
+	// -- Matrix conversions --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -237,8 +235,7 @@ namespace detail
 		this->value[2] = m[2];
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -282,8 +279,7 @@ namespace detail
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Operators
+	// -- Unary updatable operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -380,6 +376,8 @@ namespace detail
 		return (*this = *this * detail::compute_inverse<T, P>(m));
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x3<T, P> & tmat3x3<T, P>::operator++()
 	{
@ -414,8 +412,18 @@ namespace detail
 		return Result;
 	}

-	//////////////////////////////////////////////////////////////
-	// Binary operators
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> const operator-(tmat3x3<T, P> const & m)
+	{
+		return tmat3x3<T, P>(
+			-m[0], 
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P> 
 	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator+(tmat3x3<T, P> const & m, T const & s)
@ -610,18 +618,7 @@ namespace detail
 		return m1_copy /= m2;
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> const operator-(tmat3x3<T, P> const & m)
-	{
-		return tmat3x3<T, P>(
-			-m[0], 
-			-m[1],
-			-m[2]);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat3x3<T, P> const & m1, tmat3x3<T, P> const & m2)
--- a/glm/detail/type_mat3x4.hpp
+++ b/glm/detail/type_mat3x4.hpp
@ -58,12 +58,10 @@ namespace glm
 #		endif//GLM_META_PROG_HELPERS

 	private:
-		/// @cond DETAIL
 		col_type value[3];
-		/// @endcond

 	public:
-		// Constructors
+		// -- Constructors --

 		GLM_FUNC_DECL tmat3x4() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat3x4(tmat3x4<T, P> const & m) GLM_DEFAULT;
@ -81,8 +79,8 @@ namespace glm
 			col_type const & v1,
 			col_type const & v2);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --
+
 		template<
 			typename X1, typename Y1, typename Z1, typename W1,
 			typename X2, typename Y2, typename Z2, typename W2,
@ -98,8 +96,7 @@ namespace glm
 			tvec4<V2, P> const & v2,
 			tvec4<V3, P> const & v3);

-		//////////////////////////////////////
-		// Matrix conversion
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat3x4(tmat3x4<U, Q> const & m);
@ -113,8 +110,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -130,8 +126,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat3x4<T, P> & operator=(tmat3x4<T, P> const & m) GLM_DEFAULT;

@ -150,8 +145,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat3x4<T, P> & operator/=(U s);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat3x4<T, P> & operator++();
 		GLM_FUNC_DECL tmat3x4<T, P> & operator--();
@ -159,7 +153,13 @@ namespace glm
 		GLM_FUNC_DECL tmat3x4<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat3x4<T, P> const operator-(tmat3x4<T, P> const & m);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x4<T, P> operator+(tmat3x4<T, P> const & m, T const & s);

@ -199,9 +199,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x4<T, P> operator/(T const & s, tmat3x4<T, P> const & m);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> const operator-(tmat3x4<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat3x4.inl
+++ b/glm/detail/type_mat3x4.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -104,8 +103,7 @@ namespace glm
 		this->value[2] = v2;
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversion constructors --

 	template <typename T, precision P>
 	template <
@ -138,7 +136,8 @@ namespace glm
 		this->value[2] = col_type(v3);
 	}
 	
-	// Conversion
+	// -- Matrix conversions --
+
 	template <typename T, precision P>
 	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4(tmat3x4<U, Q> const & m)
@ -212,8 +211,7 @@ namespace glm
 		this->value[2] = col_type(m[2], 0);
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -257,8 +255,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
+	// -- Unary updatable operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -341,6 +338,8 @@ namespace glm
 		return *this;
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x4<T, P>& tmat3x4<T, P>::operator++()
 	{
@ -375,8 +374,18 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////////////////////////////
-	// Binary operators
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat3x4<T, P> const operator-(tmat3x4<T, P> const & m)
+	{
+		return tmat3x4<T, P>(
+			-m[0],
+			-m[1],
+			-m[2]);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator+(tmat3x4<T, P> const & m, T const & s)
@ -558,18 +567,7 @@ namespace glm
 			s / m[2]);
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> const operator-(tmat3x4<T, P> const & m)
-	{
-		return tmat3x4<T, P>(
-			-m[0],
-			-m[1],
-			-m[2]);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat3x4<T, P> const & m1, tmat3x4<T, P> const & m2)
--- a/glm/detail/type_mat4x2.hpp
+++ b/glm/detail/type_mat4x2.hpp
@ -58,12 +58,10 @@ namespace glm
 #		endif//GLM_META_PROG_HELPERS

 	private:
-		/// @cond DETAIL
 		col_type value[4];
-		/// @endcond

 	public:
-		// Constructors
+		// -- Constructors --

 		GLM_FUNC_DECL tmat4x2() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat4x2(tmat4x2<T, P> const & m) GLM_DEFAULT;
@ -83,8 +81,7 @@ namespace glm
 			col_type const & v2,
 			col_type const & v3);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --

 		template <
 			typename X1, typename Y1,
@ -104,8 +101,7 @@ namespace glm
 			tvec2<V3, P> const & v3,
 			tvec2<V4, P> const & v4);

-		//////////////////////////////////////
-		// Matrix conversions
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat4x2(tmat4x2<U, Q> const & m);
@ -119,8 +115,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -136,8 +131,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat4x2<T, P> & operator=(tmat4x2<T, P> const & m) GLM_DEFAULT;

@ -156,8 +150,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat4x2<T, P> & operator/=(U s);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat4x2<T, P> & operator++ ();
 		GLM_FUNC_DECL tmat4x2<T, P> & operator-- ();
@ -165,7 +158,13 @@ namespace glm
 		GLM_FUNC_DECL tmat4x2<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat4x2<T, P> const operator-(tmat4x2<T, P> const & m);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x2<T, P> operator+(tmat4x2<T, P> const & m, T const & s);

@ -205,9 +204,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x2<T, P> operator/(T const & s, tmat4x2<T, P> const & m);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> const operator-(tmat4x2<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat4x2.inl
+++ b/glm/detail/type_mat4x2.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P> 
@ -112,8 +111,7 @@ namespace glm
 		this->value[3] = v3;
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversion constructors --

 	template <typename T, precision P>
 	template <
@ -151,8 +149,7 @@ namespace glm
 		this->value[3] = col_type(v4);
 	}

-	//////////////////////////////////////
-	// Conversion
+	// -- Conversion --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -236,8 +233,7 @@ namespace glm
 		this->value[3] = col_type(0);
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -281,8 +277,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
+	// -- Unary updatable operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -373,6 +368,8 @@ namespace glm
 		return *this;
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x2<T, P> & tmat4x2<T, P>::operator++()
 	{
@ -409,8 +406,19 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////////////////////////////
-	// Binary operators
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x2<T, P> const operator-(tmat4x2<T, P> const & m)
+	{
+		return tmat4x2<T, P>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator+(tmat4x2<T, P> const & m, T const & s)
@ -565,19 +573,7 @@ namespace glm
 			s / m[3]);
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> const operator-(tmat4x2<T, P> const & m)
-	{
-		return tmat4x2<T, P>(
-			-m[0], 
-			-m[1], 
-			-m[2], 
-			-m[3]);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat4x2<T, P> const & m1, tmat4x2<T, P> const & m2)
--- a/glm/detail/type_mat4x3.hpp
+++ b/glm/detail/type_mat4x3.hpp
@ -61,7 +61,7 @@ namespace glm
 		col_type value[4];

 	public:
-		// Constructors
+		// -- Constructors --

 		GLM_FUNC_DECL tmat4x3() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat4x3(tmat4x3<T, P> const & m) GLM_DEFAULT;
@ -81,8 +81,7 @@ namespace glm
 			col_type const & v2,
 			col_type const & v3);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --

 		template <
 			typename X1, typename Y1, typename Z1,
@ -102,8 +101,7 @@ namespace glm
 			tvec3<V3, P> const & v3,
 			tvec3<V4, P> const & v4);

-		//////////////////////////////////////
-		// Matrix conversions
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat4x3(tmat4x3<U, Q> const & m);
@ -117,8 +115,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -134,8 +131,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat4x3<T, P> & operator=(tmat4x3<T, P> const & m) GLM_DEFAULT;

@ -154,8 +150,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat4x3<T, P> & operator/=(U s);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat4x3<T, P> & operator++();
 		GLM_FUNC_DECL tmat4x3<T, P> & operator--();
@ -163,7 +158,13 @@ namespace glm
 		GLM_FUNC_DECL tmat4x3<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat4x3<T, P> const operator-(tmat4x3<T, P> const & m);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x3<T, P> operator+(tmat4x3<T, P> const & m, T const & s);

@ -203,9 +204,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x3<T, P> operator/(T const & s, tmat4x3<T, P> const & m);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> const operator-(tmat4x3<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat4x3.inl
+++ b/glm/detail/type_mat4x3.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P> 
@ -112,8 +111,7 @@ namespace glm
 		this->value[3] = v3;
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversion constructors --

 	template <typename T, precision P> 
 	template <
@ -151,8 +149,7 @@ namespace glm
 		this->value[3] = col_type(v4);
 	}

-	//////////////////////////////////////////////////////////////
-	// Matrix conversions
+	// -- Matrix conversions --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -236,8 +233,7 @@ namespace glm
 		this->value[3] = col_type(0);
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -281,8 +277,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Unary updatable operators
+	// -- Unary updatable operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -373,6 +368,8 @@ namespace glm
 		return *this;
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x3<T, P> & tmat4x3<T, P>::operator++()
 	{
@ -393,8 +390,35 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////////////////////////////
-	// Binary operators
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> tmat4x3<T, P>::operator++(int)
+	{
+		tmat4x3<T, P> Result(*this);
+		++*this;
+		return Result;
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> tmat4x3<T, P>::operator--(int)
+	{
+		tmat4x3<T, P> Result(*this);
+		--*this;
+		return Result;
+	}
+
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x3<T, P> const operator-(tmat4x3<T, P> const & m)
+	{
+		return tmat4x3<T, P>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator+(tmat4x3<T, P> const & m, T const & s)
@ -573,55 +597,7 @@ namespace glm
 			s / m[3]);
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> const operator-(tmat4x3<T, P> const & m)
-	{
-		return tmat4x3<T, P>(
-			-m[0],
-			-m[1],
-			-m[2],
-			-m[3]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> const operator++(tmat4x3<T, P> const & m, int)
-	{
-		return tmat4x3<T, P>(
-			m[0] + T(1),
-			m[1] + T(1),
-			m[2] + T(1),
-			m[3] + T(1));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> const operator--(tmat4x3<T, P> const & m, int)
-	{
-		return tmat4x3<T, P>(
-			m[0] - T(1),
-			m[1] - T(1),
-			m[2] - T(1),
-			m[3] - T(1));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> tmat4x3<T, P>::operator++(int)
-	{
-		tmat4x3<T, P> Result(*this);
-		++*this;
-		return Result;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> tmat4x3<T, P>::operator--(int)
-	{
-		tmat4x3<T, P> Result(*this);
-		--*this;
-		return Result;
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat4x3<T, P> const & m1, tmat4x3<T, P> const & m2)
--- a/glm/detail/type_mat4x4.hpp
+++ b/glm/detail/type_mat4x4.hpp
@ -65,7 +65,8 @@ namespace glm
 		col_type value[4];

 	public:
-		// Constructors
+		// -- Constructors --
+
 		GLM_FUNC_DECL tmat4x4() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tmat4x4(tmat4x4<T, P> const & m) GLM_DEFAULT;
 		template <precision Q>
@ -84,8 +85,7 @@ namespace glm
 			col_type const & v2,
 			col_type const & v3);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversions --

 		template <
 			typename X1, typename Y1, typename Z1, typename W1,
@ -105,8 +105,7 @@ namespace glm
 			tvec4<V3, P> const & v3,
 			tvec4<V4, P> const & v4);

-		//////////////////////////////////////
-		// Matrix conversions
+		// -- Matrix conversions --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tmat4x4(tmat4x4<U, Q> const & m);
@ -120,8 +119,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T, P> const & x);

-		//////////////////////////////////////
-		// Accesses
+		// -- Accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -137,8 +135,7 @@ namespace glm
 			GLM_FUNC_DECL col_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tmat4x4<T, P> & operator=(tmat4x4<T, P> const & m) GLM_DEFAULT;

@ -161,8 +158,7 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tmat4x4<T, P> & operator/=(tmat4x4<U, P> const & m);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tmat4x4<T, P> & operator++();
 		GLM_FUNC_DECL tmat4x4<T, P> & operator--();
@ -170,7 +166,13 @@ namespace glm
 		GLM_FUNC_DECL tmat4x4<T, P> operator--(int);
 	};

-	// Binary operators
+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tmat4x4<T, P> const operator-(tmat4x4<T, P> const & m);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x4<T, P> operator+(tmat4x4<T, P> const & m, T const & s);

@ -225,9 +227,13 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x4<T, P> operator/(tmat4x4<T, P> const & m1,	tmat4x4<T, P> const & m2);

-	// Unary constant operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> const operator-(tmat4x4<T, P> const & m);
+	GLM_FUNC_DECL bool operator==(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_mat4x4.inl
+++ b/glm/detail/type_mat4x4.inl
@ -92,8 +92,7 @@ namespace detail
 	}
 }//namespace detail

-	//////////////////////////////////////////////////////////////
-	// Constructors
+	// -- Constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -185,8 +184,8 @@ namespace detail
 		this->value[3] = col_type(m[3]);
 	}

-	//////////////////////////////////////
-	// Conversion constructors
+	// -- Conversions --
+
 	template <typename T, precision P> 
 	template <
 		typename X1, typename Y1, typename Z1, typename W1,
@ -248,8 +247,7 @@ namespace detail
 		this->value[3] = col_type(v4);
 	}

-	//////////////////////////////////////
-	// Matrix convertion constructors
+	// -- Matrix conversions --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4(tmat2x2<T, P> const & m)
@ -323,8 +321,7 @@ namespace detail
 		this->value[3] = col_type(m[3], 1);
 	}

-	//////////////////////////////////////
-	// Accesses
+	// -- Accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -368,8 +365,7 @@ namespace detail
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////////////////////////////
-	// Operators
+	// -- Unary arithmetic operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -478,6 +474,8 @@ namespace detail
 		return (*this = *this * detail::compute_inverse<T, P>(m));
 	}

+	// -- Increment and decrement operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x4<T, P> & tmat4x4<T, P>::operator++()
 	{
@ -514,7 +512,20 @@ namespace detail
 		return Result;
 	}

-	// Binary operators
+	// -- Unary constant operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> const operator-(tmat4x4<T, P> const & m)
+	{
+		return tmat4x4<T, P>(
+			-m[0],
+			-m[1],
+			-m[2],
+			-m[3]);
+	}
+
+	// -- Binary arithmetic operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator+(tmat4x4<T, P> const & m, T const & s)
 	{
@ -749,39 +760,7 @@ namespace detail
 		return m1_copy /= m2;
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> const operator-(tmat4x4<T, P> const & m)
-	{
-		return tmat4x4<T, P>(
-			-m[0],
-			-m[1],
-			-m[2],
-			-m[3]);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> const operator++(tmat4x4<T, P> const & m, int)
-	{
-		return tmat4x4<T, P>(
-			m[0] + static_cast<T>(1),
-			m[1] + static_cast<T>(1),
-			m[2] + static_cast<T>(1),
-			m[3] + static_cast<T>(1));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> const operator--(tmat4x4<T, P> const & m, int)
-	{
-		return tmat4x4<T, P>(
-			m[0] - static_cast<T>(1),
-			m[1] - static_cast<T>(1),
-			m[2] - static_cast<T>(1),
-			m[3] - static_cast<T>(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tmat4x4<T, P> const & m1, tmat4x4<T, P> const & m2)
--- a/glm/detail/type_vec.hpp
+++ b/glm/detail/type_vec.hpp
@ -168,7 +168,6 @@ namespace glm

 	/// @}

-
 	/// @addtogroup core_precision
 	/// @{

@ -374,8 +373,7 @@ namespace glm
 	/// @addtogroup core_types
 	/// @{

-	//////////////////////////
-	// Default float definition
+	// -- Default float definition --

 #if(defined(GLM_PRECISION_LOWP_FLOAT))
 	typedef lowp_vec2			vec2;
@ -402,8 +400,7 @@ namespace glm
 	typedef highp_vec4			vec4;
 #endif//GLM_PRECISION

-	//////////////////////////
-	// Default double definition
+	// -- Default double definition --

 #if(defined(GLM_PRECISION_LOWP_DOUBLE))
 	typedef lowp_dvec2			dvec2;
@ -418,21 +415,20 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_dvec2			dvec2;
-	
+
 	//! 3 components vector of double-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_dvec3			dvec3;
-	
+
 	//! 4 components vector of double-precision floating-point numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_dvec4			dvec4;
 #endif//GLM_PRECISION
-	
-	//////////////////////////
-	// Signed integer definition
-	
+
+	// -- Signed integer definition --
+
 #if(defined(GLM_PRECISION_LOWP_INT))
 	typedef lowp_ivec2			ivec2;
 	typedef lowp_ivec3			ivec3;
@ -442,25 +438,24 @@ namespace glm
 	typedef mediump_ivec3		ivec3;
 	typedef mediump_ivec4		ivec4;
 #else //defined(GLM_PRECISION_HIGHP_INT)
-	//! 2 components vector of signed integer numbers.
+	/// 2 components vector of signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_ivec2			ivec2;
-	
-	//! 3 components vector of signed integer numbers.
+
+	/// 3 components vector of signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_ivec3			ivec3;
-	
-	//! 4 components vector of signed integer numbers.
+
+	/// 4 components vector of signed integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_ivec4			ivec4;
 #endif//GLM_PRECISION
-	
-	//////////////////////////
-	// Unsigned integer definition
-	
+
+	// -- Unsigned integer definition --
+
 #if(defined(GLM_PRECISION_LOWP_UINT))
 	typedef lowp_uvec2			uvec2;
 	typedef lowp_uvec3			uvec3;
@ -474,20 +469,19 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_uvec2			uvec2;
-	
+
 	/// 3 components vector of unsigned integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_uvec3			uvec3;
-	
+
 	/// 4 components vector of unsigned integer numbers.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_uvec4			uvec4;
 #endif//GLM_PRECISION
-	
-	//////////////////////////
-	// Boolean definition
+
+	// -- Boolean definition --

 #if(defined(GLM_PRECISION_LOWP_BOOL))
 	typedef lowp_bvec2			bvec2;
@ -498,21 +492,21 @@ namespace glm
 	typedef mediump_bvec3		bvec3;
 	typedef mediump_bvec4		bvec4;
 #else //defined(GLM_PRECISION_HIGHP_BOOL)
-	//! 2 components vector of boolean.
+	/// 2 components vector of boolean.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_bvec2			bvec2;
-	
-	//! 3 components vector of boolean.
+
+	/// 3 components vector of boolean.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_bvec3			bvec3;
-	
-	//! 4 components vector of boolean.
+
+	/// 4 components vector of boolean.
 	///
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
 	typedef highp_bvec4			bvec4;
 #endif//GLM_PRECISION
-	
+
 	/// @}
 }//namespace glm
--- a/glm/detail/type_vec1.hpp
+++ b/glm/detail/type_vec1.hpp
@ -48,8 +48,7 @@ namespace glm
 	template <typename T, precision P = defaultp>
 	struct tvec1
 	{
-		//////////////////////////////////////
-		// Implementation detail
+		// -- Implementation detail --

 		typedef tvec1<T, P> type;
 		typedef tvec1<bool, P> bool_type;
@ -60,8 +59,7 @@ namespace glm
 			static GLM_RELAXED_CONSTEXPR precision prec = P;
 #		endif//GLM_META_PROG_HELPERS

-		//////////////////////////////////////
-		// Data
+		// -- Data --

 #		if GLM_HAS_ANONYMOUS_UNION
 			union
@ -90,8 +88,7 @@ namespace glm
 #			endif//GLM_SWIZZLE*/
 #		endif

-		//////////////////////////////////////
-		// Accesses
+		// -- Component accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			/// Return the count of components of the vector
@ -109,39 +106,35 @@ namespace glm
 			GLM_FUNC_DECL T const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Implicit basic constructors
+		// -- Implicit basic constructors --

 		GLM_FUNC_DECL tvec1() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tvec1(tvec1<T, P> const & v) GLM_DEFAULT;
 		template <precision Q>
 		GLM_FUNC_DECL tvec1(tvec1<T, Q> const & v);

-		//////////////////////////////////////
-		// Explicit basic constructors
+		// -- Explicit basic constructors --

 		GLM_FUNC_DECL explicit tvec1(ctor);
 		GLM_FUNC_DECL explicit tvec1(T const & s);

-		//////////////////////////////////////
-		// Conversion vector constructors
+		// -- Conversion vector constructors --

-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL explicit tvec1(tvec2<U, Q> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL explicit tvec1(tvec3<U, Q> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL explicit tvec1(tvec4<U, Q> const & v);

-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tvec1(tvec1<U, Q> const & v);

-		//////////////////////////////////////
-		// Swizzle constructors
+		// -- Swizzle constructors --

 #		if(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))
 			template <int E0>
@ -151,8 +144,7 @@ namespace glm
 			}
 #		endif//(GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE))

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tvec1<T, P> & operator=(tvec1<T, P> const & v) GLM_DEFAULT;

@ -175,16 +167,14 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tvec1<T, P> & operator/=(tvec1<U, P> const & v);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tvec1<T, P> & operator++();
 		GLM_FUNC_DECL tvec1<T, P> & operator--();
 		GLM_FUNC_DECL tvec1<T, P> operator++(int);
 		GLM_FUNC_DECL tvec1<T, P> operator--(int);

-		//////////////////////////////////////
-		// Unary bit operators
+		// -- Unary bit operators --

 		template <typename U>
 		GLM_FUNC_DECL tvec1<T, P> & operator%=(U const & s);
@ -212,6 +202,12 @@ namespace glm
 		GLM_FUNC_DECL tvec1<T, P> & operator>>=(tvec1<U, P> const & v);
 	};

+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tvec1<T, P> operator-(tvec1<T, P> const & v);
+
+	// -- Binary operators --

 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec1<T, P> operator+(tvec1<T, P> const & v, T const & s);
@ -249,15 +245,6 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec1<T, P> operator/(tvec1<T, P> const & v1, tvec1<T, P> const & v2);

-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec1<T, P> operator-(tvec1<T, P> const & v);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
-
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec1<T, P> operator%(tvec1<T, P> const & v, T const & s);

@ -314,6 +301,14 @@ namespace glm

 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec1<T, P> operator~(tvec1<T, P> const & v);
+
+	// -- Boolean operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_vec1.inl
+++ b/glm/detail/type_vec1.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////
-	// Implicit basic constructors
+	// -- Implicit basic constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -57,8 +56,7 @@ namespace glm
 		: x(v.x)
 	{}

-	//////////////////////////////////////
-	// Explicit basic constructors
+	// -- Explicit basic constructors --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1(ctor)
@ -69,8 +67,7 @@ namespace glm
 		: x(s)
 	{}

-	//////////////////////////////////////
-	// Conversion vector constructors
+	// -- Conversion vector constructors --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -96,8 +93,7 @@ namespace glm
 		: x(static_cast<T>(v.x))
 	{}

-	//////////////////////////////////////
-	// Component accesses
+	// -- Component accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -141,8 +137,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////
-	// Unary arithmetic operators
+	// -- Unary arithmetic operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -225,8 +220,7 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////
-	// Increment and decrement operators
+	// -- Increment and decrement operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P> & tvec1<T, P>::operator++()
@ -258,23 +252,7 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
-	{
-		return (v1.x == v2.x);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
-	{
-		return (v1.x != v2.x);
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
+	// -- Unary bit operators --

 	template <typename T, precision P>
 	template <typename U> 
@ -372,8 +350,16 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////
-	// Binary arithmetic operators
+	// -- Unary constant operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec1<T, P> operator-(tvec1<T, P> const & v)
+	{
+		return tvec1<T, P>(
+			-v.x);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P> 
 	GLM_FUNC_QUALIFIER tvec1<T, P> operator+(tvec1<T, P> const & v, T const & s)
@ -418,7 +404,6 @@ namespace glm
 			v1.x - v2.x);
 	}

-	//operator*
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P> operator*(tvec1<T, P> const & v, T const & s)
 	{
@ -440,7 +425,6 @@ namespace glm
 			v1.x * v2.x);
 	}

-	//operator/
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P> operator/(tvec1<T, P> const & v,	T const & s)
 	{
@ -462,30 +446,7 @@ namespace glm
 			v1.x / v2.x);
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator-(tvec1<T, P> const & v)
-	{
-		return tvec1<T, P>(
-			-v.x);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator++(tvec1<T, P> const & v, int)
-	{
-		return tvec1<T, P>(
-			v.x + T(1));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> operator--(tvec1<T, P> const & v, int)
-	{
-		return tvec1<T, P>(
-			v.x - T(1));
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
+	// -- Binary bit operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P> operator%(tvec1<T, P> const & v, T const & s)
@ -619,4 +580,18 @@ namespace glm
 		return tvec1<T, P>(
 			~v.x);
 	}
+
+	// -- Boolean operators --
+
+	template <typename T, precision P> 
+	GLM_FUNC_QUALIFIER bool operator==(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	{
+		return (v1.x == v2.x);
+	}
+
+	template <typename T, precision P> 
+	GLM_FUNC_QUALIFIER bool operator!=(tvec1<T, P> const & v1, tvec1<T, P> const & v2)
+	{
+		return (v1.x != v2.x);
+	}
 }//namespace glm
--- a/glm/detail/type_vec2.hpp
+++ b/glm/detail/type_vec2.hpp
@ -32,7 +32,6 @@

 #pragma once

-//#include "../fwd.hpp"
 #include "type_vec.hpp"
 #ifdef GLM_SWIZZLE
 #	if GLM_HAS_ANONYMOUS_UNION
@ -48,8 +47,7 @@ namespace glm
 	template <typename T, precision P = defaultp>
 	struct tvec2
 	{
-		//////////////////////////////////////
-		// Implementation detail
+		// -- Implementation detail --

 		typedef tvec2<T, P> type;
 		typedef tvec2<bool, P> bool_type;
@ -60,8 +58,7 @@ namespace glm
 			static GLM_RELAXED_CONSTEXPR precision prec = P;
 #		endif//GLM_META_PROG_HELPERS

-		//////////////////////////////////////
-		// Data
+		// -- Data --

 #		if GLM_HAS_ANONYMOUS_UNION
 			union
@ -91,8 +88,7 @@ namespace glm
 #			endif//GLM_SWIZZLE
 #		endif

-		//////////////////////////////////////
-		// Component accesses
+		// -- Component accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			/// Return the count of components of the vector
@ -110,23 +106,20 @@ namespace glm
 			GLM_FUNC_DECL T const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Implicit basic constructors
+		// -- Implicit basic constructors --

 		GLM_FUNC_DECL tvec2() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tvec2(tvec2<T, P> const & v) GLM_DEFAULT;
 		template <precision Q>
 		GLM_FUNC_DECL tvec2(tvec2<T, Q> const & v);

-		//////////////////////////////////////
-		// Explicit basic constructors
+		// -- Explicit basic constructors --

 		GLM_FUNC_DECL explicit tvec2(ctor);
 		GLM_FUNC_DECL explicit tvec2(T const & s);
 		GLM_FUNC_DECL tvec2(T const & s1, T const & s2);

-		//////////////////////////////////////
-		// Conversion constructors
+		// -- Conversion constructors --

 		/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B>
@ -134,22 +127,20 @@ namespace glm
 		template <typename A, typename B>
 		GLM_FUNC_DECL tvec2(tvec1<A, P> const & v1, tvec1<B, P> const & v2);

-		//////////////////////////////////////
-		// Conversion vector constructors
+		// -- Conversion vector constructors --

-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL explicit tvec2(tvec3<U, Q> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL explicit tvec2(tvec4<U, Q> const & v);

-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tvec2(tvec2<U, Q> const & v);

-		//////////////////////////////////////
-		// Swizzle constructors
+		// -- Swizzle constructors --

 #		if GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
 			template <int E0, int E1>
@ -159,8 +150,7 @@ namespace glm
 			}
 #		endif// GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tvec2<T, P>& operator=(tvec2<T, P> const & v) GLM_DEFAULT;

@ -191,16 +181,14 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tvec2<T, P>& operator/=(tvec2<U, P> const & v);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tvec2<T, P> & operator++();
 		GLM_FUNC_DECL tvec2<T, P> & operator--();
 		GLM_FUNC_DECL tvec2<T, P> operator++(int);
 		GLM_FUNC_DECL tvec2<T, P> operator--(int);

-		//////////////////////////////////////
-		// Unary bit operators
+		// -- Unary bit operators --

 		template <typename U> 
 		GLM_FUNC_DECL tvec2<T, P> & operator%=(U s);
@ -240,6 +228,13 @@ namespace glm
 		GLM_FUNC_DECL tvec2<T, P> & operator>>=(tvec2<U, P> const & v);
 	};

+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tvec2<T, P> operator-(tvec2<T, P> const & v);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec2<T, P> operator+(tvec2<T, P> const & v, T const & s);

@ -395,6 +390,14 @@ namespace glm

 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec2<T, P> operator~(tvec2<T, P> const & v);
+
+	// -- Boolean operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator==(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tvec2<T, P> const & v1, tvec2<T, P> const & v2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_vec2.inl
+++ b/glm/detail/type_vec2.inl
@ -28,8 +28,7 @@

 namespace glm
 {
-	//////////////////////////////////////
-	// Implicit basic constructors
+	// -- Implicit basic constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -53,8 +52,7 @@ namespace glm
 		: x(v.x), y(v.y)
 	{}

-	//////////////////////////////////////
-	// Explicit basic constructors
+	// -- Explicit basic constructors --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2(ctor)
@ -70,8 +68,7 @@ namespace glm
 		: x(s1), y(s2)
 	{}

-	//////////////////////////////////////
-	// Conversion scalar constructors
+	// -- Conversion scalar constructors --

 	template <typename T, precision P>
 	template <typename A, typename B>
@ -87,8 +84,7 @@ namespace glm
 		, y(static_cast<T>(b.x))
 	{}

-	//////////////////////////////////////
-	// Conversion vector constructors
+	// -- Conversion vector constructors --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -111,8 +107,7 @@ namespace glm
 		, y(static_cast<T>(v.y))
 	{}

-	//////////////////////////////////////
-	// Component accesses
+	// -- Component accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -156,8 +151,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////
-	// Unary arithmetic operators
+	// -- Unary arithmetic operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -286,8 +280,7 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////
-	// Increment and decrement operators
+	// -- Increment and decrement operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> & tvec2<T, P>::operator++()
@ -321,23 +314,7 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
-	{
-		return (v1.x == v2.x) && (v1.y == v2.y);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y);
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
+	// -- Unary bit operators --

 	template <typename T, precision P>
 	template <typename U>
@ -501,8 +478,17 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////
-	// Binary arithmetic operators
+	// -- Unary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(tvec2<T, P> const & v)
+	{
+		return tvec2<T, P>(
+			-v.x, 
+			-v.y);
+	}
+
+	// -- Binary arithmetic operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> operator+(tvec2<T, P> const & v, T const & s)
@ -544,7 +530,6 @@ namespace glm
 			v1.y + v2.y);
 	}

-	//operator-
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(tvec2<T, P> const & v, T const & s)
 	{
@ -585,7 +570,6 @@ namespace glm
 			v1.y - v2.y);
 	}

-	//operator*
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> operator*(tvec2<T, P> const & v1, T const & v2)
 	{
@ -626,7 +610,6 @@ namespace glm
 			v1.y * v2.y);
 	}

-	//operator/
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> operator/(tvec2<T, P> const & v, T const & s)
 	{
@ -667,17 +650,7 @@ namespace glm
 			v1.y / v2.y);
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> operator-(tvec2<T, P> const & v)
-	{
-		return tvec2<T, P>(
-			-v.x, 
-			-v.y);
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
+	// -- Binary bit operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> operator%(tvec2<T, P> const & v, T const & s)
@ -926,4 +899,18 @@ namespace glm
 			~v.x,
 			~v.y);
 	}
+
+	// -- Boolean operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	{
+		return (v1.x == v2.x) && (v1.y == v2.y);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(tvec2<T, P> const & v1, tvec2<T, P> const & v2)
+	{
+		return (v1.x != v2.x) || (v1.y != v2.y);
+	}
 }//namespace glm
--- a/glm/detail/type_vec3.hpp
+++ b/glm/detail/type_vec3.hpp
@ -32,7 +32,6 @@

 #pragma once

-//#include "../fwd.hpp"
 #include "type_vec.hpp"
 #ifdef GLM_SWIZZLE
 #	if GLM_HAS_ANONYMOUS_UNION
@ -48,8 +47,7 @@ namespace glm
 	template <typename T, precision P = defaultp>
 	struct tvec3
 	{
-		//////////////////////////////////////
-		// Implementation detail
+		// -- Implementation detail --

 		typedef tvec3<T, P> type;
 		typedef tvec3<bool, P> bool_type;
@ -60,8 +58,7 @@ namespace glm
 			static GLM_RELAXED_CONSTEXPR precision prec = P;
 #		endif//GLM_META_PROG_HELPERS

-		//////////////////////////////////////
-		// Data
+		// -- Data --

 #		if GLM_HAS_ANONYMOUS_UNION
 			union
@ -92,8 +89,7 @@ namespace glm
 #			endif//GLM_SWIZZLE
 #		endif//GLM_LANG

-		//////////////////////////////////////
-		// Component accesses
+		// -- Component accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			/// Return the count of components of the vector
@ -111,23 +107,20 @@ namespace glm
 			GLM_FUNC_DECL T const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Implicit basic constructors
+		// -- Implicit basic constructors --

 		GLM_FUNC_DECL tvec3() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tvec3(tvec3<T, P> const & v) GLM_DEFAULT;
 		template <precision Q>
 		GLM_FUNC_DECL tvec3(tvec3<T, Q> const & v);

-		//////////////////////////////////////
-		// Explicit basic constructors
+		// -- Explicit basic constructors --

 		GLM_FUNC_DECL explicit tvec3(ctor);
 		GLM_FUNC_DECL explicit tvec3(T const & s);
 		GLM_FUNC_DECL tvec3(T const & a, T const & b, T const & c);

-		//////////////////////////////////////
-		// Conversion scalar constructors
+		// -- Conversion scalar constructors --

 		/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C>
@ -135,31 +128,29 @@ namespace glm
 		template <typename A, typename B, typename C>
 		GLM_FUNC_DECL tvec3(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c);

-		//////////////////////////////////////
-		// Conversion vector constructors
+		// -- Conversion vector constructors --

-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec3(tvec2<A, Q> const & a, B const & b);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec3(tvec2<A, Q> const & a, tvec1<B, Q> const & b);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec3(A const & a, tvec2<B, Q> const & b);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec3(tvec1<A, Q> const & a, tvec2<B, Q> const & b);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL explicit tvec3(tvec4<U, Q> const & v);

-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tvec3(tvec3<U, Q> const & v);

-		//////////////////////////////////////
-		// Swizzle constructors
+		// -- Swizzle constructors --

 #		if GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
 			template <int E0, int E1, int E2>
@ -181,8 +172,7 @@ namespace glm
 			}
 #		endif// GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tvec3<T, P> & operator=(tvec3<T, P> const & v) GLM_DEFAULT;

@ -213,16 +203,14 @@ namespace glm
 		template <typename U>
 		GLM_FUNC_DECL tvec3<T, P> & operator/=(tvec3<U, P> const & v);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tvec3<T, P> & operator++();
 		GLM_FUNC_DECL tvec3<T, P> & operator--();
 		GLM_FUNC_DECL tvec3<T, P> operator++(int);
 		GLM_FUNC_DECL tvec3<T, P> operator--(int);

-		//////////////////////////////////////
-		// Unary bit operators
+		// -- Unary bit operators --

 		template <typename U>
 		GLM_FUNC_DECL tvec3<T, P> & operator%=(U s);
@ -262,6 +250,13 @@ namespace glm
 		GLM_FUNC_DECL tvec3<T, P> & operator>>=(tvec3<U, P> const & v);
 	};

+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec3<T, P> operator+(tvec3<T, P> const & v, T const & s);

@ -322,9 +317,6 @@ namespace glm
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec3<T, P> operator/(tvec3<T, P> const & v1, tvec3<T, P> const & v2);

-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator-(tvec3<T, P> const & v);
-
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec3<T, P> operator%(tvec3<T, P> const & v, T const & s);

@ -417,6 +409,14 @@ namespace glm

 	template <typename T, precision P> 
 	GLM_FUNC_DECL tvec3<T, P> operator~(tvec3<T, P> const & v);
+
+	// -- Boolean operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator==(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tvec3<T, P> const & v1, tvec3<T, P> const & v2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_vec3.inl
+++ b/glm/detail/type_vec3.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////
-	// Implicit basic constructors
+	// -- Implicit basic constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -57,8 +56,7 @@ namespace glm
 		: x(v.x), y(v.y), z(v.z)
 	{}

-	//////////////////////////////////////
-	// Explicit basic constructors
+	// -- Explicit basic constructors --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3(ctor)
@ -74,8 +72,7 @@ namespace glm
 		: x(a), y(b), z(c)
 	{}

-	//////////////////////////////////////
-	// Conversion scalar constructors
+	// -- Conversion scalar constructors --

 	template <typename T, precision P>
 	template <typename A, typename B, typename C>
@ -93,8 +90,7 @@ namespace glm
 		z(static_cast<T>(c))
 	{}

-	//////////////////////////////////////
-	// Conversion vector constructors
+	// -- Conversion vector constructors --

 	template <typename T, precision P>
 	template <typename A, typename B, precision Q>
@ -144,8 +140,7 @@ namespace glm
 		z(static_cast<T>(v.z))
 	{}

-	//////////////////////////////////////
-	// Component accesses
+	// -- Component accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -189,8 +184,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////
-	// Unary arithmetic operators
+	// -- Unary arithmetic operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -333,8 +327,7 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////
-	// Increment and decrement operators
+	// -- Increment and decrement operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator++()
@ -370,8 +363,7 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////
-	// Unary bit operators
+	// -- Unary bit operators --

 	template <typename T, precision P>
 	template <typename U>
@ -553,23 +545,18 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////
-	// Boolean operators
+	// -- Unary arithmetic operators --

 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(tvec3<T, P> const & v)
 	{
-		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z);
+		return tvec3<T, P>(
+			-v.x, 
+			-v.y, 
+			-v.z);
 	}

-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
+	// -- Binary arithmetic operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> operator+(tvec3<T, P> const & v, T const & s)
@ -616,7 +603,6 @@ namespace glm
 			v1.z + v2.z);
 	}

-	//operator-
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(tvec3<T, P> const & v, T const & s)
 	{
@ -662,7 +648,6 @@ namespace glm
 			v1.z - v2.z);
 	}

-	//operator*
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tvec3<T, P> const & v, T const & s)
 	{
@ -708,7 +693,6 @@ namespace glm
 			v1.z * v2.z);
 	}

-	//operator/
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> operator/(tvec3<T, P> const & v, T const & s)
 	{
@ -754,18 +738,7 @@ namespace glm
 			v1.z / v2.z);
 	}

-	// Unary constant operators
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> operator-(tvec3<T, P> const & v)
-	{
-		return tvec3<T, P>(
-			-v.x, 
-			-v.y, 
-			-v.z);
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
+	// -- Binary bit operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> operator%(tvec3<T, P> const & v, T const & s)
@ -1045,4 +1018,18 @@ namespace glm
 			~v.y,
 			~v.z);
 	}
+
+	// -- Boolean operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	{
+		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(tvec3<T, P> const & v1, tvec3<T, P> const & v2)
+	{
+		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z);
+	}
 }//namespace glm
--- a/glm/detail/type_vec4.hpp
+++ b/glm/detail/type_vec4.hpp
@ -32,7 +32,6 @@

 #pragma once

-//#include "../fwd.hpp"
 #include "setup.hpp"
 #include "type_vec.hpp"
 #ifdef GLM_SWIZZLE
@ -102,8 +101,7 @@ namespace detail
 	template <typename T, precision P = defaultp>
 	struct tvec4
 	{
-		//////////////////////////////////////
-		// Implementation detail
+		// -- Implementation detail --

 		typedef tvec4<T, P> type;
 		typedef tvec4<bool, P> bool_type;
@ -114,8 +112,7 @@ namespace detail
 			static GLM_RELAXED_CONSTEXPR precision prec = P;
 #		endif//GLM_META_PROG_HELPERS

-		//////////////////////////////////////
-		// Data
+		// -- Data --

 #		if GLM_HAS_ANONYMOUS_UNION
 			union
@ -149,8 +146,7 @@ namespace detail
 #			endif//GLM_SWIZZLE
 #		endif//GLM_LANG

-		//////////////////////////////////////
-		// Component accesses
+		// -- Component accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			/// Return the count of components of the vector
@ -168,23 +164,20 @@ namespace detail
 			GLM_FUNC_DECL T const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Implicit basic constructors
+		// -- Implicit basic constructors --

 		GLM_FUNC_DECL tvec4() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tvec4(tvec4<T, P> const & v) GLM_DEFAULT;
 		template <precision Q>
 		GLM_FUNC_DECL tvec4(tvec4<T, Q> const & v);

-		//////////////////////////////////////
-		// Explicit basic constructors
+		// -- Explicit basic constructors --

 		GLM_FUNC_DECL explicit tvec4(ctor);
 		GLM_FUNC_DECL explicit tvec4(T s);
 		GLM_FUNC_DECL tvec4(T a, T b, T c, T d);

-		//////////////////////////////////////
-		// Conversion scalar constructors
+		// -- Conversion scalar constructors --

 		/// Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, typename D>
@ -192,49 +185,47 @@ namespace detail
 		template <typename A, typename B, typename C, typename D>
 		GLM_FUNC_DECL tvec4(tvec1<A, P> const & a, tvec1<B, P> const & b, tvec1<C, P> const & c, tvec1<D, P> const & d);

-		//////////////////////////////////////
-		// Conversion vector constructors
+		// -- Conversion vector constructors --

-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
 		GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, B b, C c);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
 		GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<C, Q> const & c);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
 		GLM_FUNC_DECL explicit tvec4(A a, tvec2<B, Q> const & b, C c);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
 		GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<C, Q> const & c);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
 		GLM_FUNC_DECL explicit tvec4(A a, B b, tvec2<C, Q> const & c);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, typename C, precision Q>
 		GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<C, Q> const & c);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> const & a, B b);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> const & a, tvec1<B, Q> const & b);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec4(A a, tvec3<B, Q> const & b);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename A, typename B, precision Q>
 		GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b);

-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		/// Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tvec4(tvec4<U, Q> const & v);

-		//////////////////////////////////////
-		// Swizzle constructors
+		// -- Swizzle constructors --

 #		if GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)
 			template <int E0, int E1, int E2, int E3>
@ -280,8 +271,7 @@ namespace detail
 			}
 #		endif// GLM_HAS_ANONYMOUS_UNION && defined(GLM_SWIZZLE)

-		//////////////////////////////////////
-		// Unary arithmetic operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<T, P> const & v) GLM_DEFAULT;

@ -312,16 +302,14 @@ namespace detail
 		template <typename U>
 		GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec4<U, P> const & v);

-		//////////////////////////////////////
-		// Increment and decrement operators
+		// -- Increment and decrement operators --

 		GLM_FUNC_DECL tvec4<T, P> & operator++();
 		GLM_FUNC_DECL tvec4<T, P> & operator--();
 		GLM_FUNC_DECL tvec4<T, P> operator++(int);
 		GLM_FUNC_DECL tvec4<T, P> operator--(int);

-		//////////////////////////////////////
-		// Unary bit operators
+		// -- Unary bit operators --

 		template <typename U>
 		GLM_FUNC_DECL tvec4<T, P> & operator%=(U scalar);
@ -361,6 +349,13 @@ namespace detail
 		GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec4<U, P> const & v);
 	};

+	// -- Unary operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v);
+
+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> const & v, T scalar);

@ -421,9 +416,6 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec4<T, P> const & v2);

-	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> const & v);
-
 	template <typename T, precision P>
 	GLM_FUNC_DECL bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2);

@ -522,6 +514,14 @@ namespace detail

 	template <typename T, precision P> 
 	GLM_FUNC_DECL tvec4<T, P> operator~(tvec4<T, P> const & v);
+
+	// -- Boolean operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2);
 }//namespace glm

 #ifndef GLM_EXTERNAL_TEMPLATE
--- a/glm/detail/type_vec4.inl
+++ b/glm/detail/type_vec4.inl
@ -32,8 +32,7 @@

 namespace glm
 {
-	//////////////////////////////////////
-	// Implicit basic constructors
+	// -- Implicit basic constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -57,8 +56,7 @@ namespace glm
 		: x(v.x), y(v.y), z(v.z), w(v.w)
 	{}

-	//////////////////////////////////////
-	// Explicit basic constructors
+	// -- Explicit basic constructors --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4(ctor)
@ -74,8 +72,7 @@ namespace glm
 		: x(a), y(b), z(c), w(d)
 	{}

-	//////////////////////////////////////
-	// Conversion scalar constructors
+	// -- Conversion scalar constructors --

 	template <typename T, precision P>
 	template <typename A, typename B, typename C, typename D>
@ -95,8 +92,7 @@ namespace glm
 		w(static_cast<T>(d.x))
 	{}

-	//////////////////////////////////////
-	// Conversion vector constructors
+	// -- Conversion vector constructors --

 	template <typename T, precision P>
 	template <typename A, typename B, typename C, precision Q>
@ -206,8 +202,7 @@ namespace glm
 		w(static_cast<T>(v.w))
 	{}

-	//////////////////////////////////////
-	// Component accesses
+	// -- Component accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -251,8 +246,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////
-	// Unary arithmetic operators
+	// -- Unary arithmetic operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -411,8 +405,7 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////
-	// Increment and decrement operators
+	// -- Increment and decrement operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P> & tvec4<T, P>::operator++()
@ -450,8 +443,7 @@ namespace glm
 		return Result;
 	}

-	//////////////////////////////////////
-	// Unary bit operators
+	// -- Unary bit operators --

 	template <typename T, precision P>
 	template <typename U> 
@ -651,149 +643,9 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////
-	// Boolean operators
+	// -- Unary constant operators --

 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
-	{
-		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z) || (v1.w != v2.w);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v, T scalar)
-	{
-		return tvec4<T, P>(
-			v.x + scalar,
-			v.y + scalar,
-			v.z + scalar,
-			v.w + scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(T scalar, tvec4<T, P> const & v)
-	{
-		return tvec4<T, P>(
-			scalar + v.x,
-			scalar + v.y,
-			scalar + v.z,
-			scalar + v.w);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
-	{
-		return tvec4<T, P>(
-			v1.x + v2.x,
-			v1.y + v2.y,
-			v1.z + v2.z,
-			v1.w + v2.w);
-	}
-
-	//operator-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v, T scalar)
-	{
-		return tvec4<T, P>(
-			v.x - scalar,
-			v.y - scalar,
-			v.z - scalar,
-			v.w - scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(T scalar, tvec4<T, P> const & v)
-	{
-		return tvec4<T, P>(
-			scalar - v.x,
-			scalar - v.y,
-			scalar - v.z,
-			scalar - v.w);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
-	{
-		return tvec4<T, P>(
-			v1.x - v2.x,
-			v1.y - v2.y,
-			v1.z - v2.z,
-			v1.w - v2.w);
-	}
-
-	//operator*
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v, T scalar)
-	{
-		return tvec4<T, P>(
-			v.x * scalar,
-			v.y * scalar,
-			v.z * scalar,
-			v.w * scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(T scalar, tvec4<T, P> const & v)
-	{
-		return tvec4<T, P>(
-			scalar * v.x,
-			scalar * v.y,
-			scalar * v.z,
-			scalar * v.w);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
-	{
-		return tvec4<T, P>(
-			v1.x * v2.x,
-			v1.y * v2.y,
-			v1.z * v2.z,
-			v1.w * v2.w);
-	}
-
-	//operator/
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v, T scalar)
-	{
-		return tvec4<T, P>(
-			v.x / scalar,
-			v.y / scalar,
-			v.z / scalar,
-			v.w / scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(T scalar, tvec4<T, P> const & v)
-	{
-		return tvec4<T, P>(
-			scalar / v.x,
-			scalar / v.y,
-			scalar / v.z,
-			scalar / v.w);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
-	{
-		return tvec4<T, P>(
-			v1.x / v2.x,
-			v1.y / v2.y,
-			v1.z / v2.z,
-			v1.w / v2.w);
-	}
-
-	// Unary constant operators
-	template <typename T, precision P> 
 	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v)
 	{
 		return tvec4<T, P>(
@ -803,8 +655,129 @@ namespace glm
 			-v.w);
 	}

-	//////////////////////////////////////
-	// Binary bit operators
+	// -- Binary arithmetic operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v, T scalar)
+	{
+		return tvec4<T, P>(
+			v.x + scalar,
+			v.y + scalar,
+			v.z + scalar,
+			v.w + scalar);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(T scalar, tvec4<T, P> const & v)
+	{
+		return tvec4<T, P>(
+			scalar + v.x,
+			scalar + v.y,
+			scalar + v.z,
+			scalar + v.w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator+(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	{
+		return tvec4<T, P>(
+			v1.x + v2.x,
+			v1.y + v2.y,
+			v1.z + v2.z,
+			v1.w + v2.w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v, T scalar)
+	{
+		return tvec4<T, P>(
+			v.x - scalar,
+			v.y - scalar,
+			v.z - scalar,
+			v.w - scalar);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(T scalar, tvec4<T, P> const & v)
+	{
+		return tvec4<T, P>(
+			scalar - v.x,
+			scalar - v.y,
+			scalar - v.z,
+			scalar - v.w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator-(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	{
+		return tvec4<T, P>(
+			v1.x - v2.x,
+			v1.y - v2.y,
+			v1.z - v2.z,
+			v1.w - v2.w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v, T scalar)
+	{
+		return tvec4<T, P>(
+			v.x * scalar,
+			v.y * scalar,
+			v.z * scalar,
+			v.w * scalar);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(T scalar, tvec4<T, P> const & v)
+	{
+		return tvec4<T, P>(
+			scalar * v.x,
+			scalar * v.y,
+			scalar * v.z,
+			scalar * v.w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator*(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	{
+		return tvec4<T, P>(
+			v1.x * v2.x,
+			v1.y * v2.y,
+			v1.z * v2.z,
+			v1.w * v2.w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v, T scalar)
+	{
+		return tvec4<T, P>(
+			v.x / scalar,
+			v.y / scalar,
+			v.z / scalar,
+			v.w / scalar);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(T scalar, tvec4<T, P> const & v)
+	{
+		return tvec4<T, P>(
+			scalar / v.x,
+			scalar / v.y,
+			scalar / v.z,
+			scalar / v.w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER tvec4<T, P> operator/(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	{
+		return tvec4<T, P>(
+			v1.x / v2.x,
+			v1.y / v2.y,
+			v1.z / v2.z,
+			v1.w / v2.w);
+	}
+
+	// -- Binary bit operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P> operator%(tvec4<T, P> const & v, T s)
@ -1115,6 +1088,20 @@ namespace glm
 			~v.z,
 			~v.w);
 	}
+
+	// -- Boolean operators --
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator==(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	{
+		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER bool operator!=(tvec4<T, P> const & v1, tvec4<T, P> const & v2)
+	{
+		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z) || (v1.w != v2.w);
+	}
 }//namespace glm

 #if GLM_HAS_ANONYMOUS_UNION && GLM_NOT_BUGGY_VC32BITS
--- a/glm/fwd.hpp
+++ b/glm/fwd.hpp
@ -124,9 +124,6 @@ namespace glm
 // GLM_GTC_precision
 namespace glm
 {
-	/// @addtogroup gtc_type_precision
-	/// @{
-
 	/// Low precision 8 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int8 lowp_int8;
@ -1547,15 +1544,15 @@ namespace glm
 	typedef tvec1<float, lowp> lowp_vec1;

 	/// Low single-precision floating-point vector of 2 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec2<float, lowp> lowp_vec2;

 	/// Low single-precision floating-point vector of 3 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec3<float, lowp> lowp_vec3;

 	/// Low single-precision floating-point vector of 4 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec4<float, lowp> lowp_vec4;

 	/// Low single-precision floating-point vector of 1 component.
@ -1580,15 +1577,15 @@ namespace glm
 	typedef tvec1<float, mediump> mediump_vec1;

 	/// Medium Single-precision floating-point vector of 2 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec2<float, mediump> mediump_vec2;

 	/// Medium Single-precision floating-point vector of 3 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec3<float, mediump> mediump_vec3;

 	/// Medium Single-precision floating-point vector of 4 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec4<float, mediump> mediump_vec4;

 	/// Medium single-precision floating-point vector of 1 component.
@ -1613,15 +1610,15 @@ namespace glm
 	typedef tvec1<float, highp> highp_vec1;

 	/// High Single-precision floating-point vector of 2 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec2<float, highp> highp_vec2;

 	/// High Single-precision floating-point vector of 3 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec3<float, highp> highp_vec3;

 	/// High Single-precision floating-point vector of 4 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec4<float, highp> highp_vec4;

 	/// High single-precision floating-point vector of 1 component.
@ -1629,15 +1626,15 @@ namespace glm
 	typedef tvec1<float, highp> highp_fvec1;

 	/// High Single-precision floating-point vector of 2 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec2<float, highp> highp_fvec2;

 	/// High Single-precision floating-point vector of 3 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec3<float, highp> highp_fvec3;

 	/// High Single-precision floating-point vector of 4 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec4<float, highp> highp_fvec4;


@ -1646,15 +1643,15 @@ namespace glm
 	typedef tvec1<f32, lowp> lowp_f32vec1;

 	/// Low single-precision floating-point vector of 2 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec2<f32, lowp> lowp_f32vec2;

 	/// Low single-precision floating-point vector of 3 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec3<f32, lowp> lowp_f32vec3;

 	/// Low single-precision floating-point vector of 4 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec4<f32, lowp> lowp_f32vec4;

 	/// Medium single-precision floating-point vector of 1 component.
@ -1662,15 +1659,15 @@ namespace glm
 	typedef tvec1<f32, mediump> mediump_f32vec1;

 	/// Medium single-precision floating-point vector of 2 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec2<f32, mediump> mediump_f32vec2;

 	/// Medium single-precision floating-point vector of 3 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec3<f32, mediump> mediump_f32vec3;

 	/// Medium single-precision floating-point vector of 4 components.
-	/// @see gtc_type_precision
+	/// @see core_precision
 	typedef tvec4<f32, mediump> mediump_f32vec4;

 	/// High single-precision floating-point vector of 1 component.
@ -2598,4 +2595,5 @@ namespace glm
 	/// @see gtc_type_precision
 	typedef highp_f64quat			f64quat;
 #endif
+
 }//namespace glm
--- a/glm/gtc/quaternion.hpp
+++ b/glm/gtc/quaternion.hpp
@ -62,6 +62,8 @@ namespace glm
 	template <typename T, precision P = defaultp>
 	struct tquat
 	{
+		// -- Implementation detail --
+
 		typedef tquat<T, P> type;
 		typedef T value_type;

@ -70,11 +72,11 @@ namespace glm
 			static GLM_RELAXED_CONSTEXPR precision prec = P;
 #		endif//GLM_META_PROG_HELPERS

-	public:
+		// -- Data --
+
 		T x, y, z, w;

-		//////////////////////////////////////
-		// Component accesses
+		// -- Component accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -92,28 +94,25 @@ namespace glm
 			GLM_FUNC_DECL T const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Implicit basic constructors
+		// -- Implicit basic constructors --

 		GLM_FUNC_DECL tquat() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tquat(tquat<T, P> const & q) GLM_DEFAULT;
 		template <precision Q>
 		GLM_FUNC_DECL tquat(tquat<T, Q> const & q);

-		//////////////////////////////////////
-		// Explicit basic constructors
+		// -- Explicit basic constructors --

 		GLM_FUNC_DECL explicit tquat(ctor);
 		GLM_FUNC_DECL explicit tquat(T const & s, tvec3<T, P> const & v);
 		GLM_FUNC_DECL tquat(T const & w, T const & x, T const & y, T const & z);

-		//////////////////////////////////////
-		// Conversions
+		// -- Conversion constructors --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tquat(tquat<U, Q> const & q);

-		// explicit conversion operators
+		/// Explicit conversion operators
 #		if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS
 			GLM_FUNC_DECL explicit operator tmat3x3<T, P>();
 			GLM_FUNC_DECL explicit operator tmat4x4<T, P>();
@ -132,8 +131,7 @@ namespace glm
 		GLM_FUNC_DECL explicit tquat(tmat3x3<T, P> const & m);
 		GLM_FUNC_DECL explicit tquat(tmat4x4<T, P> const & m);

-		//////////////////////////////////////
-		// Operators
+		// -- Unary arithmetic operators --

 		GLM_FUNC_DECL tquat<T, P> & operator=(tquat<T, P> const & m) GLM_DEFAULT;

@ -149,9 +147,13 @@ namespace glm
 		GLM_FUNC_DECL tquat<T, P> & operator/=(U s);
 	};

+	// -- Unary bit operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator-(tquat<T, P> const & q);

+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_DECL tquat<T, P> operator+(tquat<T, P> const & q, tquat<T, P> const & p);

--- a/glm/gtc/quaternion.inl
+++ b/glm/gtc/quaternion.inl
@ -49,8 +49,7 @@ namespace detail
 	};
 }//namespace detail

-	//////////////////////////////////////
-	// Component accesses
+	// -- Component accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -94,8 +93,7 @@ namespace detail
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////
-	// Implicit basic constructors
+	// -- Implicit basic constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -119,8 +117,7 @@ namespace detail
 		: x(q.x), y(q.y), z(q.z), w(q.w)
 	{}

-	//////////////////////////////////////
-	// Explicit basic constructors
+	// -- Explicit basic constructors --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(ctor)
@ -136,8 +133,7 @@ namespace detail
 		: x(x), y(y), z(z), w(w)
 	{}

-	//////////////////////////////////////////////////////////////
-	// Conversions
+	// -- Conversion constructors --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -226,8 +222,7 @@ namespace detail
 		return conjugate(q) / dot(q, q);
 	}

-	//////////////////////////////////////////////////////////////
-	// tquat<valType> operators
+	// -- Unary arithmetic operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -299,8 +294,7 @@ namespace detail
 		return *this;
 	}

-	//////////////////////////////////////////////////////////////
-	// tquat<T, P> external operators
+	// -- Unary bit operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator-(tquat<T, P> const & q)
@ -308,6 +302,8 @@ namespace detail
 		return tquat<T, P>(-q.w, -q.x, -q.y, -q.z);
 	}

+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tquat<T, P> operator+(tquat<T, P> const & q,	tquat<T, P> const & p)
 	{
@ -320,7 +316,6 @@ namespace detail
 		return tquat<T, P>(q) *= p;
 	}

-	// Transformation
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tquat<T, P> const & q,	tvec3<T, P> const & v)
 	{
@ -369,8 +364,7 @@ namespace detail
 			q.w / s, q.x / s, q.y / s, q.z / s);
 	}

-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tquat<T, P> const & q1, tquat<T, P> const & q2)
@ -384,7 +378,8 @@ namespace detail
 		return (q1.x != q2.x) || (q1.y != q2.y) || (q1.z != q2.z) || (q1.w != q2.w);
 	}

-	////////////////////////////////////////////////////////
+	// -- Operations --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER T length(tquat<T, P> const & q)
 	{
--- a/glm/gtx/dual_quaternion.hpp
+++ b/glm/gtx/dual_quaternion.hpp
@ -61,6 +61,8 @@ namespace glm
 	template <typename T, precision P = defaultp>
 	struct tdualquat
 	{
+		// -- Implementation detail --
+
 		typedef T value_type;
 		typedef glm::tquat<T, P> part_type;

@ -69,11 +71,11 @@ namespace glm
 			static GLM_RELAXED_CONSTEXPR precision prec = P;
 #		endif//GLM_META_PROG_HELPERS

-	public:
+		// -- Data --
+
 		glm::tquat<T, P> real, dual;

-		//////////////////////////////////////
-		// Component accesses
+		// -- Component accesses --

 #		ifdef GLM_FORCE_SIZE_FUNC
 			typedef size_t size_type;
@ -91,24 +93,21 @@ namespace glm
 			GLM_FUNC_DECL part_type const & operator[](length_type i) const;
 #		endif//GLM_FORCE_SIZE_FUNC

-		//////////////////////////////////////
-		// Implicit basic constructors
+		// -- Implicit basic constructors --

 		GLM_FUNC_DECL tdualquat() GLM_DEFAULT_CTOR;
 		GLM_FUNC_DECL tdualquat(tdualquat<T, P> const & d) GLM_DEFAULT;
 		template <precision Q>
 		GLM_FUNC_DECL tdualquat(tdualquat<T, Q> const & d);

-		//////////////////////////////////////
-		// Explicit basic constructors
+		// -- Explicit basic constructors --

 		GLM_FUNC_DECL explicit tdualquat(ctor);
 		GLM_FUNC_DECL explicit tdualquat(tquat<T, P> const & real);
 		GLM_FUNC_DECL tdualquat(tquat<T, P> const & orientation, tvec3<T, P> const & translation);
 		GLM_FUNC_DECL tdualquat(tquat<T, P> const & real, tquat<T, P> const & dual);

-		//////////////////////////////////////////////////////////////
-		// tdualquat conversions
+		// -- Conversion constructors --

 		template <typename U, precision Q>
 		GLM_FUNC_DECL GLM_EXPLICIT tdualquat(tdualquat<U, Q> const & q);
@ -116,7 +115,8 @@ namespace glm
 		GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat);
 		GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat);

-		// Operators
+		// -- Unary arithmetic operators --
+
 		GLM_FUNC_DECL tdualquat<T, P> & operator=(tdualquat<T, P> const & m) GLM_DEFAULT;

 		template <typename U>
@ -127,105 +127,81 @@ namespace glm
 		GLM_FUNC_DECL tdualquat<T, P> & operator/=(U s);
 	};

-	template <typename T, precision P>
-	GLM_FUNC_DECL tquat<T, P> operator- (
-		tquat<T, P> const & q);
+	// -- Unary bit operators --

 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> operator+ (
-		tdualquat<T, P> const & q,
-		tdualquat<T, P> const & p);
+	GLM_FUNC_DECL tquat<T, P> operator-(tquat<T, P> const & q);
+
+	// -- Binary operators --

 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> operator* (
-		tdualquat<T, P> const & q,
-		tdualquat<T, P> const & p);
+	GLM_FUNC_DECL tdualquat<T, P> operator+(tdualquat<T, P> const & q, tdualquat<T, P> const & p);

 	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator* (
-		tquat<T, P> const & q,
-		tvec3<T, P> const & v);
+	GLM_FUNC_DECL tdualquat<T, P> operator*(tdualquat<T, P> const & q, tdualquat<T, P> const & p);

 	template <typename T, precision P>
-	GLM_FUNC_DECL tvec3<T, P> operator* (
-		tvec3<T, P> const & v,
-		tquat<T, P> const & q);
+	GLM_FUNC_DECL tvec3<T, P> operator*(tquat<T, P> const & q, tvec3<T, P> const & v);

 	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator* (
-		tquat<T, P> const & q,
-		tvec4<T, P> const & v);
+	GLM_FUNC_DECL tvec3<T, P> operator*(tvec3<T, P> const & v, tquat<T, P> const & q);

 	template <typename T, precision P>
-	GLM_FUNC_DECL tvec4<T, P> operator* (
-		tvec4<T, P> const & v,
-		tquat<T, P> const & q);
+	GLM_FUNC_DECL tvec4<T, P> operator*(tquat<T, P> const & q, tvec4<T, P> const & v);

 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> operator* (
-		tdualquat<T, P> const & q,
-		T const & s);
+	GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> const & v, tquat<T, P> const & q);

 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> operator* (
-		T const & s,
-		tdualquat<T, P> const & q);
+	GLM_FUNC_DECL tdualquat<T, P> operator*(tdualquat<T, P> const & q, T const & s);

 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> operator/ (
-		tdualquat<T, P> const & q,
-		T const & s);
+	GLM_FUNC_DECL tdualquat<T, P> operator*(T const & s, tdualquat<T, P> const & q);
+
+	template <typename T, precision P>
+	GLM_FUNC_DECL tdualquat<T, P> operator/(tdualquat<T, P> const & q, T const & s);

 	/// Returns the normalized quaternion.
 	///
 	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> normalize(
-		tdualquat<T, P> const & q);
+	GLM_FUNC_DECL tdualquat<T, P> normalize(tdualquat<T, P> const & q);

 	/// Returns the linear interpolation of two dual quaternion.
 	///
 	/// @see gtc_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> lerp(
-		tdualquat<T, P> const & x,
-		tdualquat<T, P> const & y,
-		T const & a);
+	GLM_FUNC_DECL tdualquat<T, P> lerp(tdualquat<T, P> const & x, tdualquat<T, P> const & y, T const & a);

 	/// Returns the q inverse.
 	///
 	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> inverse(
-		tdualquat<T, P> const & q);
+	GLM_FUNC_DECL tdualquat<T, P> inverse(tdualquat<T, P> const & q);

 	/// Converts a quaternion to a 2 * 4 matrix.
 	///
 	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> mat2x4_cast(
-		tdualquat<T, P> const & x);
+	GLM_FUNC_DECL tmat2x4<T, P> mat2x4_cast(tdualquat<T, P> const & x);

 	/// Converts a quaternion to a 3 * 4 matrix.
 	///
 	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> mat3x4_cast(
-		tdualquat<T, P> const & x);
+	GLM_FUNC_DECL tmat3x4<T, P> mat3x4_cast(tdualquat<T, P> const & x);

 	/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
 	///
 	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
-		tmat2x4<T, P> const & x);
+	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(tmat2x4<T, P> const & x);

 	/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
 	///
 	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
-	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
-		tmat3x4<T, P> const & x);
+	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(tmat3x4<T, P> const & x);


 	/// Dual-quaternion of low single-precision floating-point numbers.
--- a/glm/gtx/dual_quaternion.inl
+++ b/glm/gtx/dual_quaternion.inl
@ -35,8 +35,7 @@

 namespace glm
 {
-	//////////////////////////////////////
-	// Component accesses
+	// -- Component accesses --

 #	ifdef GLM_FORCE_SIZE_FUNC
 		template <typename T, precision P>
@ -80,8 +79,7 @@ namespace glm
 		}
 #	endif//GLM_FORCE_SIZE_FUNC

-	//////////////////////////////////////
-	// Implicit basic constructors
+	// -- Implicit basic constructors --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
 		template <typename T, precision P>
@ -108,8 +106,7 @@ namespace glm
 		, dual(d.dual)
 	{}

-	//////////////////////////////////////
-	// Explicit basic constructors
+	// -- Explicit basic constructors --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(ctor)
@ -134,8 +131,7 @@ namespace glm
 		: real(r), dual(d)
 	{}

-	//////////////////////////////////////////////////////////////
-	// tdualquat conversions
+	// -- Conversion constructors --

 	template <typename T, precision P>
 	template <typename U, precision Q>
@ -156,8 +152,7 @@ namespace glm
 		*this = dualquat_cast(m);
 	}

-	//////////////////////////////////////////////////////////////
-	// tdualquat operators
+	// -- Unary arithmetic operators --

 #	if !GLM_HAS_DEFAULTED_FUNCTIONS
 		template <typename T, precision P>
@ -196,8 +191,7 @@ namespace glm
 		return *this;
 	}

-	//////////////////////////////////////////////////////////////
-	// tquat<valType> external operators
+	// -- Unary bit operators --

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator-(tdualquat<T, P> const & q)
@ -205,6 +199,8 @@ namespace glm
 		return tdualquat<T, P>(-q.real,-q.dual);
 	}

+	// -- Binary operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> operator+(tdualquat<T, P> const & q, tdualquat<T, P> const & p)
 	{
@ -217,7 +213,6 @@ namespace glm
 		return tdualquat<T, P>(p.real * o.real,p.real * o.dual + p.dual * o.real);
 	}

-	// Transformation
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> operator*(tdualquat<T, P> const & q, tvec3<T, P> const & v)
 	{
@ -262,8 +257,8 @@ namespace glm
 		return tdualquat<T, P>(q.real / s, q.dual / s);
 	}

-	//////////////////////////////////////
-	// Boolean operators
+	// -- Boolean operators --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER bool operator==(tdualquat<T, P> const & q1, tdualquat<T, P> const & q2)
 	{
@ -276,7 +271,8 @@ namespace glm
 		return (q1.real != q2.dual) || (q1.real != q2.dual);
 	}

-	////////////////////////////////////////////////////////
+	// -- Operations --
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P> normalize(tdualquat<T, P> const & q)
 	{