28.6 Numeric arrays [numarray] C++N4910:2022 (669) p1320.cpp

# はじめに(Introduction)
N4910  Working Draft, Standard for Programming Language C++
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf

n4910は、ISO/IEC JTC1 SC22 WG21の作業原案(Working Draft)です。
公式のISO/IEC 14882原本ではありません。
ISO/IEC JTC1 SC22 WG21では、可能な限り作業文書を公開し、幅広い意見を求めています。
一連の記事はコード断片をコンパイルできる形にする方法を検討してコンパイル、リンク、実行して、規格案の原文と処理系(g++, Clang++)との違いを確認し、技術内容を検討し、ISO/IEC JTC1 SC22 WG21にフィードバックするために用います。
また、CERT C++, MISRA C++等のコーディング標準のコード断片をコンパイルする際の参考にさせていただこうと考えています。CERT C++, MISRA C++が標準化の動きとの時間的なずれがあれば確認できれば幸いです。また、boostライブラリとの関連、Linux OS, TOPPERSカーネル、g++(GCC), clang++(LLVM）との関係も調査中です。
何か、抜け漏れ、耳より情報がありましたらおしらせくださると幸いです。

 <この項は書きかけです。順次追記します。>
## 背景(back ground)
C/C++でコンパイルエラーが出ると、途方にくれることがしばしばあります。
何回かに１回は、該当するエラーが検索できます。
ただ、条件が違っていて、そこでの修正方法では目的を達成しないこともしばしばです。いろいろな条件のコンパイルエラーとその対応方法について、広く記録することによって、いつか同じエラーに遭遇した時にやくに立つことを目指しています。

この半年の間で、三度、自分のネットでの記録に助けられたことがあります。
また過去に解決できなかった記録を１０種類以上、最近になって解決できたことがあります。それは、主に次の３つの情報に基づいています。
https://stackoverflow.com
http://ja.cppreference.com/

cpprefjp - C++日本語リファレンス
https://cpprefjp.github.io/

コンパイラの実装状況
https://cpprefjp.github.io/implementation-status.html

また
https://researchmap.jp/joub9b3my-1797580/#_1797580
に記載したサイトのお世話になっています。

## 作業方針(sequence)
Clang++では-std=c++03, C++2bの2種類
g++では-std=c++03, c++2bの２種類
でコンパイルし、

１）コンパイルエラーを収集する。
２）コンパイルエラーをなくす方法を検討する。
コンパイルエラーになる例を示すだけが目的のコードは、コンパイルエラーをなくすのではなく、コンパイルエラーの種類を収集するだけにする。
文法を示すのが目的のコード場合に、コンパイルエラーをなくすのに手間がかかる場合は、順次作業します。
３）リンクエラーをなくす方法を検討する。
文法を示すのが目的のコード場合に、リンクエラーをなくすのに手間がかかる場合は、順次作業します。
４）意味のある出力を作る。
コンパイル、リンクが通っても、意味のある出力を示そうとすると、コンパイル・リンクエラーが出て収拾できそうにない場合がある。順次作業します。

１）だけのものから４）まで進んだものと色々ある状態です。一歩でも前に進むご助言をお待ちしています。「検討事項」の欄に現状を記録するようにしています。

### C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list  

https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

### C++N4741, 2018 Standard Working Draft on ISO/IEC 14882 sample code compile list
https://qiita.com/kaizen_nagoya/items/3294c014044550896010

### C++N4606, 2016符号断片編纂一覧(example code compile list)
C++N4606, 2016 Working Draft 2016, ISO/IEC 14882, C++ standard(1) Example code compile list
https://qiita.com/kaizen_nagoya/items/df5d62c35bd6ed1c3d43/

### C++N3242, 2011 sample code compile list on clang++ and g++
https://qiita.com/kaizen_nagoya/items/685b5c1a2c17c1bf1318

## 編纂器(Compiler)
### clang++ --version
> Debian clang version 14.0.5-++20220610033153+c12386ae247c-1~exp1~20220610153237.151
Target: x86_64-pc-linux-gnu, Thread model: posix, InstalledDir: /usr/bin

### g++- --version
> g++ (GCC) 12.1.0  Copyright (C) 2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

# 28.6 Numeric arrays [numarray] C++N4910:2022 (669) p1320.cpp

## 算譜(source code)

```c++:p1320.cpp
// C++N4910 Committee Draft, Standard for Programming Language C++
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4910.pdf
const char * n4910 = "28.6 Numeric arrays [numarray] C++N4910:2022 (669) p1320.cpp";
// Debian clang version 14.0.5-++20220610033153+c12386ae247c-
// g++ (GCC) 12.1.0 Copyright (C) 2022 Free Software Foundation, Inc.
// Edited by Dr. OGAWA Kiyoshi. Compile procedure and results record.
// C++N4910:2022 Standard Working Draft on ISO/IEC 14882(0) sample code compile list
// https://qiita.com/kaizen_nagoya/items/fc957ddddd402004bb91

#include "N4910.h"

using namespace std;

// 28.6.1 Header <valarray> synopsis [valarray.syn]
#include <initializer_list>
namespace std {
template<class T> class valarray;
class slice;
template<class T> class slice_array;
// An array of type T
// a BLAS-like slice out of an array
class gslice;
template<class T> class gslice_array;
template<class T> class mask_array;
template<class T> class indirect_array;
// a generalized slice out of an array
// a masked array
// an indirected array
template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;
template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator* (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator* (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator/ (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator% (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator% (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator+ (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator- (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator- (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator^ (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator& (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator& (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator| (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator| (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator<<(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator<<(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator>>(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator>>(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator&&(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator&&(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator||(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator||(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator==(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator==(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator!=(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator< (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator> (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator<=(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator>=(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> abs  (const valarray<T>&);
template<class T> valarray<T> acos (const valarray<T>&);
template<class T> valarray<T> asin (const valarray<T>&);
template<class T> valarray<T> atan (const valarray<T>&);
template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> atan2(const valarray<T>&,
                                    const typename valarray<T>::value_type&);
template<class T> valarray<T> atan2(const typename valarray<T>::value_type&,
                                    const valarray<T>&);
template<class T> valarray<T> cos  (const valarray<T>&);
template<class T> valarray<T> cosh (const valarray<T>&);
template<class T> valarray<T> exp  (const valarray<T>&);
template<class T> valarray<T> log  (const valarray<T>&);
template<class T> valarray<T> log10(const valarray<T>&);
// — for every function taking a const valarray<T>& other than begin and end (28.6.10), identical functions taking the replacement types shall be added;
// — for every function taking two const valarray<T>& arguments, identical functions taking every combi- nation of const valarray<T>& and replacement types shall be added.
template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> pow(const valarray<T>&, const typename valarray<T>::value_type&);
template<class T> valarray<T> pow(const typename valarray<T>::value_type&, const valarray<T>&);
template<class T> valarray<T> sin  (const valarray<T>&);
template<class T> valarray<T> sinh (const valarray<T>&);
template<class T> valarray<T> sqrt (const valarray<T>&);
template<class T> valarray<T> tan  (const valarray<T>&);
template<class T> valarray<T> tanh (const valarray<T>&);
template<class T> unspecified1 begin(valarray<T>& v);
template<class T> unspecified2 begin(const valarray<T>& v);
template<class T> unspecified1 end(valarray<T>& v);
template<class T> unspecified2 end(const valarray<T>& v);
}
//  The header <valarray> defines five class templates (valarray, slice_array, gslice_array, mask_array, and indirect_array), two classes (slice and gslice), and a series of related function templates for representing and manipulating arrays of values.
//  The valarray array classes are defined to be free of certain forms of aliasing, thus allowing operations on these classes to be optimized.
//  Any function returning a valarray<T> is permitted to return an object of another type, provided all the const member functions of valarray<T> are also applicable to this type. This return type shall not add more than two levels of template nesting over the most deeply nested argument type.238
// Implementations introducing such replacement types shall provide additional functions and operators as follows:
//  In particular, an implementation shall allow a valarray<T> to be constructed from such replacement types and shall allow assignments and compound assignments of such types to valarray<T>, slice_array<T>, gslice_array<T>, mask_array<T> and indirect_array<T> objects.
//  These library functions are permitted to throw a bad_alloc (17.6.4.1) exception if there are not sufficient resources available to carry out the operation. Note that the exception is not mandated.
// 28.6.2 Class template valarray [template.valarray]
// 28.6.2.1 Overview [template.valarray.overview]
namespace std {
template<class T> class valarray {
public:
    using value_type = T;
// 28.6.2.2, construct/destroy valarray();
    explicit valarray(size_t);
    valarray(const T&, size_t);
    valarray(const T*, size_t);
    valarray(const valarray&);
    valarray(valarray&&) noexcept;
    valarray(const slice_array<T>&);
    valarray(const gslice_array<T>&);
    valarray(const mask_array<T>&);
    valarray(const indirect_array<T>&);
    valarray(initializer_list<T>);
    ~valarray();
//  238) Annex B recommends a minimum number of recursively nested template instantiations. This requirement thus indirectly suggests a minimum allowable complexity for valarray expressions.
// 28.6.2.3, assignment
    valarray& operator=(const valarray&);
    valarray& operator=(valarray&&) noexcept;
    valarray& operator=(initializer_list<T>);
    valarray& operator=(const T&);
    valarray& operator=(const slice_array<T>&);
    valarray& operator=(const gslice_array<T>&);
    valarray& operator=(const mask_array<T>&);
    valarray& operator=(const indirect_array<T>&);
// 28.6.2.4, element access
    const T& operator[](size_t) const;
    T& operator[](size_t);
// 28.6.2.5, subset operations
    valarray
    slice_array<T>
    valarray
    gslice_array<T>
    valarray
    mask_array<T>
    valarray
    indirect_array<T> operator[](const valarray<size_t>&);
    operator[](slice) const;
    operator[](slice);
    operator[](const gslice&) const;
    operator[](const gslice&);
    operator[](const valarray<bool>&) const;
    operator[](const valarray<bool>&);
    operator[](const valarray<size_t>&) const;
// 28.6.2.6, unary operators
    valarray operator+() const;
    valarray operator-() const;
    valarray operator~() const;
    valarray<bool> operator!() const;
// 28.6.2.7, compound assignment valarray& operator*= (const T&); valarray& operator/= (const T&); valarray& operator%= (const T&); valarray& operator+= (const T&); valarray& operator-= (const T&); valarray& operator^= (const T&); valarray& operator&= (const T&); valarray& operator|= (const T&); valarray& operator<<=(const T&); valarray& operator>>=(const T&);
    valarray& operator*= (const valarray&);
    valarray& operator/= (const valarray&);
    valarray& operator%= (const valarray&);
    valarray& operator+= (const valarray&);
    valarray& operator-= (const valarray&);
    valarray& operator^= (const valarray&);
    valarray& operator|= (const valarray&);
    valarray& operator&= (const valarray&);
    valarray& operator<<=(const valarray&);
    valarray& operator>>=(const valarray&);
// 28.6.2.8, member functions void swap(valarray&) noexcept;
    size_t size() const;
    T sum() const;
    T min() const;
    T max() const;
    valarray shift (int) const;
    valarray cshift(int) const;
// Effects: Constructs a valarray that has length n. Each element of the array is value-initialized (9.4). valarray(const T& v, size_t n);
    valarray apply(T func(T)) const;
    valarray apply(T func(const T&)) const;
    void resize(size_t sz, T c = T());
};
template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;
}
//  The class template valarray<T> is a one-dimensional smart array, with elements numbered sequentially from zero. It is a representation of the mathematical concept of an ordered set of values. For convenience, an object of type valarray<T> is referred to as an “array” throughout the remainder of 28.6. The illusion of higher dimensionality may be produced by the familiar idiom of computed indices, together with the powerful subsetting capabilities provided by the generalized subscript operators.239
// 28.6.2.2 Constructors [valarray.cons]
valarray();
// Effects: Constructs a valarray that has zero length.240 explicit valarray(size_t n);
// Effects: Constructs a valarray that has length n. Each element of the array is initialized with v.
valarray(const T* p, size_t n);
// Preconditions: [p, p + n) is a valid range.
// Effects: Constructs a valarray that has length n. The values of the elements of the array are initialized
with the first n values pointed to by the first argument.241 valarray(const valarray& v);
// Effects: Constructs a valarray that has the same length as v. The elements are initialized with the values of the corresponding elements of v.242
valarray(valarray&& v) noexcept;
// Effects: Constructs a valarray that has the same length as v. The elements are initialized with the values of the corresponding elements of v.
// Complexity: Constant. valarray(initializer_list<T> il);
// Effects: Equivalent to valarray(il.begin(), il.size()).
valarray(const slice_array<T>&);
valarray(const gslice_array<T>&);
valarray(const mask_array<T>&);
valarray(const indirect_array<T>&);
// These conversion constructors convert one of the four reference templates to a valarray. ~valarray();
// Effects: The destructor is applied to every element of *this; an implementation may return all allocated memory.
// 239) The intent is to specify an array template that has the minimum functionality necessary to address aliasing ambiguities and the proliferation of temporary objects. Thus, the valarray template is neither a matrix class nor a field class. However, it is a very useful building block for designing such classes.
// 240) This default constructor is essential, since arrays of valarray can be useful. After initialization, the length of an empty array can be increased with the resize member function.
// 241) This constructor is the preferred method for converting a C array to a valarray object.
// 242) This copy constructor creates a distinct array rather than an alias. Implementations in which arrays share storage are permitted, but they would need to implement a copy-on-reference mechanism to ensure that arrays are conceptually distinct.
// 28.6.2.3 Assignment [valarray.assign]
valarray& operator=(const valarray& v);
// Effects: Each element of the *this array is assigned the value of the corresponding element of v. If the length of v is not equal to the length of *this, resizes *this to make the two arrays the same length, as if by calling resize(v.size()), before performing the assignment.
// Postconditions: size() == v.size(). Returns: *this.
//  The member operator[] is overloaded to provide several ways to select sequences of elements from among those controlled by *this. Each of these operations returns a subset of the array. The const-qualified versions return this subset as a new valarray object. The non-const versions return a class template object which has reference semantics to the original array, working in conjunction with various overloads of operator=
valarray& operator=(valarray&& v) noexcept;
// Effects: *this obtains the value of v. The value of v after the assignment is not specified. Returns: *this.
// Complexity: Linear.
valarray& operator=(initializer_list<T> il);
Effects:
Equivalent to:
return *this = valarray(il);
valarray& operator=(const T& v);
Effects:
Assigns v to each element of *this. Returns:
*this.
valarray& operator=(const slice_array<T>&);
valarray& operator=(const gslice_array<T>&);
valarray& operator=(const mask_array<T>&);
valarray& operator=(const indirect_array<T>&);
// Preconditions: The length of the array to which the argument refers equals size(). The value of an element in the left-hand side of a valarray assignment operator does not depend on the value of another element in that left-hand side.
// These operators allow the results of a generalized subscripting operation to be assigned directly to a valarray.
// 28.6.2.4 Element access [valarray.access]
const T&  operator[](size_t n) const;
T& operator[](size_t n);
// Preconditions: n < size() is true.
// Returns: A reference to the corresponding element of the array.
// [Note 1: The expression (a[i] = q, a[i]) == q evaluates to true for any non-constant valarray<T> a, any T q, and for any size_t i such that the value of i is less than the length of a.
// Remarks: The expression addressof(a[i+j]) == addressof(a[i]) + j evaluates to true for all size_t i and size_t j such that i+j < a.size().
// The expression addressof(a[i]) != addressof(b[j]) evaluates to true for any two arrays a and b and for any size_t i and size_t j such that i < a.size() and j < b.size().
// [Note 2: This property indicates an absence of aliasing and can be used to advantage by optimizing compilers. Compilers can take advantage of inlining, constant propagation, loop fusion, tracking of pointers obtained from operator new, and other techniques to generate efficient valarrays.
// The reference returned by the subscript operator for an array shall be valid until the member function resize(size_t, T) (28.6.2.8) is called for that array or until the lifetime of that array ends, whichever happens first.
// 28.6.2.5 Subset operations [valarray.sub]
// and other assigning operators to allow selective replacement (slicing) of the controlled sequence. In each case the selected element(s) shall exist.
valarray operator[](slice slicearr) const;
// Returns: A valarray containing those elements of the controlled sequence designated by slicearr. [Example 1:
const valarray<char> v0("abcdefghijklmnop", 16);
// v0[slice(2, 5, 3)] returns valarray<char>("cfilo", 5)
// Returns: An object that holds references to elements of the controlled sequence selected by gslicearr. [Example 4:
valarray<char> v0("abcdefghijklmnop", 16);
valarray<char> v1("ABCDEF", 6);
const size_t lv[] = { 2, 3 };
const size_t dv[] = { 7, 2 };
const valarray<size_t> len(lv, 2), str(dv, 2);
v0[gslice(3, len, str)] = v1;
// v0 == valarray<char>("abcAeBgCijDlEnFp", 16)
// Returns: A valarray containing those elements of the controlled sequence designated by boolarr. [Example 5:
const valarray<char> v0("abcdefghijklmnop", 16);
const bool vb[] = { false, false, true, true, false, true }; // v0[valarray<bool>(vb, 6)] returns
// valarray<char>("cdf", 3)
slice_array<T> operator[](slice slicearr);
// Returns: An object that holds references to elements of the controlled sequence selected by slicearr. [Example 2:
valarray<char> v0("abcdefghijklmnop", 16);
valarray<char> v1("ABCDE", 5);
v0[slice(2, 5, 3)] = v1;
// v0 == valarray<char>("abAdeBghCjkDmnEp", 16);
valarray operator[](const gslice& gslicearr) const;
// Returns: A valarray containing those elements of the controlled sequence designated by gslicearr. [Example 3:
const valarray<char> v0("abcdefghijklmnop", 16);
const size_t lv[] = { 2, 3 };
const size_t dv[] = { 7, 2 };
const valarray<size_t> len(lv, 2), str(dv, 2); // v0[gslice(3, len, str)] returns
// valarray<char>("dfhkmo", 6) —end example]
gslice_array<T> operator[](const gslice& gslicearr);
valarray operator[](const valarray<bool>& boolarr) const;
mask_array<T> operator[](const valarray<bool>& boolarr);
// Returns: An object that holds references to elements of the controlled sequence selected by boolarr. [Example 6:
valarray<char> v0("abcdefghijklmnop", 16);
// Returns: A valarray containing those elements of the controlled sequence designated by indarr. [Example 7:
const valarray<char> v0("abcdefghijklmnop", 16);
const size_t vi[] = { 7, 5, 2, 3, 8 };
// v0[valarray<size_t>(vi, 5)] returns
// valarray<char>("hfcdi", 5)
// Mandates: The indicated operator can be applied to operands of type T and returns a value of type T (bool for operator!) or which may be unambiguously implicitly converted to type T (bool for operator!).
// Returns: A valarray whose length is size(). Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding element of the array.
// Mandates: The indicated operator can be applied to two operands of type T.
// Preconditions: size() == v.size() is true.
// The value of an element in the left-hand side of a valarray compound assignment operator does not depend on the value of another element in that left hand side.
// Effects: Each of these operators performs the indicated operation on each of the elements of *this and the corresponding element of v.
// Returns: *this.
valarray<char> v1("ABC", 3);
const bool vb[] = { false, false, true, true, false, true };
v0[valarray<bool>(vb, 6)] = v1;
// v0 == valarray<char>("abABeCghijklmnop", 16)
valarray operator[](const valarray<size_t>& indarr) const;
indirect_array<T> operator[](const valarray<size_t>& indarr);
// Returns: An object that holds references to elements of the controlled sequence selected by indarr. [Example 8:
valarray<char> v0("abcdefghijklmnop", 16);
valarray<char> v1("ABCDE", 5);
const size_t vi[] = { 7, 5, 2, 3, 8 };
v0[valarray<size_t>(vi, 5)] = v1;
// v0 == valarray<char>("abCDeBgAEjklmnop", 16)
// 28.6.2.6 Unary operators [valarray.unary]
valarray operator+() const;
valarray operator-() const;
valarray operator~() const;
valarray<bool> operator!() const;
// 28.6.2.7 Compound assignment [valarray.cassign]
valarray& operator*= (const valarray& v);
valarray& operator/= (const valarray& v);
valarray& operator%= (const valarray& v);
valarray& operator+= (const valarray& v);
valarray& operator-= (const valarray& v);
valarray& operator^= (const valarray& v);
valarray& operator&= (const valarray& v);
valarray& operator|= (const valarray& v);
valarray& operator<<=(const valarray& v);
valarray& operator>>=(const valarray& v);
// Mandates: The indicated operator can be applied to two operands of type T.
// Effects: Each of these operators applies the indicated operation to each element of *this and v.
// Returns: *this
// Remarks: The appearance of an array on the left-hand side of a compound assignment does not invalidate references or pointers to the elements of the array.
// Remarks: The appearance of an array on the left-hand side of a compound assignment does not invalidate references or pointers.
valarray& operator*= (const T& v);
valarray& operator/= (const T& v);
valarray& operator%= (const T& v);
valarray& operator+= (const T& v);
valarray& operator-= (const T& v);
valarray& operator^= (const T& v);
valarray& operator&= (const T& v);
valarray& operator|= (const T& v);
valarray& operator<<=(const T& v);
valarray& operator>>=(const T& v);
// 28.6.2.8 Member functions [valarray.members]
void swap(valarray& v) noexcept;
// Effects: *this obtains the value of v. v obtains the value of *this.
// Complexity: Constant.
size_t size() const;
// Returns: The number of elements in the array. Complexity: Constant time.
T sum() const;
// Mandates: operator+= can be applied to operands of type T.
// Preconditions: size() > 0 is true.
// Returns: The sum of all the elements of the array. If the array has length 1, returns the value of element 0. Otherwise, the returned value is calculated by applying operator+= to a copy of an element of the array and all other elements of the array in an unspecified order.
T min() const;
// Preconditions: size() > 0 is true.
// Returns: The minimum value contained in *this. For an array of length 1, the value of element 0 is returned. For all other array lengths, the determination is made using operator<.
T max() const;
// Preconditions: size() > 0 is true.
// Returns: The maximum value contained in *this. For an array of length 1, the value of element 0 is
returned. For all other array lengths, the determination is made using operator<. valarray shift(int n) const;
// Returns: A valarray of length size(), each of whose elements I is (*this)[I + n] if I + n is non-negative and less than size(), otherwise T().
// [Note 1: If element zero is taken as the leftmost element, a positive value of n shifts the elements left n places, with zero fill. —end note]
// [Example 1: If the argument has the value −2, the first two elements of the result will be value-initialized (9.4); the third element of the result will be assigned the value of the first element of the argument; etc.
// Mandates: The indicated operator can be applied to operands of type T and returns a value of type T or which can be unambiguously implicitly converted to T.
// Preconditions: The argument arrays have the same length.
// Returns: A valarray whose length is equal to the lengths of the argument arrays. Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding elements of the argument arrays.
valarray cshift(int n) const;
// Returns: A valarray of length size() that is a circular shift of *this. If element zero is taken as the leftmost element, a non-negative value of n shifts the elements circularly left n places and a negative value of n shifts the elements circularly right −n places.
valarray apply(T func(T)) const;
valarray apply(T func(const T&)) const;
// Returns: A valarray whose length is size(). Each element of the returned array is assigned the value returned by applying the argument function to the corresponding element of *this.
void resize(size_t sz, T c = T());
// Effects: Changes the length of the *this array to sz and then assigns to each element the value of the second argument. Resizing invalidates all pointers and references to elements in the array.
// 28.6.3 valarray non-member operations [valarray.nonmembers]
// 28.6.3.1 Binary operators [valarray.binary]
template<class T> valarray<T> operator* (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator/ (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator% (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator+ (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator- (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator^ (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator& (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator| (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator<<(const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator>>(const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> operator* (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator* (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator/ (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator/ (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator% (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator% (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator+ (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator+ (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator- (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator- (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator^ (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator^ (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator& (const valarray<T>&,
        const typename valarray<T>::value_type&);
// Mandates: The indicated operator can be applied to operands of type T and returns a value of type T or which can be unambiguously implicitly converted to T.
// Returns: A valarray whose length is equal to the length of the array argument. Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding element of the array argument and the non-array argument.
// Mandates: The indicated operator can be applied to operands of type T and returns a value of type bool or which can be unambiguously implicitly converted to bool.
// Preconditions: The two array arguments have the same length.
// Returns: A valarray<bool> whose length is equal to the length of the array arguments. Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding elements of the argument arrays.
template<class T> valarray<T> operator& (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator| (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator| (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator<<(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator<<(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<T> operator>>(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<T> operator>>(const typename valarray<T>::value_type&,
        const valarray<T>&);
// 28.6.3.2 Logical operators [valarray.comparison]
template<class T> valarray<bool> operator==(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator!=(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator< (const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator> (const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator<=(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator>=(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator&&(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator||(const valarray<T>&, const valarray<T>&);
template<class T> valarray<bool> operator==(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator==(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator!=(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator!=(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator< (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator< (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator> (const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator> (const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator<=(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator<=(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator>=(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator>=(const typename valarray<T>::value_type&,
        const valarray<T>&);
// Mandates: The indicated operator can be applied to operands of type T and returns a value of type bool or which can be unambiguously implicitly converted to bool.
// Returns: A valarray<bool> whose length is equal to the length of the array argument. Each element of the returned array is initialized with the result of applying the indicated operator to the corresponding element of the array and the non-array argument.
// Mandates: A unique function with the indicated name can be applied (unqualified) to an operand of type T. This function returns a value of type T or which can be unambiguously implicitly converted to type T.
template<class T> valarray<bool> operator&&(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator&&(const typename valarray<T>::value_type&,
        const valarray<T>&);
template<class T> valarray<bool> operator||(const valarray<T>&,
        const typename valarray<T>::value_type&);
template<class T> valarray<bool> operator||(const typename valarray<T>::value_type&,
        const valarray<T>&);
// 28.6.3.3 Transcendentals [valarray.transcend]
template<class T> valarray<T> abs  (const valarray<T>&);
template<class T> valarray<T> acos (const valarray<T>&);
template<class T> valarray<T> asin (const valarray<T>&);
template<class T> valarray<T> atan (const valarray<T>&);
template<class T> valarray<T> atan2(const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> atan2(const valarray<T>&, const typename valarray<T>::value_type&);
template<class T> valarray<T> atan2(const typename valarray<T>::value_type&, const valarray<T>&);
template<class T> valarray<T> cos  (const valarray<T>&);
template<class T> valarray<T> cosh (const valarray<T>&);
template<class T> valarray<T> exp  (const valarray<T>&);
template<class T> valarray<T> log  (const valarray<T>&);
template<class T> valarray<T> log10(const valarray<T>&);
template<class T> valarray<T> pow  (const valarray<T>&, const valarray<T>&);
template<class T> valarray<T> pow  (const valarray<T>&, const typename valarray<T>::value_type&);
template<class T> valarray<T> pow  (const typename valarray<T>::value_type&, const valarray<T>&);
template<class T> valarray<T> sin  (const valarray<T>&);
template<class T> valarray<T> sinh (const valarray<T>&);
template<class T> valarray<T> sqrt (const valarray<T>&);
template<class T> valarray<T> tan  (const valarray<T>&);
template<class T> valarray<T> tanh (const valarray<T>&);
// 28.6.3.4 Specialized algorithms [valarray.special]
template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
}
// Effects: Equivalent to x.swap(y).
// 28.6.4 Class slice  [class.slice]
// 28.6.4.1 Overview [class.slice.overview]
namespace std {
class slice {
public:
    slice();
    slice(size_t, size_t, size_t);
    size_t start() const;
    size_t size() const;
    size_t stride() const;
    friend bool operator==(const slice& x, const slice& y);
};
}
// The default constructor is equivalent to slice(0, 0, 0). A default constructor is provided only to permit the declaration of arrays of slices. The constructor with arguments for a slice takes a start, length, and stride parameter.
// [Example 1 : slice(3, 8, 2) constructs a slice which selects elements 3, 5, 7, . . . , 17 from an array.
// The slice class represents a BLAS-like slice from an array. Such a slice is specified by a starting index, a length, and a stride.243
// 28.6.4.2 Constructors[cons.slice]
slice();
slice(size_t start, size_t length, size_t stride);
slice(const slice&);
// 28.6.4.3 Access functions [slice.access]
size_t start() const;
size_t size() const;
size_t stride() const;
// Returns: The start, length, or stride specified by a slice object. Complexity: Constant time.
// 28.6.4.4 Operators [slice.ops]
friend bool operator==(const slice& x, const slice& y);
// Effects: Equivalent to:
return x.start() == y.start() && x.size() == y.size() && x.stride() == y.stride();
// 28.6.5 Class template slice_array [template.slice.array]
// 28.6.5.1 Overview \template.slice.array.overview]
namespace std {
template<class T> class slice_array {
public:
    using value_type = T;
    void operator=  (const valarray<T>&) const;
    void operator*= (const valarray<T>&) const;
    void operator/= (const valarray<T>&) const;
    void operator%= (const valarray<T>&) const;
    void operator+= (const valarray<T>&) const;
    void operator-= (const valarray<T>&) const;
    void operator^= (const valarray<T>&) const;
    void operator&= (const valarray<T>&) const;
    void operator|= (const valarray<T>&) const;
    void operator<<=(const valarray<T>&) const;
    void operator>>=(const valarray<T>&) const;
    slice_array(const slice_array&);
    ~slice_array();
    const slice_array& operator=(const slice_array&) const;
    void operator=(const T&) const;
    slice_array() = delete; // as implied by declaring copy constructor above
};
}
//  This template is a helper template used by the slice subscript operator slice_array<T> valarray<T>::operator[](slice);
// 243) BLAS stands for Basic Linear Algebra Subprograms. C++ programs can instantiate this class. See, for example, Dongarra, Du Croz, Duff, and Hammerling: A set of Level 3 Basic Linear Algebra Subprograms; Technical Report MCS-P1-0888, Argonne National Laboratory (USA), Mathematics and Computer Science Division, August, 1988.
// These assignment operators have reference semantics, assigning the values of the argument array elements to selected elements of the valarray<T> object to which the slice_array object refers.
// These compound assignments have reference semantics, applying the indicated operation to the elements of the argument array and selected elements of the valarray<T> object to which the slice_array object refers.
//  It has reference semantics to a subset of an array specified by a slice object.
// [Example 1: The expression a[slice(1, 5, 3)] = b; has the effect of assigning the elements of b to a slice of the elements in a. For the slice shown, the elements selected from a are 1, 4, . . . , 13.
// 28.6.5.2 Assignment [slice.arr.assign]
void operator=(const valarray<T>&) const;
const slice_array& operator=(const slice_array&) const;
// 28.6.5.3 Compound assignment [slice.arr.comp.assign]
void operator*= (const valarray<T>&) const;
void operator/= (const valarray<T>&) const;
void operator%= (const valarray<T>&) const;
void operator+= (const valarray<T>&) const;
void operator-= (const valarray<T>&) const;
void operator^= (const valarray<T>&) const;
void operator&= (const valarray<T>&) const;
void operator|= (const valarray<T>&) const;
void operator<<=(const valarray<T>&) const;
void operator>>=(const valarray<T>&) const;
// 28.6.5.4 Fill function [slice.arr.fill]
void operator=(const T&) const;
// This function has reference semantics, assigning the value of its argument to the elements of the valarray<T> object to which the slice_array object refers.
// 28.6.6 The gslice class  [class.gslice]
// 28.6.6.1 Overview [class.gslice.overview]
namespace std {
class gslice {
public:

    gslice();
    gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d);
    size_t           start() const;
    valarray<size_t> size() const;
    valarray<size_t> stride() const;
};
}
//  This class represents a generalized slice out of an array. A gslice is defined by a starting offset (s), a set of lengths (lj), and a set of strides (dj). The number of lengths shall equal the number of strides.
//  A gslice represents a mapping from a set of indices (ij), equal in number to the number of strides, to a single index k. It is useful for building multidimensional array classes using the valarray template, which is one-dimensional. The set of one-dimensional index values specified by a gslice are k = s + 􏰓 ij dj j where the multidimensional indices ij range in value from 0 to lij − 1.
//  [Example 1 : The gslice specification
start  = 3
         length = {2, 4, 3}
                  stride = {19, 4, 1}
// The default constructor is equivalent to gslice(0, valarray<size_t>(), valarray<size_t>()). The constructor with arguments builds a gslice based on a specification of start, lengths, and strides, as explained in the previous subclause. k = 3+(0,1)×19+(0,1,2,3)×4+(0,1,2)×1 yields the sequence of one-dimensional indiceswhich are ordered as shown in the following table: That is, the highest-ordered index turns fastest. —end example]
//  It is possible to have degenerate generalized slices in which an address is repeated.
//  [Example 2: If the stride parameters in the previous example are changed to {1, 1, 1}, the first few elements of the resulting sequence of indices will be (0, 0, 0, 3), (0, 0, 1, 4), (0, 0, 2, 5), (0, 1, 0, 4), (0, 1, 1, 5), (0, 1, 2, 6), ...
//  If a degenerate slice is used as the argument to the non-const version of operator[](const gslice&), the behavior is undefined.
// 28.6.6.2 Constructors [gslice.cons]
                           gslice();
gslice(size_t start, const valarray<size_t>& lengths,
       const valarray<size_t>& strides);
gslice(const gslice&);
// 28.6.6.3 Access functions [gslice.access]
size_t           start()  const;
valarray<size_t> size() const;
valarray<size_t> stride() const;
// Returns: The representation of the start, lengths, or strides specified for the gslice. Complexity: start() is constant time. size() and stride() are linear in the number of strides. These compound assignments have reference semantics, applying the indicated operation to the elements of the argument array and selected elements of the valarray<T> object to which the gslice_array object refers.
// 28.6.7 Class template gslice_array [template.gslice.array]
// 28.6.7.1 Overview [template.gslice.array.overview]
namespace std {
template<class T> class gslice_array {
public:
    using value_type = T;
    void operator=  (const valarray<T>&) const;
    void operator*= (const valarray<T>&) const;
    void operator/= (const valarray<T>&) const;
    void operator%= (const valarray<T>&) const;
    void operator+= (const valarray<T>&) const;
    void operator-= (const valarray<T>&) const;
    void operator^= (const valarray<T>&) const;
    void operator&= (const valarray<T>&) const;
    void operator|= (const valarray<T>&) const;
    void operator<<=(const valarray<T>&) const;
    void operator>>=(const valarray<T>&) const;
    gslice_array(const gslice_array&);
    ~gslice_array();
    const gslice_array& operator=(const gslice_array&) const;
    void operator=(const T&) const;
    gslice_array() = delete; // as implied by declaring copy constructor above
};
}
// This template is a helper template used by the gslice subscript operator gslice_array<T> valarray<T>::operator[](const gslice&);
//  It has reference semantics to a subset of an array specified by a gslice object. Thus, the expression a[gslice(1, length, stride)] = b has the effect of assigning the elements of b to a generalized slice of the elements in a.
// 28.6.7.2 Assignment [gslice.array.assign]
void operator=(const valarray<T>&) const;
const gslice_array& operator=(const gslice_array&) const;
// These assignment operators have reference semantics, assigning the values of the argument array elements to selected elements of the valarray<T> object to which the gslice_array refers.
// 28.6.7.3 Compound assignment [gslice.array.comp.assign]
void operator*= (const valarray<T>&) const;
void operator/= (const valarray<T>&) const;
void operator%= (const valarray<T>&) const;
void operator+= (const valarray<T>&) const;
void operator-= (const valarray<T>&) const;
void operator^= (const valarray<T>&) const;
void operator&= (const valarray<T>&) const;
void operator|= (const valarray<T>&) const;
void operator<<=(const valarray<T>&) const;
void operator>>=(const valarray<T>&) const;
// 28.6.7.4 Fill function [gslice.array.fill]
void operator=(const T&) const;
// This function has reference semantics, assigning the value of its argument to the elements of the valarray<T> object to which the gslice_array object refers. These compound assignments have reference semantics, applying the indicated operation to the elements of the argument array and selected elements of the valarray<T> object to which the mask_array object refers.
// 28.6.8 Class template mask_array [template.mask.array]
// 28.6.8.1 Overview [template.mask.array.overview]
namespace std {
template<class T> class mask_array {
public:
    using value_type = T;
    void operator=  (const valarray<T>&) const;
    void operator*= (const valarray<T>&) const;
    void operator/= (const valarray<T>&) const;
    void operator%= (const valarray<T>&) const;
    void operator+= (const valarray<T>&) const;
    void operator-= (const valarray<T>&) const;
    void operator^= (const valarray<T>&) const;
    void operator&= (const valarray<T>&) const;
    void operator|= (const valarray<T>&) const;
    void operator<<=(const valarray<T>&) const;
    void operator>>=(const valarray<T>&) const;
    mask_array(const mask_array&);
    ~mask_array();
    const mask_array& operator=(const mask_array&) const;
    void operator=(const T&) const;
    mask_array() = delete; // as implied by declaring copy constructor above
};
}
//  This template is a helper template used by the mask subscript operator: mask_array<T> valarray<T>::operator[](const valarray<bool>&).
//  It has reference semantics to a subset of an array specified by a boolean mask. Thus, the expression a[mask] = b; has the effect of assigning the elements of b to the masked elements in a (those for which the corresponding element in mask is true).
// 28.6.8.2 Assignment [mask.array.assign]
void operator=(const valarray<T>&) const;
const mask_array& operator=(const mask_array&) const;
// These assignment operators have reference semantics, assigning the values of the argument array elements to selected elements of the valarray<T> object to which the mask_array object refers.
// 28.6.8.3 Compound assignment [mask.array.comp.assign]
void operator*= (const valarray<T>&) const;
void operator/= (const valarray<T>&) const;
void operator%= (const valarray<T>&) const;
void operator+= (const valarray<T>&) const;
void operator-= (const valarray<T>&) const;
void operator^= (const valarray<T>&) const;
void operator&= (const valarray<T>&) const;
void operator|= (const valarray<T>&) const;
void operator<<=(const valarray<T>&) const;
void operator>>=(const valarray<T>&) const;
// 28.6.8.4 Fill function [mask.array.fill]
void operator=(const T&) const;
// This function has reference semantics, assigning the value of its argument to the elements of the valarray<T> object to which the mask_array object refers.
// 28.6.9 Class template indirect_array  [template.indirect.array]
// 28.6.9.1 Overview [template.indirect.array.overview]
namespace std {
template<class T> class indirect_array {
public:
    using value_type = T;
    void operator=  (const valarray<T>&) const;
    void operator*= (const valarray<T>&) const;
    void operator/= (const valarray<T>&) const;
    void operator%= (const valarray<T>&) const;
    void operator+= (const valarray<T>&) const;
    void operator-= (const valarray<T>&) const;
    void operator^= (const valarray<T>&) const;
    void operator&= (const valarray<T>&) const;
    void operator|= (const valarray<T>&) const;
    void operator<<=(const valarray<T>&) const;
    void operator>>=(const valarray<T>&) const;
    indirect_array(const indirect_array&);
    ~indirect_array();
    const indirect_array& operator=(const indirect_array&) const;
    void operator=(const T&) const;
    indirect_array() = delete; // as implied by declaring copy constructor above
};
}
//  This template is a helper template used by the indirect subscript operator indirect_array<T> valarray<T>::operator[](const valarray<size_t>&).
//  It has reference semantics to a subset of an array specified by an indirect_array. Thus, the expression a[indirect] = b; has the effect of assigning the elements of b to the elements in a whose indices appear in indirect.
// 28.6.9.2 Assignment [indirect.array.assign]
void operator=(const valarray<T>&) const;
const indirect_array& operator=(const indirect_array&) const;
// These assignment operators have reference semantics, assigning the values of the argument array elements to selected elements of the valarray<T> object to which it refers. If the indirect_array specifies an element in the valarray<T> object to which it refers more than once, the behavior is undefined.
// [Example 1:
int addr[] = {2, 3, 1, 4, 4};
valarray<size_t> indirect(addr, 5);
valarray<double> a(0., 10), b(1., 5);
a[indirect] = b;
// results in undefined behavior since element 4 is specified twice in the indirection.
// 28.6.9.3 Compound assignment [indirect.array.comp.assign]
void operator*= (const valarray<T>&) const;
void operator/= (const valarray<T>&) const;
void operator%= (const valarray<T>&) const;
void operator+= (const valarray<T>&) const;
void operator-= (const valarray<T>&) const;
void operator^= (const valarray<T>&) const;
void operator&= (const valarray<T>&) const;
void operator|= (const valarray<T>&) const;
void operator<<=(const valarray<T>&) const;
void operator>>=(const valarray<T>&) const;
//  In the begin and end function templates that follow, unspecified 1 is a type that meets the requirements of a mutable Cpp17RandomAccessIterator (25.3.5.7) and models contiguous_iterator (25.3.4.14), whose value_type is the template parameter T and whose reference type is T&. unspecified 2 is a type that meets the requirements of a constant Cpp17RandomAccessIterator and models contiguous_iterator, whose value_type is the template parameter T and whose reference type is const T&.
//  The iterators returned by begin and end for an array are guaranteed to be valid until the member function resize(size_t, T) (28.6.2.8) is called for that array or until the lifetime of that array ends, whichever happens first. These compound assignments have reference semantics, applying the indicated operation to the elements of the argument array and selected elements of the valarray<T> object to which the indirect_array object refers.If the indirect_array specifies an element in the valarray<T> object to which it refers more than once, the behavior is undefined.
// 28.6.9.4 Fill function [indirect.array.fill]
void operator=(const T&) const;
// This function has reference semantics, assigning the value of its argument to the elements of the valarray<T> object to which the indirect_array object refers.
// 28.6.10 valarray range access [valarray.range]
template<class T> unspecified1 begin(valarray<T>& v);
template<class T> unspecified2 begin(const valarray<T>& v);
//Returns: An iterator referencing the first value in the array. template<class T> unspecified1 end(valarray<T>& v);
template<class T> unspecified2 end(const valarray<T>& v);
// Returns: An iterator referencing one past the last value in the array.
int main() {
    cout  <<  n4910 << endl;
    return EXIT_SUCCESS;
}
```

## 編纂・実行結果(compile and go)

```ubuntu:bash
$ clang++ p1320.cpp -std=03 -o p1320l -I. -Wall
In file included from p1320.cpp:10:
In file included from ./N4910.h:11:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/atomic:38:
/usr/bin/../lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/c++0x_warning.h:32:2: error: This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
#error This file requires compiler and library support \
 ^
p1320.cpp:29:56: error: expected ';' at end of declaration
template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;
                                                       ^
                                                       ;
p1320.cpp:29:57: error: C++ requires a type specifier for all declarations
template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;
                                                        ^
p1320.cpp:144:19: error: unknown type name 'unspecified1'
template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
                  ^
p1320.cpp:144:73: error: unknown type name 'unspecified2'
template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
                                                                        ^
p1320.cpp:144:133: error: unknown type name 'unspecified1'
template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
                                                                                                                                    ^
p1320.cpp:144:185: error: unknown type name 'unspecified2'
template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
                                                                                                                                                                                        ^
p1320.cpp:157:26: warning: alias declarations are a C++11 extension [-Wc++11-extensions]
      using value_type = T;
                         ^
p1320.cpp:159:128: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
explicit valarray(size_t); valarray(const T&, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
                                                                                                                               ^
p1320.cpp:159:131: error: expected ';' at end of declaration list
explicit valarray(size_t); valarray(const T&, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
                                                                                                                                  ^
                                                                                                                                  ;
p1320.cpp:162:67: warning: rvalue references are a C++11 extension [-Wc++11-extensions]
valarray& operator=(const valarray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&);
                                                                  ^
p1320.cpp:162:70: error: expected ';' at end of declaration list
valarray& operator=(const valarray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&);
                                                                     ^
                                                                     ;
p1320.cpp:162:101: error: no template named 'initializer_list'
valarray& operator=(const valarray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&);
                                                                                                    ^
p1320.cpp:168:15: error: expected ';' at end of declaration list
slice_array<T>
              ^
              ;
p1320.cpp:175:1: error: C++ requires a type specifier for all declarations
operator[](slice) const;
^
p1320.cpp:176:1: error: C++ requires a type specifier for all declarations
operator[](slice);
^
p1320.cpp:177:1: error: C++ requires a type specifier for all declarations
operator[](const gslice&) const;
^
p1320.cpp:178:1: error: C++ requires a type specifier for all declarations
operator[](const gslice&);
^
p1320.cpp:179:1: error: C++ requires a type specifier for all declarations
operator[](const valarray<bool>&) const;
^
p1320.cpp:180:1: error: C++ requires a type specifier for all declarations
operator[](const valarray<bool>&);
^
p1320.cpp:181:1: error: C++ requires a type specifier for all declarations
operator[](const valarray<size_t>&) const;
^
p1320.cpp:207:38: error: C++ requires a type specifier for all declarations
       template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;
                                     ^
fatal error: too many errors emitted, stopping now [-ferror-limit=]
3 warnings and 20 errors generated.
$ clang++ p1320.cpp -std=2b -o p1320l -I. -Wall
p1320.cpp:144:19: error: unknown type name 'unspecified1'
template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
                  ^
p1320.cpp:144:73: error: unknown type name 'unspecified2'
template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
                                                                        ^
p1320.cpp:144:133: error: unknown type name 'unspecified1'
template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
                                                                                                                                    ^
p1320.cpp:144:185: error: unknown type name 'unspecified2'
template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
                                                                                                                                                                                        ^
p1320.cpp:168:15: error: expected ';' at end of declaration list
slice_array<T>
              ^
              ;
p1320.cpp:175:1: error: C++ requires a type specifier for all declarations
operator[](slice) const;
^
p1320.cpp:176:1: error: C++ requires a type specifier for all declarations
operator[](slice);
^
p1320.cpp:177:1: error: C++ requires a type specifier for all declarations
operator[](const gslice&) const;
^
p1320.cpp:178:1: error: C++ requires a type specifier for all declarations
operator[](const gslice&);
^
p1320.cpp:179:1: error: C++ requires a type specifier for all declarations
operator[](const valarray<bool>&) const;
^
p1320.cpp:180:1: error: C++ requires a type specifier for all declarations
operator[](const valarray<bool>&);
^
p1320.cpp:181:1: error: C++ requires a type specifier for all declarations
operator[](const valarray<size_t>&) const;
^
p1320.cpp:211:1: error: deduction guide must be declared in the same scope as template 'std::valarray'
valarray();
^
p1320.cpp:155:29: note: template is declared here
    template<class T> class valarray {
                            ^
p1320.cpp:211:1: error: deduction guide declaration without trailing return type
valarray();
^
p1320.cpp:214:16: error: unknown type name 'T'
valarray(const T* p, size_t n);
               ^
p1320.cpp:214:1: error: deduction guide must be declared in the same scope as template 'std::valarray'
valarray(const T* p, size_t n);
^
p1320.cpp:155:29: note: template is declared here
    template<class T> class valarray {
                            ^
p1320.cpp:214:1: error: deduction guide declaration without trailing return type
valarray(const T* p, size_t n);
^
p1320.cpp:217:1: error: unknown type name 'with'
with the first n values pointed to by the first argument.241 valarray(const valarray& v);
^
p1320.cpp:217:9: error: expected ';' after top level declarator
with the first n values pointed to by the first argument.241 valarray(const valarray& v);
        ^
        ;
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.

$ g++ p1320.cpp -std=03 -o p1320g -I. -Wall
In file included from /usr/local/include/c++/12.1.0/atomic:38,
                 from N4910.h:11,
                 from p1320.cpp:10:
/usr/local/include/c++/12.1.0/bits/c++0x_warning.h:32:2: error: #error This file requires compiler and library support for the ISO C++ 2011 standard. This support must be enabled with the -std=c++11 or -std=gnu++11 compiler options.
   32 | #error This file requires compiler and library support \
      |  ^~~~~
p1320.cpp:29:57: warning: identifier 'noexcept' is a keyword in C++11 [-Wc++11-compat]
   29 | template<class T> void swap(valarray<T>&, valarray<T>&) noexcept;
      |                                                         ^~~~~~~~
p1320.cpp:29:57: error: expected initializer before 'noexcept'
p1320.cpp:144:19: error: 'unspecified1' does not name a type
  144 | template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
      |                   ^~~~~~~~~~~~
p1320.cpp:144:73: error: 'unspecified2' does not name a type
  144 | template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
      |                                                                         ^~~~~~~~~~~~
p1320.cpp:144:133: error: 'unspecified1' does not name a type
  144 | y<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
      |                                                                                         ^~~~~~~~~~~

p1320.cpp:144:185: error: 'unspecified2' does not name a type
  144 |  valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified end(const valarray<T>& v);
      |                                                                                         ^~~~~~~~~~~

p1320.cpp:157:13: error: expected nested-name-specifier before 'value_type'
  157 |       using value_type = T;
      |             ^~~~~~~~~~
p1320.cpp:159:128: error: expected ',' or '...' before '&&' token
  159 | st T&, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
      |                                                                                         ^~

p1320.cpp:159:111: error: invalid constructor; you probably meant 'std::valarray<T> (const std::valarray<T>&)'
  159 | _t); valarray(const T&, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
      |                                                                                         ^~~~~~~~

p1320.cpp:159:130: error: expected ';' at end of member declaration
  159 |  T&, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
      |                                                                                         ^
      |                                                                                          ;
p1320.cpp:159:132: error: 'noexcept' does not name a type
  159 | &, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
      |                                                                                         ^~~~~~~~

p1320.cpp:159:132: note: C++11 'noexcept' only available with '-std=c++11' or '-std=gnu++11'
p1320.cpp:159:302: error: expected ')' before '<' token
  159 | ray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
      |                                                                        ~                ^
      |                                                                                         )
p1320.cpp:162:67: error: expected ',' or '...' before '&&' token
  162 | valarray& operator=(const valarray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&);
      |                                                                   ^~
p1320.cpp:162:69: error: expected ';' at end of member declaration
  162 | valarray& operator=(const valarray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&);
      |                                                                     ^
      |                                                                      ;
p1320.cpp:162:71: error: 'noexcept' does not name a type
  162 | valarray& operator=(const valarray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&);
      |                                                                       ^~~~~~~~
p1320.cpp:162:71: note: C++11 'noexcept' only available with '-std=c++11' or '-std=gnu++11'
p1320.cpp:162:101: error: 'initializer_list' has not been declared
  162 | erator=(const valarray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&);
      |                                                                                         ^~~~~~~~~~~~~~~~

p1320.cpp:162:117: error: expected ',' or '...' before '<' token
  162 | larray&); valarray& operator=(valarray&&) noexcept; valarray& operator=(initializer_list<T>); valarray& operator=(const T&);
      |                                                                                         ^

p1320.cpp:169:1: error: invalid declarator before 'valarray'
  169 | valarray
      | ^~~~~~~~
p1320.cpp:175:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  175 | operator[](slice) const;
      | ^~~~~~~~
p1320.cpp:176:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  176 | operator[](slice);
      | ^~~~~~~~
p1320.cpp:177:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  177 | operator[](const gslice&) const;
      | ^~~~~~~~
p1320.cpp:178:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  178 | operator[](const gslice&);
      | ^~~~~~~~
p1320.cpp:179:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  179 | operator[](const valarray<bool>&) const;
      | ^~~~~~~~
p1320.cpp:180:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  180 | operator[](const valarray<bool>&);
      | ^~~~~~~~
p1320.cpp:181:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  181 | operator[](const valarray<size_t>&) const;
      | ^~~~~~~~
p1320.cpp:207:86: error: expected constructor, destructor, or type conversion before ';' token
  207 |        template<class T, size_t cnt> valarray(const T(&)[cnt], size_t) -> valarray<T>;
      |                                                                                      ^
p1320.cpp:211:11: error: expected constructor, destructor, or type conversion before ';' token
  211 | valarray();
      |           ^
p1320.cpp:214:16: error: 'T' does not name a type
  214 | valarray(const T* p, size_t n);
      |                ^
p1320.cpp:214:31: error: expected constructor, destructor, or type conversion before ';' token
  214 | valarray(const T* p, size_t n);
      |                               ^
p1320.cpp:217:1: error: 'with' does not name a type
  217 | with the first n values pointed to by the first argument.241 valarray(const valarray& v);
      | ^~~~
p1320.cpp:219:9: error: expected constructor, destructor, or type conversion before '(' token
  219 | valarray(valarray&& v) noexcept;
      |         ^
p1320.cpp:223:28: error: 'T' was not declared in this scope
  223 | valarray(const slice_array<T>&);
      |                            ^
p1320.cpp:223:29: error: template argument 1 is invalid
  223 | valarray(const slice_array<T>&);
      |                             ^
p1320.cpp:223:32: error: expected constructor, destructor, or type conversion before ';' token
  223 | valarray(const slice_array<T>&);
      |                                ^
p1320.cpp:224:29: error: 'T' was not declared in this scope
  224 | valarray(const gslice_array<T>&);
      |                             ^
p1320.cpp:224:30: error: template argument 1 is invalid
  224 | valarray(const gslice_array<T>&);
      |                              ^
p1320.cpp:224:33: error: expected constructor, destructor, or type conversion before ';' token
  224 | valarray(const gslice_array<T>&);
      |                                 ^
p1320.cpp:225:27: error: 'T' was not declared in this scope
  225 | valarray(const mask_array<T>&);
      |                           ^
p1320.cpp:225:28: error: template argument 1 is invalid
  225 | valarray(const mask_array<T>&);
      |                            ^
p1320.cpp:225:31: error: expected constructor, destructor, or type conversion before ';' token
  225 | valarray(const mask_array<T>&);
      |                               ^
p1320.cpp:226:31: error: 'T' was not declared in this scope
  226 | valarray(const indirect_array<T>&);
      |                               ^
p1320.cpp:226:32: error: template argument 1 is invalid
  226 | valarray(const indirect_array<T>&);
      |                                ^
p1320.cpp:226:35: error: expected constructor, destructor, or type conversion before ';' token
  226 | valarray(const indirect_array<T>&);
      |                                   ^
p1320.cpp:234:1: error: invalid use of template-name 'std::valarray' without an argument list
  234 | valarray& operator=(const valarray& v);
      | ^~~~~~~~
p1320.cpp:234:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:238:1: error: invalid use of template-name 'std::valarray' without an argument list
  238 | valarray& operator=(valarray&& v) noexcept;
      | ^~~~~~~~
p1320.cpp:238:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:241:1: error: invalid use of template-name 'std::valarray' without an argument list
  241 | valarray& operator=(initializer_list<T> il);
      | ^~~~~~~~
p1320.cpp:241:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:242:8: error: found ':' in nested-name-specifier, expected '::'
  242 | Effects: Equivalent to: return *this = valarray(il);
      |        ^
      |        ::
p1320.cpp:242:1: error: 'Effects' does not name a type
  242 | Effects: Equivalent to: return *this = valarray(il);
      | ^~~~~~~
p1320.cpp:243:1: error: invalid use of template-name 'std::valarray' without an argument list
  243 | valarray& operator=(const T& v);
      | ^~~~~~~~
p1320.cpp:243:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:244:8: error: found ':' in nested-name-specifier, expected '::'
  244 | Effects: Assigns v to each element of *this. Returns: *this.
      |        ^
      |        ::
p1320.cpp:244:1: error: 'Effects' does not name a type
  244 | Effects: Assigns v to each element of *this. Returns: *this.
      | ^~~~~~~
p1320.cpp:246:1: error: invalid use of template-name 'std::valarray' without an argument list
  246 | valarray& operator=(const gslice_array<T>&);
      | ^~~~~~~~
p1320.cpp:246:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:247:1: error: invalid use of template-name 'std::valarray' without an argument list
  247 | valarray& operator=(const mask_array<T>&);
      | ^~~~~~~~
p1320.cpp:247:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:248:1: error: invalid use of template-name 'std::valarray' without an argument list
  248 | valarray& operator=(const indirect_array<T>&);
      | ^~~~~~~~
p1320.cpp:248:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:252:7: error: 'T' does not name a type
  252 | const T&  operator[](size_t n) const;
      |       ^
p1320.cpp:253:1: error: 'T' does not name a type
  253 | T& operator[](size_t n);
      | ^
p1320.cpp:263:1: error: invalid use of template-name 'std::valarray' without an argument list
  263 | valarray operator[](slice slicearr) const;
      | ^~~~~~~~
p1320.cpp:263:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:268:18: error: conflicting declaration 'std::valarray<char> v0'
  268 |   valarray<char> v0("abcdefghijklmnop", 16);
      |                  ^~
p1320.cpp:265:22: note: previous declaration as 'const std::valarray<char> v0'
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:272:48: error: 'v0' does not name a type
  272 | const valarray<size_t> len(lv, 2), str(dv, 2); v0[gslice(3, len, str)] = v1;
      |                                                ^~
p1320.cpp:275:22: error: redefinition of 'const std::valarray<char> v0'
  275 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:265:22: note: 'const std::valarray<char> v0' previously declared here
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:278:13: error: 'T' was not declared in this scope
  278 | slice_array<T> operator[](slice slicearr);
      |             ^
p1320.cpp:278:14: error: template argument 1 is invalid
  278 | slice_array<T> operator[](slice slicearr);
      |              ^
p1320.cpp:278:16: error: 'int operator[](std::slice)' must be a non-static member function
  278 | slice_array<T> operator[](slice slicearr);
      |                ^~~~~~~~
p1320.cpp:280:16: error: conflicting declaration 'std::valarray<char> v0'
  280 | valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5);
      |                ^~
p1320.cpp:265:22: note: previous declaration as 'const std::valarray<char> v0'
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:280:59: error: redefinition of 'std::valarray<char> v1'
  280 | valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5);
      |                                                           ^~
p1320.cpp:269:18: note: 'std::valarray<char> v1' previously declared here
  269 |   valarray<char> v1("ABCDEF", 6);
      |                  ^~
p1320.cpp:281:1: error: 'v0' does not name a type
  281 | v0[slice(2, 5, 3)] = v1;
      | ^~
p1320.cpp:283:1: error: invalid use of template-name 'std::valarray' without an argument list
  283 | valarray operator[](const gslice& gslicearr) const;
      | ^~~~~~~~
p1320.cpp:283:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:285:22: error: redefinition of 'const std::valarray<char> v0'
  285 | const valarray<char> v0("abcdefghijklmnop", 16); const size_t lv[] = { 2, 3 };
      |                      ^~
p1320.cpp:265:22: note: 'const std::valarray<char> v0' previously declared here
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:285:63: error: redefinition of 'const size_t lv []'
  285 | const valarray<char> v0("abcdefghijklmnop", 16); const size_t lv[] = { 2, 3 };
      |                                                               ^~
p1320.cpp:270:16: note: 'const size_t lv [2]' previously defined here
  270 |   const size_t lv[] = { 2, 3 };
      |                ^~
p1320.cpp:286:14: error: redefinition of 'const size_t dv []'
  286 | const size_t dv[] = { 7, 2 };
      |              ^~
p1320.cpp:271:16: note: 'const size_t dv [2]' previously defined here
  271 |   const size_t dv[] = { 7, 2 };
      |                ^~
p1320.cpp:287:24: error: redefinition of 'const std::valarray<long unsigned int> len'
  287 | const valarray<size_t> len(lv, 2), str(dv, 2); // v0[gslice(3, len, str)] returns
      |                        ^~~
p1320.cpp:272:24: note: 'const std::valarray<long unsigned int> len' previously declared here
  272 | const valarray<size_t> len(lv, 2), str(dv, 2); v0[gslice(3, len, str)] = v1;
      |                        ^~~
p1320.cpp:287:36: error: redefinition of 'const std::valarray<long unsigned int> str'
  287 | const valarray<size_t> len(lv, 2), str(dv, 2); // v0[gslice(3, len, str)] returns
      |                                    ^~~
p1320.cpp:272:36: note: 'const std::valarray<long unsigned int> str' previously declared here
  272 | const valarray<size_t> len(lv, 2), str(dv, 2); v0[gslice(3, len, str)] = v1;
      |                                    ^~~
p1320.cpp:289:14: error: 'T' was not declared in this scope
  289 | gslice_array<T> operator[](const gslice& gslicearr);
      |              ^
p1320.cpp:289:15: error: template argument 1 is invalid
  289 | gslice_array<T> operator[](const gslice& gslicearr);
      |               ^
p1320.cpp:289:17: error: 'int operator[](const std::gslice&)' must be a non-static member function
  289 | gslice_array<T> operator[](const gslice& gslicearr);
      |                 ^~~~~~~~
p1320.cpp:290:1: error: invalid use of template-name 'std::valarray' without an argument list
  290 | valarray operator[](const valarray<bool>& boolarr) const;
      | ^~~~~~~~
p1320.cpp:290:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:291:12: error: 'T' was not declared in this scope
  291 | mask_array<T> operator[](const valarray<bool>& boolarr);
      |            ^
p1320.cpp:291:13: error: template argument 1 is invalid
  291 | mask_array<T> operator[](const valarray<bool>& boolarr);
      |             ^
p1320.cpp:291:15: error: 'int operator[](const std::valarray<bool>&)' must be a non-static member function
  291 | mask_array<T> operator[](const valarray<bool>& boolarr);
      |               ^~~~~~~~
p1320.cpp:293:18: error: conflicting declaration 'std::valarray<char> v0'
  293 |   valarray<char> v0("abcdefghijklmnop", 16);
      |                  ^~
p1320.cpp:265:22: note: previous declaration as 'const std::valarray<char> v0'
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:295:22: error: redefinition of 'const std::valarray<char> v0'
  295 | const valarray<char> v0("abcdefghijklmnop", 16); const size_t vi[] = { 7, 5, 2, 3, 8 };
      |                      ^~
p1320.cpp:265:22: note: 'const std::valarray<char> v0' previously declared here
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:305:16: error: redefinition of 'std::valarray<char> v1'
  305 | valarray<char> v1("ABC", 3);
      |                ^~
p1320.cpp:269:18: note: 'std::valarray<char> v1' previously declared here
  269 |   valarray<char> v1("ABCDEF", 6);
      |                  ^~
p1320.cpp:306:12: error: redefinition of 'const bool vb []'
  306 | const bool vb[] = { false, false, true, true, false, true }; v0[valarray<bool>(vb, 6)] = v1;
      |            ^~
p1320.cpp:276:12: note: 'const bool vb [6]' previously defined here
  276 | const bool vb[] = { false, false, true, true, false, true }; // v0[valarray<bool>(vb, 6)] returns
      |            ^~
p1320.cpp:306:62: error: 'v0' does not name a type
  306 | const bool vb[] = { false, false, true, true, false, true }; v0[valarray<bool>(vb, 6)] = v1;
      |                                                              ^~
p1320.cpp:308:1: error: invalid use of template-name 'std::valarray' without an argument list
  308 | valarray operator[](const valarray<size_t>& indarr) const;
      | ^~~~~~~~
p1320.cpp:308:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:309:16: error: 'T' was not declared in this scope
  309 | indirect_array<T> operator[](const valarray<size_t>& indarr);
      |                ^
p1320.cpp:309:17: error: template argument 1 is invalid
  309 | indirect_array<T> operator[](const valarray<size_t>& indarr);
      |                 ^
p1320.cpp:309:19: error: 'int operator[](const std::valarray<long unsigned int>&)' must be a non-static member function
  309 | indirect_array<T> operator[](const valarray<size_t>& indarr);
      |                   ^~~~~~~~
p1320.cpp:311:18: error: conflicting declaration 'std::valarray<char> v0'
  311 |   valarray<char> v0("abcdefghijklmnop", 16);
      |                  ^~
p1320.cpp:265:22: note: previous declaration as 'const std::valarray<char> v0'
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:312:18: error: redefinition of 'std::valarray<char> v1'
  312 |   valarray<char> v1("ABCDE", 5);
      |                  ^~
p1320.cpp:269:18: note: 'std::valarray<char> v1' previously declared here
  269 |   valarray<char> v1("ABCDEF", 6);
      |                  ^~
p1320.cpp:313:16: error: redefinition of 'const size_t vi []'
  313 |   const size_t vi[] = { 7, 5, 2, 3, 8 };
      |                ^~
p1320.cpp:295:63: note: 'const size_t vi [5]' previously defined here
  295 | const valarray<char> v0("abcdefghijklmnop", 16); const size_t vi[] = { 7, 5, 2, 3, 8 };
      |                                                               ^~
p1320.cpp:314:3: error: 'v0' does not name a type
  314 |   v0[valarray<size_t>(vi, 5)] = v1;
      |   ^~
p1320.cpp:317:1: error: invalid use of template-name 'std::valarray' without an argument list
  317 | valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      | ^~~~~~~~
p1320.cpp:317:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:317:29: error: invalid use of template-name 'std::valarray' without an argument list
  317 | valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      |                             ^~~~~~~~
p1320.cpp:317:29: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:317:57: error: invalid use of template-name 'std::valarray' without an argument list
  317 | valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      |                                                         ^~~~~~~~
p1320.cpp:317:57: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:317:112: error: non-member function 'std::valarray<bool> operator!()' cannot have cv-qualifier
  317 | () const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      |                                                                                              ^~~~~

p1320.cpp:317:100: error: 'std::valarray<bool> operator!()' must have an argument of class or enumerated type
  317 | erator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      |                                                                                         ^~~~~~~~

p1320.cpp:319:1: error: invalid use of template-name 'std::valarray' without an argument list
  319 | valarray& operator*= (const valarray& v);
      | ^~~~~~~~
p1320.cpp:319:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:320:1: error: invalid use of template-name 'std::valarray' without an argument list
  320 | valarray& operator/= (const valarray& v);
      | ^~~~~~~~
p1320.cpp:320:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:321:1: error: invalid use of template-name 'std::valarray' without an argument list
  321 | valarray& operator%= (const valarray& v);
      | ^~~~~~~~
p1320.cpp:321:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:322:1: error: invalid use of template-name 'std::valarray' without an argument list
  322 | valarray& operator+= (const valarray& v);
      | ^~~~~~~~
p1320.cpp:322:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:323:1: error: invalid use of template-name 'std::valarray' without an argument list
  323 | valarray& operator-= (const valarray& v);
      | ^~~~~~~~
p1320.cpp:323:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:324:1: error: invalid use of template-name 'std::valarray' without an argument list
  324 | valarray& operator^= (const valarray& v);
      | ^~~~~~~~
p1320.cpp:324:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:325:1: error: invalid use of template-name 'std::valarray' without an argument list
  325 | valarray& operator&= (const valarray& v);
      | ^~~~~~~~
p1320.cpp:325:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:326:1: error: invalid use of template-name 'std::valarray' without an argument list
  326 | valarray& operator|= (const valarray& v);
      | ^~~~~~~~
p1320.cpp:326:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:327:1: error: invalid use of template-name 'std::valarray' without an argument list
  327 | valarray& operator<<=(const valarray& v);
      | ^~~~~~~~
p1320.cpp:327:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:328:1: error: invalid use of template-name 'std::valarray' without an argument list
  328 | valarray& operator>>=(const valarray& v);
      | ^~~~~~~~
p1320.cpp:328:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:334:1: error: invalid use of template-name 'std::valarray' without an argument list
  334 | valarray& operator*= (const T& v);
      | ^~~~~~~~
p1320.cpp:334:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:335:1: error: invalid use of template-name 'std::valarray' without an argument list
  335 | valarray& operator/= (const T& v);
      | ^~~~~~~~
p1320.cpp:335:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:336:1: error: invalid use of template-name 'std::valarray' without an argument list
  336 | valarray& operator%= (const T& v);
      | ^~~~~~~~
p1320.cpp:336:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:337:1: error: invalid use of template-name 'std::valarray' without an argument list
  337 | valarray& operator+= (const T& v);
      | ^~~~~~~~
p1320.cpp:337:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:338:1: error: invalid use of template-name 'std::valarray' without an argument list
  338 | valarray& operator-= (const T& v);
      | ^~~~~~~~
p1320.cpp:338:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:339:1: error: invalid use of template-name 'std::valarray' without an argument list
  339 | valarray& operator^= (const T& v);
      | ^~~~~~~~
p1320.cpp:339:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:340:1: error: invalid use of template-name 'std::valarray' without an argument list
  340 | valarray& operator&= (const T& v);
      | ^~~~~~~~
p1320.cpp:340:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:341:1: error: invalid use of template-name 'std::valarray' without an argument list
  341 | valarray& operator|= (const T& v);
      | ^~~~~~~~
p1320.cpp:341:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:342:1: error: invalid use of template-name 'std::valarray' without an argument list
  342 | valarray& operator<<=(const T& v);
      | ^~~~~~~~
p1320.cpp:342:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:343:1: error: invalid use of template-name 'std::valarray' without an argument list
  343 | valarray& operator>>=(const T& v);
      | ^~~~~~~~
p1320.cpp:343:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:345:6: error: variable or field 'swap' declared void
  345 | void swap(valarray& v) noexcept;
      |      ^~~~
p1320.cpp:345:19: error: missing template arguments before '&' token
  345 | void swap(valarray& v) noexcept;
      |                   ^
p1320.cpp:345:21: error: 'v' was not declared in this scope; did you mean 'vi'?
  345 | void swap(valarray& v) noexcept;
      |                     ^
      |                     vi
p1320.cpp:348:15: error: non-member function 'size_t size()' cannot have cv-qualifier
  348 | size_t size() const;
      |               ^~~~~
p1320.cpp:350:1: error: 'T' does not name a type
  350 | T sum() const;
      | ^
p1320.cpp:354:1: error: 'T' does not name a type
  354 | T min() const;
      | ^
p1320.cpp:357:1: error: 'T' does not name a type
  357 | T max() const;
      | ^
p1320.cpp:360:1: error: 'returned' does not name a type
  360 | returned. For all other array lengths, the determination is made using operator<. valarray shift(int n) const;
      | ^~~~~~~~
p1320.cpp:367:4: error: invalid use of template-name 'std::valarray' without an argument list
  367 |    valarray cshift(int n) const;
      |    ^~~~~~~~
p1320.cpp:367:4: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:369:1: error: invalid use of template-name 'std::valarray' without an argument list
  369 | valarray apply(T func(T)) const;
      | ^~~~~~~~
p1320.cpp:369:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:370:1: error: invalid use of template-name 'std::valarray' without an argument list
  370 | valarray apply(T func(const T&)) const;
      | ^~~~~~~~
p1320.cpp:370:1: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:17:29: note: 'template<class T> class std::valarray' declared here
   17 |     template<class T> class valarray;
      |                             ^~~~~~~~
p1320.cpp:372:24: error: 'T' has not been declared
  372 | void resize(size_t sz, T c = T());
      |                        ^
p1320.cpp:372:30: error: 'T' was not declared in this scope
  372 | void resize(size_t sz, T c = T());
      |                              ^
p1320.cpp:497:61: error: expected initializer before 'noexcept'
  497 | template<class T> void swap(valarray<T>& x, valarray<T>& y) noexcept;
      |                                                             ^~~~~~~~
p1320.cpp:498:1: error: expected declaration before '}' token
  498 | }
      | ^
p1320.cpp:517:7: error: expected unqualified-id before ')' token
  517 | slice();
      |       ^
p1320.cpp:518:13: error: expected ')' before 'start'
  518 | slice(size_t start, size_t length, size_t stride);
      |      ~      ^~~~~~
      |             )
p1320.cpp:519:7: error: expected unqualified-id before 'const'
  519 | slice(const slice&);
      |       ^~~~~
p1320.cpp:519:7: error: expected ')' before 'const'
  519 | slice(const slice&);
      |      ~^~~~~
      |       )
p1320.cpp:521:16: error: non-member function 'size_t start()' cannot have cv-qualifier
  521 | size_t start() const;
      |                ^~~~~
p1320.cpp:522:15: error: non-member function 'size_t size()' cannot have cv-qualifier
  522 | size_t size() const;
      |               ^~~~~
p1320.cpp:523:17: error: non-member function 'size_t stride()' cannot have cv-qualifier
  523 | size_t stride() const;
      |                 ^~~~~
p1320.cpp:526:1: error: 'friend' used outside of class
  526 | friend bool operator==(const slice& x, const slice& y);
      | ^~~~~~
      | ------
p1320.cpp:528:1: error: expected unqualified-id before 'return'
  528 | return x.start() == y.start() && x.size() == y.size() && x.stride() == y.stride();
      | ^~~~~~
p1320.cpp:534:13: error: expected nested-name-specifier before 'value_type'
  534 |       using value_type = T;
      |             ^~~~~~~~~~
p1320.cpp:549:17: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++1' [-Wc++11-extensions]
  549 | slice_array() = delete; // as implied by declaring copy constructor above
      |                 ^~~~~~
p1320.cpp:559:34: error: 'T' was not declared in this scope
  559 |    void operator=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:559:35: error: template argument 1 is invalid
  559 |    void operator=(const valarray<T>&) const;
      |                                   ^
p1320.cpp:559:39: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  559 |    void operator=(const valarray<T>&) const;
      |                                       ^~~~~
p1320.cpp:559:9: error: 'void operator=(const int&)' must be a non-static member function
  559 |    void operator=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:560:10: error: invalid use of template-name 'std::slice_array' without an argument list
  560 |    const slice_array& operator=(const slice_array&) const;
      |          ^~~~~~~~~~~
p1320.cpp:560:10: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:19:29: note: 'template<class T> class std::slice_array' declared here
   19 |     template<class T> class slice_array;
      |                             ^~~~~~~~~~~
p1320.cpp:562:33: error: 'T' was not declared in this scope
  562 | void operator*= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:562:34: error: template argument 1 is invalid
  562 | void operator*= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:562:38: error: non-member function 'void operator*=(const int&)' cannot have cv-qualifier
  562 | void operator*= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:562:6: error: 'void operator*=(const int&)' must have an argument of class or enumerated type
  562 | void operator*= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:563:33: error: 'T' was not declared in this scope
  563 | void operator/= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:563:34: error: template argument 1 is invalid
  563 | void operator/= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:563:38: error: non-member function 'void operator/=(const int&)' cannot have cv-qualifier
  563 | void operator/= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:563:6: error: 'void operator/=(const int&)' must have an argument of class or enumerated type
  563 | void operator/= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:564:33: error: 'T' was not declared in this scope
  564 | void operator%= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:564:34: error: template argument 1 is invalid
  564 | void operator%= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:564:38: error: non-member function 'void operator%=(const int&)' cannot have cv-qualifier
  564 | void operator%= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:564:6: error: 'void operator%=(const int&)' must have an argument of class or enumerated type
  564 | void operator%= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:565:33: error: 'T' was not declared in this scope
  565 | void operator+= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:565:34: error: template argument 1 is invalid
  565 | void operator+= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:565:38: error: non-member function 'void operator+=(const int&)' cannot have cv-qualifier
  565 | void operator+= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:565:6: error: 'void operator+=(const int&)' must have an argument of class or enumerated type
  565 | void operator+= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:566:33: error: 'T' was not declared in this scope
  566 | void operator-= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:566:34: error: template argument 1 is invalid
  566 | void operator-= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:566:38: error: non-member function 'void operator-=(const int&)' cannot have cv-qualifier
  566 | void operator-= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:566:6: error: 'void operator-=(const int&)' must have an argument of class or enumerated type
  566 | void operator-= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:567:33: error: 'T' was not declared in this scope
  567 | void operator^= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:567:34: error: template argument 1 is invalid
  567 | void operator^= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:567:38: error: non-member function 'void operator^=(const int&)' cannot have cv-qualifier
  567 | void operator^= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:567:6: error: 'void operator^=(const int&)' must have an argument of class or enumerated type
  567 | void operator^= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:568:33: error: 'T' was not declared in this scope
  568 | void operator&= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:568:34: error: template argument 1 is invalid
  568 | void operator&= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:568:38: error: non-member function 'void operator&=(const int&)' cannot have cv-qualifier
  568 | void operator&= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:568:6: error: 'void operator&=(const int&)' must have an argument of class or enumerated type
  568 | void operator&= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:569:33: error: 'T' was not declared in this scope
  569 | void operator|= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:569:34: error: template argument 1 is invalid
  569 | void operator|= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:569:38: error: non-member function 'void operator|=(const int&)' cannot have cv-qualifier
  569 | void operator|= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:569:6: error: 'void operator|=(const int&)' must have an argument of class or enumerated type
  569 | void operator|= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:570:33: error: 'T' was not declared in this scope
  570 | void operator<<=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:570:34: error: template argument 1 is invalid
  570 | void operator<<=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:570:38: error: non-member function 'void operator<<=(const int&)' cannot have cv-qualifier
  570 | void operator<<=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:570:6: error: 'void operator<<=(const int&)' must have an argument of class or enumerated type
  570 | void operator<<=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:571:33: error: 'T' was not declared in this scope
  571 | void operator>>=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:571:34: error: template argument 1 is invalid
  571 | void operator>>=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:571:38: error: non-member function 'void operator>>=(const int&)' cannot have cv-qualifier
  571 | void operator>>=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:571:6: error: 'void operator>>=(const int&)' must have an argument of class or enumerated type
  571 | void operator>>=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:573:22: error: 'T' does not name a type
  573 | void operator=(const T&) const;
      |                      ^
p1320.cpp:573:26: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  573 | void operator=(const T&) const;
      |                          ^~~~~
p1320.cpp:573:6: error: 'void operator=(const int&)' must be a non-static member function
  573 | void operator=(const T&) const;
      |      ^~~~~~~~
p1320.cpp:590:6: error: 'start' does not name a type
  590 |      start  = 3
      |      ^~~~~
p1320.cpp:592:6: error: 'stride' does not name a type
  592 |      stride = {19, 4, 1}
      |      ^~~~~~
p1320.cpp:598:8: error: expected unqualified-id before ')' token
  598 | gslice();
      |        ^
p1320.cpp:599:14: error: expected ')' before 'start'
  599 | gslice(size_t start, const valarray<size_t>& lengths,
      |       ~      ^~~~~~
      |              )
p1320.cpp:601:8: error: expected unqualified-id before 'const'
  601 | gslice(const gslice&);
      |        ^~~~~
p1320.cpp:601:8: error: expected ')' before 'const'
  601 | gslice(const gslice&);
      |       ~^~~~~
      |        )
p1320.cpp:603:27: error: non-member function 'size_t start()' cannot have cv-qualifier
  603 | size_t           start()  const;
      |                           ^~~~~
p1320.cpp:604:25: error: non-member function 'std::valarray<long unsigned int> size()' cannot have cv-qualifier
  604 | valarray<size_t> size() const;
      |                         ^~~~~
p1320.cpp:604:18: error: ambiguating new declaration of 'std::valarray<long unsigned int> size()'
  604 | valarray<size_t> size() const;
      |                  ^~~~
p1320.cpp:522:8: note: old declaration 'size_t size()'
  522 | size_t size() const;
      |        ^~~~
p1320.cpp:605:27: error: non-member function 'std::valarray<long unsigned int> stride()' cannot have cv-qualifier
  605 | valarray<size_t> stride() const;
      |                           ^~~~~
p1320.cpp:605:18: error: ambiguating new declaration of 'std::valarray<long unsigned int> stride()'
  605 | valarray<size_t> stride() const;
      |                  ^~~~~~
p1320.cpp:523:8: note: old declaration 'size_t stride()'
  523 | size_t stride() const;
      |        ^~~~~~
p1320.cpp:612:13: error: expected nested-name-specifier before 'value_type'
  612 |       using value_type = T;
      |             ^~~~~~~~~~
p1320.cpp:627:18: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++1' [-Wc++11-extensions]
  627 | gslice_array() = delete; // as implied by declaring copy constructor above
      |                  ^~~~~~
p1320.cpp:633:34: error: 'T' was not declared in this scope
  633 |    void operator=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:633:35: error: template argument 1 is invalid
  633 |    void operator=(const valarray<T>&) const;
      |                                   ^
p1320.cpp:633:39: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  633 |    void operator=(const valarray<T>&) const;
      |                                       ^~~~~
p1320.cpp:633:9: error: 'void operator=(const int&)' must be a non-static member function
  633 |    void operator=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:634:10: error: invalid use of template-name 'std::gslice_array' without an argument list
  634 |    const gslice_array& operator=(const gslice_array&) const;
      |          ^~~~~~~~~~~~
p1320.cpp:634:10: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:23:25: note: 'template<class T> class std::gslice_array' declared here
   23 | template<class T> class gslice_array;
      |                         ^~~~~~~~~~~~
p1320.cpp:637:33: error: 'T' was not declared in this scope
  637 | void operator*= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:637:34: error: template argument 1 is invalid
  637 | void operator*= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:637:38: error: non-member function 'void operator*=(const int&)' cannot have cv-qualifier
  637 | void operator*= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:637:6: error: 'void operator*=(const int&)' must have an argument of class or enumerated type
  637 | void operator*= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:638:33: error: 'T' was not declared in this scope
  638 | void operator/= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:638:34: error: template argument 1 is invalid
  638 | void operator/= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:638:38: error: non-member function 'void operator/=(const int&)' cannot have cv-qualifier
  638 | void operator/= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:638:6: error: 'void operator/=(const int&)' must have an argument of class or enumerated type
  638 | void operator/= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:639:33: error: 'T' was not declared in this scope
  639 | void operator%= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:639:34: error: template argument 1 is invalid
  639 | void operator%= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:639:38: error: non-member function 'void operator%=(const int&)' cannot have cv-qualifier
  639 | void operator%= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:639:6: error: 'void operator%=(const int&)' must have an argument of class or enumerated type
  639 | void operator%= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:640:33: error: 'T' was not declared in this scope
  640 | void operator+= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:640:34: error: template argument 1 is invalid
  640 | void operator+= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:640:38: error: non-member function 'void operator+=(const int&)' cannot have cv-qualifier
  640 | void operator+= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:640:6: error: 'void operator+=(const int&)' must have an argument of class or enumerated type
  640 | void operator+= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:641:33: error: 'T' was not declared in this scope
  641 | void operator-= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:641:34: error: template argument 1 is invalid
  641 | void operator-= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:641:38: error: non-member function 'void operator-=(const int&)' cannot have cv-qualifier
  641 | void operator-= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:641:6: error: 'void operator-=(const int&)' must have an argument of class or enumerated type
  641 | void operator-= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:642:33: error: 'T' was not declared in this scope
  642 | void operator^= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:642:34: error: template argument 1 is invalid
  642 | void operator^= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:642:38: error: non-member function 'void operator^=(const int&)' cannot have cv-qualifier
  642 | void operator^= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:642:6: error: 'void operator^=(const int&)' must have an argument of class or enumerated type
  642 | void operator^= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:643:33: error: 'T' was not declared in this scope
  643 | void operator&= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:643:34: error: template argument 1 is invalid
  643 | void operator&= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:643:38: error: non-member function 'void operator&=(const int&)' cannot have cv-qualifier
  643 | void operator&= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:643:6: error: 'void operator&=(const int&)' must have an argument of class or enumerated type
  643 | void operator&= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:644:33: error: 'T' was not declared in this scope
  644 | void operator|= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:644:34: error: template argument 1 is invalid
  644 | void operator|= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:644:38: error: non-member function 'void operator|=(const int&)' cannot have cv-qualifier
  644 | void operator|= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:644:6: error: 'void operator|=(const int&)' must have an argument of class or enumerated type
  644 | void operator|= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:645:33: error: 'T' was not declared in this scope
  645 | void operator<<=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:645:34: error: template argument 1 is invalid
  645 | void operator<<=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:645:38: error: non-member function 'void operator<<=(const int&)' cannot have cv-qualifier
  645 | void operator<<=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:645:6: error: 'void operator<<=(const int&)' must have an argument of class or enumerated type
  645 | void operator<<=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:646:33: error: 'T' was not declared in this scope
  646 | void operator>>=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:646:34: error: template argument 1 is invalid
  646 | void operator>>=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:646:38: error: non-member function 'void operator>>=(const int&)' cannot have cv-qualifier
  646 | void operator>>=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:646:6: error: 'void operator>>=(const int&)' must have an argument of class or enumerated type
  646 | void operator>>=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:648:22: error: 'T' does not name a type
  648 | void operator=(const T&) const;
      |                      ^
p1320.cpp:648:26: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  648 | void operator=(const T&) const;
      |                          ^~~~~
p1320.cpp:648:6: error: 'void operator=(const int&)' must be a non-static member function
  648 | void operator=(const T&) const;
      |      ^~~~~~~~
p1320.cpp:655:13: error: expected nested-name-specifier before 'value_type'
  655 |       using value_type = T;
      |             ^~~~~~~~~~
p1320.cpp:670:16: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++1' [-Wc++11-extensions]
  670 | mask_array() = delete; // as implied by declaring copy constructor above
      |                ^~~~~~
p1320.cpp:676:34: error: 'T' was not declared in this scope
  676 |    void operator=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:676:35: error: template argument 1 is invalid
  676 |    void operator=(const valarray<T>&) const;
      |                                   ^
p1320.cpp:676:39: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  676 |    void operator=(const valarray<T>&) const;
      |                                       ^~~~~
p1320.cpp:676:9: error: 'void operator=(const int&)' must be a non-static member function
  676 |    void operator=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:677:10: error: invalid use of template-name 'std::mask_array' without an argument list
  677 |    const mask_array& operator=(const mask_array&) const;
      |          ^~~~~~~~~~
p1320.cpp:677:10: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:24:25: note: 'template<class T> class std::mask_array' declared here
   24 | template<class T> class mask_array;
      |                         ^~~~~~~~~~
p1320.cpp:680:33: error: 'T' was not declared in this scope
  680 | void operator*= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:680:34: error: template argument 1 is invalid
  680 | void operator*= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:680:38: error: non-member function 'void operator*=(const int&)' cannot have cv-qualifier
  680 | void operator*= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:680:6: error: 'void operator*=(const int&)' must have an argument of class or enumerated type
  680 | void operator*= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:681:33: error: 'T' was not declared in this scope
  681 | void operator/= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:681:34: error: template argument 1 is invalid
  681 | void operator/= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:681:38: error: non-member function 'void operator/=(const int&)' cannot have cv-qualifier
  681 | void operator/= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:681:6: error: 'void operator/=(const int&)' must have an argument of class or enumerated type
  681 | void operator/= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:682:33: error: 'T' was not declared in this scope
  682 | void operator%= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:682:34: error: template argument 1 is invalid
  682 | void operator%= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:682:38: error: non-member function 'void operator%=(const int&)' cannot have cv-qualifier
  682 | void operator%= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:682:6: error: 'void operator%=(const int&)' must have an argument of class or enumerated type
  682 | void operator%= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:683:33: error: 'T' was not declared in this scope
  683 | void operator+= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:683:34: error: template argument 1 is invalid
  683 | void operator+= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:683:38: error: non-member function 'void operator+=(const int&)' cannot have cv-qualifier
  683 | void operator+= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:683:6: error: 'void operator+=(const int&)' must have an argument of class or enumerated type
  683 | void operator+= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:684:33: error: 'T' was not declared in this scope
  684 | void operator-= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:684:34: error: template argument 1 is invalid
  684 | void operator-= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:684:38: error: non-member function 'void operator-=(const int&)' cannot have cv-qualifier
  684 | void operator-= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:684:6: error: 'void operator-=(const int&)' must have an argument of class or enumerated type
  684 | void operator-= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:685:33: error: 'T' was not declared in this scope
  685 | void operator^= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:685:34: error: template argument 1 is invalid
  685 | void operator^= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:685:38: error: non-member function 'void operator^=(const int&)' cannot have cv-qualifier
  685 | void operator^= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:685:6: error: 'void operator^=(const int&)' must have an argument of class or enumerated type
  685 | void operator^= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:686:33: error: 'T' was not declared in this scope
  686 | void operator&= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:686:34: error: template argument 1 is invalid
  686 | void operator&= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:686:38: error: non-member function 'void operator&=(const int&)' cannot have cv-qualifier
  686 | void operator&= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:686:6: error: 'void operator&=(const int&)' must have an argument of class or enumerated type
  686 | void operator&= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:687:33: error: 'T' was not declared in this scope
  687 | void operator|= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:687:34: error: template argument 1 is invalid
  687 | void operator|= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:687:38: error: non-member function 'void operator|=(const int&)' cannot have cv-qualifier
  687 | void operator|= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:687:6: error: 'void operator|=(const int&)' must have an argument of class or enumerated type
  687 | void operator|= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:688:33: error: 'T' was not declared in this scope
  688 | void operator<<=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:688:34: error: template argument 1 is invalid
  688 | void operator<<=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:688:38: error: non-member function 'void operator<<=(const int&)' cannot have cv-qualifier
  688 | void operator<<=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:688:6: error: 'void operator<<=(const int&)' must have an argument of class or enumerated type
  688 | void operator<<=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:689:33: error: 'T' was not declared in this scope
  689 | void operator>>=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:689:34: error: template argument 1 is invalid
  689 | void operator>>=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:689:38: error: non-member function 'void operator>>=(const int&)' cannot have cv-qualifier
  689 | void operator>>=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:689:6: error: 'void operator>>=(const int&)' must have an argument of class or enumerated type
  689 | void operator>>=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:691:22: error: 'T' does not name a type
  691 | void operator=(const T&) const;
      |                      ^
p1320.cpp:691:26: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  691 | void operator=(const T&) const;
      |                          ^~~~~
p1320.cpp:691:6: error: 'void operator=(const int&)' must be a non-static member function
  691 | void operator=(const T&) const;
      |      ^~~~~~~~
p1320.cpp:698:13: error: expected nested-name-specifier before 'value_type'
  698 |       using value_type = T;
      |             ^~~~~~~~~~
p1320.cpp:713:20: warning: defaulted and deleted functions only available with '-std=c++11' or '-std=gnu++1' [-Wc++11-extensions]
  713 | indirect_array() = delete; // as implied by declaring copy constructor above
      |                    ^~~~~~
p1320.cpp:719:34: error: 'T' was not declared in this scope
  719 |    void operator=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:719:35: error: template argument 1 is invalid
  719 |    void operator=(const valarray<T>&) const;
      |                                   ^
p1320.cpp:719:39: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  719 |    void operator=(const valarray<T>&) const;
      |                                       ^~~~~
p1320.cpp:719:9: error: 'void operator=(const int&)' must be a non-static member function
  719 |    void operator=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:720:10: error: invalid use of template-name 'std::indirect_array' without an argument list
  720 |    const indirect_array& operator=(const indirect_array&) const;
      |          ^~~~~~~~~~~~~~
p1320.cpp:720:10: note: class template argument deduction is only available with '-std=c++17' or '-std=gnu++17'
p1320.cpp:25:25: note: 'template<class T> class std::indirect_array' declared here
   25 | template<class T> class indirect_array;
      |                         ^~~~~~~~~~~~~~
p1320.cpp:724:34: error: invalid conversion from 'int*' to 'long unsigned int' [-fpermissive]
  724 |        valarray<size_t> indirect(addr, 5);
      |                                  ^~~~
      |                                  |
      |                                  int*
p1320.cpp:159:37: note:   initializing argument 1 of 'std::valarray<T>::valarray(const T&, std::size_t) [with T = long unsigned int; std::size_t = long unsigned int]'
  159 | explicit valarray(size_t); valarray(const T&, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
      |                                     ^~~~~~~~
p1320.cpp:726:8: error: 'a' does not name a type
  726 |        a[indirect] = b;
      |        ^
p1320.cpp:729:33: error: 'T' was not declared in this scope
  729 | void operator*= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:729:34: error: template argument 1 is invalid
  729 | void operator*= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:729:38: error: non-member function 'void operator*=(const int&)' cannot have cv-qualifier
  729 | void operator*= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:729:6: error: 'void operator*=(const int&)' must have an argument of class or enumerated type
  729 | void operator*= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:730:33: error: 'T' was not declared in this scope
  730 | void operator/= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:730:34: error: template argument 1 is invalid
  730 | void operator/= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:730:38: error: non-member function 'void operator/=(const int&)' cannot have cv-qualifier
  730 | void operator/= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:730:6: error: 'void operator/=(const int&)' must have an argument of class or enumerated type
  730 | void operator/= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:731:33: error: 'T' was not declared in this scope
  731 | void operator%= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:731:34: error: template argument 1 is invalid
  731 | void operator%= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:731:38: error: non-member function 'void operator%=(const int&)' cannot have cv-qualifier
  731 | void operator%= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:731:6: error: 'void operator%=(const int&)' must have an argument of class or enumerated type
  731 | void operator%= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:732:33: error: 'T' was not declared in this scope
  732 | void operator+= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:732:34: error: template argument 1 is invalid
  732 | void operator+= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:732:38: error: non-member function 'void operator+=(const int&)' cannot have cv-qualifier
  732 | void operator+= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:732:6: error: 'void operator+=(const int&)' must have an argument of class or enumerated type
  732 | void operator+= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:733:33: error: 'T' was not declared in this scope
  733 | void operator-= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:733:34: error: template argument 1 is invalid
  733 | void operator-= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:733:38: error: non-member function 'void operator-=(const int&)' cannot have cv-qualifier
  733 | void operator-= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:733:6: error: 'void operator-=(const int&)' must have an argument of class or enumerated type
  733 | void operator-= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:734:33: error: 'T' was not declared in this scope
  734 | void operator^= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:734:34: error: template argument 1 is invalid
  734 | void operator^= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:734:38: error: non-member function 'void operator^=(const int&)' cannot have cv-qualifier
  734 | void operator^= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:734:6: error: 'void operator^=(const int&)' must have an argument of class or enumerated type
  734 | void operator^= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:735:33: error: 'T' was not declared in this scope
  735 | void operator&= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:735:34: error: template argument 1 is invalid
  735 | void operator&= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:735:38: error: non-member function 'void operator&=(const int&)' cannot have cv-qualifier
  735 | void operator&= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:735:6: error: 'void operator&=(const int&)' must have an argument of class or enumerated type
  735 | void operator&= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:736:33: error: 'T' was not declared in this scope
  736 | void operator|= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:736:34: error: template argument 1 is invalid
  736 | void operator|= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:736:38: error: non-member function 'void operator|=(const int&)' cannot have cv-qualifier
  736 | void operator|= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:736:6: error: 'void operator|=(const int&)' must have an argument of class or enumerated type
  736 | void operator|= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:737:33: error: 'T' was not declared in this scope
  737 | void operator<<=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:737:34: error: template argument 1 is invalid
  737 | void operator<<=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:737:38: error: non-member function 'void operator<<=(const int&)' cannot have cv-qualifier
  737 | void operator<<=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:737:6: error: 'void operator<<=(const int&)' must have an argument of class or enumerated type
  737 | void operator<<=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:738:36: error: 'T' was not declared in this scope
  738 |    void operator>>=(const valarray<T>&) const;
      |                                    ^
p1320.cpp:738:37: error: template argument 1 is invalid
  738 |    void operator>>=(const valarray<T>&) const;
      |                                     ^
p1320.cpp:738:41: error: non-member function 'void operator>>=(const int&)' cannot have cv-qualifier
  738 |    void operator>>=(const valarray<T>&) const;
      |                                         ^~~~~
p1320.cpp:738:9: error: 'void operator>>=(const int&)' must have an argument of class or enumerated type
  738 |    void operator>>=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:742:22: error: 'T' does not name a type
  742 | void operator=(const T&) const;
      |                      ^
p1320.cpp:742:26: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  742 | void operator=(const T&) const;
      |                          ^~~~~
p1320.cpp:742:6: error: 'void operator=(const int&)' must be a non-static member function
  742 | void operator=(const T&) const;
      |      ^~~~~~~~
p1320.cpp:745:19: error: 'unspecified1' does not name a type
  745 | template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v);
      |                   ^~~~~~~~~~~~
p1320.cpp:745:73: error: 'unspecified2' does not name a type
  745 | template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v);
      |                                                                         ^~~~~~~~~~~~
p1320.cpp:747:19: error: 'unspecified2' does not name a type
  747 | template<class T> unspecified2 end(const valarray<T>& v);
      |                   ^~~~~~~~~~~~

$ g++ p1320.cpp -std=2b -o p1320g -I. -Wall
p1320.cpp:144:19: error: 'unspecified1' does not name a type
  144 | template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
      |                   ^~~~~~~~~~~~
p1320.cpp:144:73: error: 'unspecified2' does not name a type
  144 | template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
      |                                                                         ^~~~~~~~~~~~
p1320.cpp:144:133: error: 'unspecified1' does not name a type
  144 | y<T>& v); template<class T> unspecified2 begin(const valarray<T>& v); template<class T> unspecified end(valarray<T>& v); template<class T> unspecified2 end(const valarray<T>& v);
      |                                                                                         ^~~~~~~~~~~

p1320.cpp:144:185: error: 'unspecified2' does not name a type
  144 |  valarray<T>& v); template<class T> unspecified1 end(valarray<T>& v); template<class T> unspecified end(const valarray<T>& v);
      |                                                                                         ^~~~~~~~~~~

p1320.cpp:169:1: error: invalid declarator before 'valarray'
  169 | valarray
      | ^~~~~~~~
p1320.cpp:175:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  175 | operator[](slice) const;
      | ^~~~~~~~
p1320.cpp:176:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  176 | operator[](slice);
      | ^~~~~~~~
p1320.cpp:177:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  177 | operator[](const gslice&) const;
      | ^~~~~~~~
p1320.cpp:178:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  178 | operator[](const gslice&);
      | ^~~~~~~~
p1320.cpp:179:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  179 | operator[](const valarray<bool>&) const;
      | ^~~~~~~~
p1320.cpp:180:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  180 | operator[](const valarray<bool>&);
      | ^~~~~~~~
p1320.cpp:181:1: error: ISO C++ forbids declaration of 'operator[]' with no type [-fpermissive]
  181 | operator[](const valarray<size_t>&) const;
      | ^~~~~~~~
p1320.cpp:211:1: error: deduction guide for 'std::valarray<_Tp>' must have trailing return type
  211 | valarray();
      | ^~~~~~~~
In file included from /usr/local/include/c++/12.1.0/string:52,
                 from /usr/local/include/c++/12.1.0/bits/locale_classes.h:40,
                 from /usr/local/include/c++/12.1.0/bits/ios_base.h:41,
                 from /usr/local/include/c++/12.1.0/ios:42,
                 from /usr/local/include/c++/12.1.0/ostream:38,
                 from /usr/local/include/c++/12.1.0/iostream:39,
                 from N4910.h:2,
                 from p1320.cpp:10:
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:214:16: error: 'T' does not name a type
  214 | valarray(const T* p, size_t n);
      |                ^
p1320.cpp:214:1: error: deduction guide for 'std::valarray<_Tp>' must have trailing return type
  214 | valarray(const T* p, size_t n);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:217:1: error: 'with' does not name a type
  217 | with the first n values pointed to by the first argument.241 valarray(const valarray& v);
      | ^~~~
p1320.cpp:219:10: error: template placeholder type 'valarray<...auto...>' must be followed by a simple declarator-id
  219 | valarray(valarray&& v) noexcept;
      |          ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:219:1: error: deduction guide for 'std::valarray<_Tp>' must have trailing return type
  219 | valarray(valarray&& v) noexcept;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:223:28: error: 'T' was not declared in this scope
  223 | valarray(const slice_array<T>&);
      |                            ^
p1320.cpp:223:29: error: template argument 1 is invalid
  223 | valarray(const slice_array<T>&);
      |                             ^
p1320.cpp:223:1: error: deduction guide for 'std::valarray<_Tp>' must have trailing return type
  223 | valarray(const slice_array<T>&);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:224:29: error: 'T' was not declared in this scope
  224 | valarray(const gslice_array<T>&);
      |                             ^
p1320.cpp:224:30: error: template argument 1 is invalid
  224 | valarray(const gslice_array<T>&);
      |                              ^
p1320.cpp:224:1: error: deduction guide for 'std::valarray<_Tp>' must have trailing return type
  224 | valarray(const gslice_array<T>&);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:225:27: error: 'T' was not declared in this scope
  225 | valarray(const mask_array<T>&);
      |                           ^
p1320.cpp:225:28: error: template argument 1 is invalid
  225 | valarray(const mask_array<T>&);
      |                            ^
p1320.cpp:225:1: error: deduction guide for 'std::valarray<_Tp>' must have trailing return type
  225 | valarray(const mask_array<T>&);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:226:31: error: 'T' was not declared in this scope
  226 | valarray(const indirect_array<T>&);
      |                               ^
p1320.cpp:226:32: error: template argument 1 is invalid
  226 | valarray(const indirect_array<T>&);
      |                                ^
p1320.cpp:226:1: error: deduction guide for 'std::valarray<_Tp>' must have trailing return type
  226 | valarray(const indirect_array<T>&);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:234:21: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  234 | valarray& operator=(const valarray& v);
      |                     ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:234:1: error: deduced class type 'valarray' in function return type
  234 | valarray& operator=(const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:238:21: error: template placeholder type 'valarray<...auto...>' must be followed by a simple declarator-id
  238 | valarray& operator=(valarray&& v) noexcept;
      |                     ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:238:1: error: deduced class type 'valarray' in function return type
  238 | valarray& operator=(valarray&& v) noexcept;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:241:38: error: 'T' was not declared in this scope
  241 | valarray& operator=(initializer_list<T> il);
      |                                      ^
p1320.cpp:241:39: error: template argument 1 is invalid
  241 | valarray& operator=(initializer_list<T> il);
      |                                       ^
p1320.cpp:241:1: error: deduced class type 'valarray' in function return type
  241 | valarray& operator=(initializer_list<T> il);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:242:8: error: found ':' in nested-name-specifier, expected '::'
  242 | Effects: Equivalent to: return *this = valarray(il);
      |        ^
      |        ::
p1320.cpp:242:1: error: 'Effects' does not name a type
  242 | Effects: Equivalent to: return *this = valarray(il);
      | ^~~~~~~
p1320.cpp:243:27: error: 'T' does not name a type
  243 | valarray& operator=(const T& v);
      |                           ^
p1320.cpp:243:1: error: deduced class type 'valarray' in function return type
  243 | valarray& operator=(const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:244:8: error: found ':' in nested-name-specifier, expected '::'
  244 | Effects: Assigns v to each element of *this. Returns: *this.
      |        ^
      |        ::
p1320.cpp:244:1: error: 'Effects' does not name a type
  244 | Effects: Assigns v to each element of *this. Returns: *this.
      | ^~~~~~~
p1320.cpp:246:40: error: 'T' was not declared in this scope
  246 | valarray& operator=(const gslice_array<T>&);
      |                                        ^
p1320.cpp:246:41: error: template argument 1 is invalid
  246 | valarray& operator=(const gslice_array<T>&);
      |                                         ^
p1320.cpp:246:1: error: deduced class type 'valarray' in function return type
  246 | valarray& operator=(const gslice_array<T>&);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:247:38: error: 'T' was not declared in this scope
  247 | valarray& operator=(const mask_array<T>&);
      |                                      ^
p1320.cpp:247:39: error: template argument 1 is invalid
  247 | valarray& operator=(const mask_array<T>&);
      |                                       ^
p1320.cpp:247:1: error: deduced class type 'valarray' in function return type
  247 | valarray& operator=(const mask_array<T>&);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:248:42: error: 'T' was not declared in this scope
  248 | valarray& operator=(const indirect_array<T>&);
      |                                          ^
p1320.cpp:248:43: error: template argument 1 is invalid
  248 | valarray& operator=(const indirect_array<T>&);
      |                                           ^
p1320.cpp:248:1: error: deduced class type 'valarray' in function return type
  248 | valarray& operator=(const indirect_array<T>&);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:252:7: error: 'T' does not name a type
  252 | const T&  operator[](size_t n) const;
      |       ^
p1320.cpp:253:1: error: 'T' does not name a type
  253 | T& operator[](size_t n);
      | ^
p1320.cpp:263:1: error: deduced class type 'valarray' in function return type
  263 | valarray operator[](slice slicearr) const;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:268:18: error: conflicting declaration 'std::valarray<char> v0'
  268 |   valarray<char> v0("abcdefghijklmnop", 16);
      |                  ^~
p1320.cpp:265:22: note: previous declaration as 'const std::valarray<char> v0'
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:272:48: error: 'v0' does not name a type
  272 | const valarray<size_t> len(lv, 2), str(dv, 2); v0[gslice(3, len, str)] = v1;
      |                                                ^~
p1320.cpp:275:22: error: redefinition of 'const std::valarray<char> v0'
  275 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:265:22: note: 'const std::valarray<char> v0' previously declared here
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:278:13: error: 'T' was not declared in this scope
  278 | slice_array<T> operator[](slice slicearr);
      |             ^
p1320.cpp:278:14: error: template argument 1 is invalid
  278 | slice_array<T> operator[](slice slicearr);
      |              ^
p1320.cpp:278:16: error: 'int operator[](std::slice)' must be a non-static member function
  278 | slice_array<T> operator[](slice slicearr);
      |                ^~~~~~~~
p1320.cpp:280:16: error: conflicting declaration 'std::valarray<char> v0'
  280 | valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5);
      |                ^~
p1320.cpp:265:22: note: previous declaration as 'const std::valarray<char> v0'
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:280:59: error: redefinition of 'std::valarray<char> v1'
  280 | valarray<char> v0("abcdefghijklmnop", 16); valarray<char> v1("ABCDE", 5);
      |                                                           ^~
p1320.cpp:269:18: note: 'std::valarray<char> v1' previously declared here
  269 |   valarray<char> v1("ABCDEF", 6);
      |                  ^~
p1320.cpp:281:1: error: 'v0' does not name a type
  281 | v0[slice(2, 5, 3)] = v1;
      | ^~
p1320.cpp:283:1: error: deduced class type 'valarray' in function return type
  283 | valarray operator[](const gslice& gslicearr) const;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:285:22: error: redefinition of 'const std::valarray<char> v0'
  285 | const valarray<char> v0("abcdefghijklmnop", 16); const size_t lv[] = { 2, 3 };
      |                      ^~
p1320.cpp:265:22: note: 'const std::valarray<char> v0' previously declared here
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:285:63: error: redefinition of 'const size_t lv []'
  285 | const valarray<char> v0("abcdefghijklmnop", 16); const size_t lv[] = { 2, 3 };
      |                                                               ^~
p1320.cpp:270:16: note: 'const size_t lv [2]' previously defined here
  270 |   const size_t lv[] = { 2, 3 };
      |                ^~
p1320.cpp:286:14: error: redefinition of 'const size_t dv []'
  286 | const size_t dv[] = { 7, 2 };
      |              ^~
p1320.cpp:271:16: note: 'const size_t dv [2]' previously defined here
  271 |   const size_t dv[] = { 7, 2 };
      |                ^~
p1320.cpp:287:24: error: redefinition of 'const std::valarray<long unsigned int> len'
  287 | const valarray<size_t> len(lv, 2), str(dv, 2); // v0[gslice(3, len, str)] returns
      |                        ^~~
p1320.cpp:272:24: note: 'const std::valarray<long unsigned int> len' previously declared here
  272 | const valarray<size_t> len(lv, 2), str(dv, 2); v0[gslice(3, len, str)] = v1;
      |                        ^~~
p1320.cpp:287:36: error: redefinition of 'const std::valarray<long unsigned int> str'
  287 | const valarray<size_t> len(lv, 2), str(dv, 2); // v0[gslice(3, len, str)] returns
      |                                    ^~~
p1320.cpp:272:36: note: 'const std::valarray<long unsigned int> str' previously declared here
  272 | const valarray<size_t> len(lv, 2), str(dv, 2); v0[gslice(3, len, str)] = v1;
      |                                    ^~~
p1320.cpp:289:14: error: 'T' was not declared in this scope
  289 | gslice_array<T> operator[](const gslice& gslicearr);
      |              ^
p1320.cpp:289:15: error: template argument 1 is invalid
  289 | gslice_array<T> operator[](const gslice& gslicearr);
      |               ^
p1320.cpp:289:17: error: 'int operator[](const std::gslice&)' must be a non-static member function
  289 | gslice_array<T> operator[](const gslice& gslicearr);
      |                 ^~~~~~~~
p1320.cpp:290:1: error: deduced class type 'valarray' in function return type
  290 | valarray operator[](const valarray<bool>& boolarr) const;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:291:12: error: 'T' was not declared in this scope
  291 | mask_array<T> operator[](const valarray<bool>& boolarr);
      |            ^
p1320.cpp:291:13: error: template argument 1 is invalid
  291 | mask_array<T> operator[](const valarray<bool>& boolarr);
      |             ^
p1320.cpp:291:15: error: 'int operator[](const std::valarray<bool>&)' must be a non-static member function
  291 | mask_array<T> operator[](const valarray<bool>& boolarr);
      |               ^~~~~~~~
p1320.cpp:293:18: error: conflicting declaration 'std::valarray<char> v0'
  293 |   valarray<char> v0("abcdefghijklmnop", 16);
      |                  ^~
p1320.cpp:265:22: note: previous declaration as 'const std::valarray<char> v0'
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:295:22: error: redefinition of 'const std::valarray<char> v0'
  295 | const valarray<char> v0("abcdefghijklmnop", 16); const size_t vi[] = { 7, 5, 2, 3, 8 };
      |                      ^~
p1320.cpp:265:22: note: 'const std::valarray<char> v0' previously declared here
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:305:16: error: redefinition of 'std::valarray<char> v1'
  305 | valarray<char> v1("ABC", 3);
      |                ^~
p1320.cpp:269:18: note: 'std::valarray<char> v1' previously declared here
  269 |   valarray<char> v1("ABCDEF", 6);
      |                  ^~
p1320.cpp:306:12: error: redefinition of 'const bool vb []'
  306 | const bool vb[] = { false, false, true, true, false, true }; v0[valarray<bool>(vb, 6)] = v1;
      |            ^~
p1320.cpp:276:12: note: 'const bool vb [6]' previously defined here
  276 | const bool vb[] = { false, false, true, true, false, true }; // v0[valarray<bool>(vb, 6)] returns
      |            ^~
p1320.cpp:306:62: error: 'v0' does not name a type
  306 | const bool vb[] = { false, false, true, true, false, true }; v0[valarray<bool>(vb, 6)] = v1;
      |                                                              ^~
p1320.cpp:308:1: error: deduced class type 'valarray' in function return type
  308 | valarray operator[](const valarray<size_t>& indarr) const;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:309:16: error: 'T' was not declared in this scope
  309 | indirect_array<T> operator[](const valarray<size_t>& indarr);
      |                ^
p1320.cpp:309:17: error: template argument 1 is invalid
  309 | indirect_array<T> operator[](const valarray<size_t>& indarr);
      |                 ^
p1320.cpp:309:19: error: 'int operator[](const std::valarray<long unsigned int>&)' must be a non-static member function
  309 | indirect_array<T> operator[](const valarray<size_t>& indarr);
      |                   ^~~~~~~~
p1320.cpp:311:18: error: conflicting declaration 'std::valarray<char> v0'
  311 |   valarray<char> v0("abcdefghijklmnop", 16);
      |                  ^~
p1320.cpp:265:22: note: previous declaration as 'const std::valarray<char> v0'
  265 | const valarray<char> v0("abcdefghijklmnop", 16);
      |                      ^~
p1320.cpp:312:18: error: redefinition of 'std::valarray<char> v1'
  312 |   valarray<char> v1("ABCDE", 5);
      |                  ^~
p1320.cpp:269:18: note: 'std::valarray<char> v1' previously declared here
  269 |   valarray<char> v1("ABCDEF", 6);
      |                  ^~
p1320.cpp:313:16: error: redefinition of 'const size_t vi []'
  313 |   const size_t vi[] = { 7, 5, 2, 3, 8 };
      |                ^~
p1320.cpp:295:63: note: 'const size_t vi [5]' previously defined here
  295 | const valarray<char> v0("abcdefghijklmnop", 16); const size_t vi[] = { 7, 5, 2, 3, 8 };
      |                                                               ^~
p1320.cpp:314:3: error: 'v0' does not name a type
  314 |   v0[valarray<size_t>(vi, 5)] = v1;
      |   ^~
p1320.cpp:317:1: error: deduced class type 'valarray' in function return type
  317 | valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:317:29: error: deduced class type 'valarray' in function return type
  317 | valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      |                             ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:317:57: error: deduced class type 'valarray' in function return type
  317 | valarray operator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      |                                                         ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:317:112: error: non-member function 'std::valarray<bool> operator!()' cannot have cv-qualifier
  317 | () const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      |                                                                                              ^~~~~

p1320.cpp:317:100: error: 'std::valarray<bool> operator!()' must have an argument of class or enumerated type
  317 | erator+() const; valarray operator-() const; valarray operator~() const; valarray<bool> operator!() const;
      |                                                                                         ^~~~~~~~

p1320.cpp:319:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  319 | valarray& operator*= (const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:319:1: error: deduced class type 'valarray' in function return type
  319 | valarray& operator*= (const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:320:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  320 | valarray& operator/= (const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:320:1: error: deduced class type 'valarray' in function return type
  320 | valarray& operator/= (const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:321:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  321 | valarray& operator%= (const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:321:1: error: deduced class type 'valarray' in function return type
  321 | valarray& operator%= (const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:322:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  322 | valarray& operator+= (const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:322:1: error: deduced class type 'valarray' in function return type
  322 | valarray& operator+= (const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:323:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  323 | valarray& operator-= (const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:323:1: error: deduced class type 'valarray' in function return type
  323 | valarray& operator-= (const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:324:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  324 | valarray& operator^= (const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:324:1: error: deduced class type 'valarray' in function return type
  324 | valarray& operator^= (const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:325:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  325 | valarray& operator&= (const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:325:1: error: deduced class type 'valarray' in function return type
  325 | valarray& operator&= (const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:326:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  326 | valarray& operator|= (const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:326:1: error: deduced class type 'valarray' in function return type
  326 | valarray& operator|= (const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:327:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  327 | valarray& operator<<=(const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:327:1: error: deduced class type 'valarray' in function return type
  327 | valarray& operator<<=(const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:328:23: error: template placeholder type 'const valarray<...auto...>' must be followed by a simple declarator-id
  328 | valarray& operator>>=(const valarray& v);
      |                       ^~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:328:1: error: deduced class type 'valarray' in function return type
  328 | valarray& operator>>=(const valarray& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:334:29: error: 'T' does not name a type
  334 | valarray& operator*= (const T& v);
      |                             ^
p1320.cpp:334:1: error: deduced class type 'valarray' in function return type
  334 | valarray& operator*= (const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:335:29: error: 'T' does not name a type
  335 | valarray& operator/= (const T& v);
      |                             ^
p1320.cpp:335:1: error: deduced class type 'valarray' in function return type
  335 | valarray& operator/= (const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:336:29: error: 'T' does not name a type
  336 | valarray& operator%= (const T& v);
      |                             ^
p1320.cpp:336:1: error: deduced class type 'valarray' in function return type
  336 | valarray& operator%= (const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:337:29: error: 'T' does not name a type
  337 | valarray& operator+= (const T& v);
      |                             ^
p1320.cpp:337:1: error: deduced class type 'valarray' in function return type
  337 | valarray& operator+= (const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:338:29: error: 'T' does not name a type
  338 | valarray& operator-= (const T& v);
      |                             ^
p1320.cpp:338:1: error: deduced class type 'valarray' in function return type
  338 | valarray& operator-= (const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:339:29: error: 'T' does not name a type
  339 | valarray& operator^= (const T& v);
      |                             ^
p1320.cpp:339:1: error: deduced class type 'valarray' in function return type
  339 | valarray& operator^= (const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:340:29: error: 'T' does not name a type
  340 | valarray& operator&= (const T& v);
      |                             ^
p1320.cpp:340:1: error: deduced class type 'valarray' in function return type
  340 | valarray& operator&= (const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:341:29: error: 'T' does not name a type
  341 | valarray& operator|= (const T& v);
      |                             ^
p1320.cpp:341:1: error: deduced class type 'valarray' in function return type
  341 | valarray& operator|= (const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:342:29: error: 'T' does not name a type
  342 | valarray& operator<<=(const T& v);
      |                             ^
p1320.cpp:342:1: error: deduced class type 'valarray' in function return type
  342 | valarray& operator<<=(const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:343:29: error: 'T' does not name a type
  343 | valarray& operator>>=(const T& v);
      |                             ^
p1320.cpp:343:1: error: deduced class type 'valarray' in function return type
  343 | valarray& operator>>=(const T& v);
      | ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:345:11: error: template placeholder type 'valarray<...auto...>' must be followed by a simple declarator-id
  345 | void swap(valarray& v) noexcept;
      |           ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:348:15: error: non-member function 'size_t size()' cannot have cv-qualifier
  348 | size_t size() const;
      |               ^~~~~
p1320.cpp:350:1: error: 'T' does not name a type
  350 | T sum() const;
      | ^
p1320.cpp:354:1: error: 'T' does not name a type
  354 | T min() const;
      | ^
p1320.cpp:357:1: error: 'T' does not name a type
  357 | T max() const;
      | ^
p1320.cpp:360:1: error: 'returned' does not name a type
  360 | returned. For all other array lengths, the determination is made using operator<. valarray shift(int n) const;
      | ^~~~~~~~
p1320.cpp:367:4: error: deduced class type 'valarray' in function return type
  367 |    valarray cshift(int n) const;
      |    ^~~~~~~~
/usr/local/include/c++/12.1.0/bits/range_access.h:111:32: note: 'template<class _Tp> class std::valarray' declared here
  111 |   template<typename _Tp> class valarray;
      |                                ^~~~~~~~
p1320.cpp:369:16: error: 'T' was not declared in this scope
  369 | valarray apply(T func(T)) const;
      |                ^
p1320.cpp:369:27: error: expected ',' or ';' before 'const'
  369 | valarray apply(T func(T)) const;
      |                           ^~~~~
p1320.cpp:370:16: error: 'T' was not declared in this scope
  370 | valarray apply(T func(const T&)) const;
      |                ^
p1320.cpp:372:24: error: 'T' has not been declared
  372 | void resize(size_t sz, T c = T());
      |                        ^
p1320.cpp:372:30: error: 'T' was not declared in this scope
  372 | void resize(size_t sz, T c = T());
      |                              ^
p1320.cpp:498:1: error: expected declaration before '}' token
  498 | }
      | ^
p1320.cpp:517:8: error: expected constructor, destructor, or type conversion before ';' token
  517 | slice();
      |        ^
p1320.cpp:518:50: error: expected constructor, destructor, or type conversion before ';' token
  518 | slice(size_t start, size_t length, size_t stride);
      |                                                  ^
p1320.cpp:519:20: error: expected constructor, destructor, or type conversion before ';' token
  519 | slice(const slice&);
      |                    ^
p1320.cpp:521:16: error: non-member function 'size_t start()' cannot have cv-qualifier
  521 | size_t start() const;
      |                ^~~~~
p1320.cpp:522:15: error: non-member function 'size_t size()' cannot have cv-qualifier
  522 | size_t size() const;
      |               ^~~~~
p1320.cpp:523:17: error: non-member function 'size_t stride()' cannot have cv-qualifier
  523 | size_t stride() const;
      |                 ^~~~~
p1320.cpp:526:1: error: 'friend' used outside of class
  526 | friend bool operator==(const slice& x, const slice& y);
      | ^~~~~~
      | ------
p1320.cpp:528:1: error: expected unqualified-id before 'return'
  528 | return x.start() == y.start() && x.size() == y.size() && x.stride() == y.stride();
      | ^~~~~~
p1320.cpp:559:34: error: 'T' was not declared in this scope
  559 |    void operator=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:559:35: error: template argument 1 is invalid
  559 |    void operator=(const valarray<T>&) const;
      |                                   ^
p1320.cpp:559:39: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  559 |    void operator=(const valarray<T>&) const;
      |                                       ^~~~~
p1320.cpp:559:9: error: 'void operator=(const int&)' must be a non-static member function
  559 |    void operator=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:560:33: error: class template placeholder 'std::slice_array' not permitted in this context
  560 |    const slice_array& operator=(const slice_array&) const;
      |                                 ^~~~~
p1320.cpp:560:33: note: use 'auto' for an abbreviated function template
p1320.cpp:560:4: error: deduced class type 'slice_array' in function return type
  560 |    const slice_array& operator=(const slice_array&) const;
      |    ^~~~~
p1320.cpp:19:29: note: 'template<class T> class std::slice_array' declared here
   19 |     template<class T> class slice_array;
      |                             ^~~~~~~~~~~
p1320.cpp:562:33: error: 'T' was not declared in this scope
  562 | void operator*= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:562:34: error: template argument 1 is invalid
  562 | void operator*= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:562:38: error: non-member function 'void operator*=(const int&)' cannot have cv-qualifier
  562 | void operator*= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:562:6: error: 'void operator*=(const int&)' must have an argument of class or enumerated type
  562 | void operator*= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:563:33: error: 'T' was not declared in this scope
  563 | void operator/= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:563:34: error: template argument 1 is invalid
  563 | void operator/= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:563:38: error: non-member function 'void operator/=(const int&)' cannot have cv-qualifier
  563 | void operator/= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:563:6: error: 'void operator/=(const int&)' must have an argument of class or enumerated type
  563 | void operator/= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:564:33: error: 'T' was not declared in this scope
  564 | void operator%= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:564:34: error: template argument 1 is invalid
  564 | void operator%= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:564:38: error: non-member function 'void operator%=(const int&)' cannot have cv-qualifier
  564 | void operator%= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:564:6: error: 'void operator%=(const int&)' must have an argument of class or enumerated type
  564 | void operator%= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:565:33: error: 'T' was not declared in this scope
  565 | void operator+= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:565:34: error: template argument 1 is invalid
  565 | void operator+= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:565:38: error: non-member function 'void operator+=(const int&)' cannot have cv-qualifier
  565 | void operator+= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:565:6: error: 'void operator+=(const int&)' must have an argument of class or enumerated type
  565 | void operator+= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:566:33: error: 'T' was not declared in this scope
  566 | void operator-= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:566:34: error: template argument 1 is invalid
  566 | void operator-= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:566:38: error: non-member function 'void operator-=(const int&)' cannot have cv-qualifier
  566 | void operator-= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:566:6: error: 'void operator-=(const int&)' must have an argument of class or enumerated type
  566 | void operator-= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:567:33: error: 'T' was not declared in this scope
  567 | void operator^= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:567:34: error: template argument 1 is invalid
  567 | void operator^= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:567:38: error: non-member function 'void operator^=(const int&)' cannot have cv-qualifier
  567 | void operator^= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:567:6: error: 'void operator^=(const int&)' must have an argument of class or enumerated type
  567 | void operator^= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:568:33: error: 'T' was not declared in this scope
  568 | void operator&= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:568:34: error: template argument 1 is invalid
  568 | void operator&= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:568:38: error: non-member function 'void operator&=(const int&)' cannot have cv-qualifier
  568 | void operator&= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:568:6: error: 'void operator&=(const int&)' must have an argument of class or enumerated type
  568 | void operator&= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:569:33: error: 'T' was not declared in this scope
  569 | void operator|= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:569:34: error: template argument 1 is invalid
  569 | void operator|= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:569:38: error: non-member function 'void operator|=(const int&)' cannot have cv-qualifier
  569 | void operator|= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:569:6: error: 'void operator|=(const int&)' must have an argument of class or enumerated type
  569 | void operator|= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:570:33: error: 'T' was not declared in this scope
  570 | void operator<<=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:570:34: error: template argument 1 is invalid
  570 | void operator<<=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:570:38: error: non-member function 'void operator<<=(const int&)' cannot have cv-qualifier
  570 | void operator<<=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:570:6: error: 'void operator<<=(const int&)' must have an argument of class or enumerated type
  570 | void operator<<=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:571:33: error: 'T' was not declared in this scope
  571 | void operator>>=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:571:34: error: template argument 1 is invalid
  571 | void operator>>=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:571:38: error: non-member function 'void operator>>=(const int&)' cannot have cv-qualifier
  571 | void operator>>=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:571:6: error: 'void operator>>=(const int&)' must have an argument of class or enumerated type
  571 | void operator>>=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:573:22: error: 'T' does not name a type
  573 | void operator=(const T&) const;
      |                      ^
p1320.cpp:573:26: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  573 | void operator=(const T&) const;
      |                          ^~~~~
p1320.cpp:573:6: error: 'void operator=(const int&)' must be a non-static member function
  573 | void operator=(const T&) const;
      |      ^~~~~~~~
p1320.cpp:590:6: error: 'start' does not name a type
  590 |      start  = 3
      |      ^~~~~
p1320.cpp:592:6: error: 'stride' does not name a type
  592 |      stride = {19, 4, 1}
      |      ^~~~~~
p1320.cpp:598:9: error: expected constructor, destructor, or type conversion before ';' token
  598 | gslice();
      |         ^
p1320.cpp:600:40: error: expected constructor, destructor, or type conversion before ';' token
  600 |        const valarray<size_t>& strides);
      |                                        ^
p1320.cpp:601:22: error: expected constructor, destructor, or type conversion before ';' token
  601 | gslice(const gslice&);
      |                      ^
p1320.cpp:603:27: error: non-member function 'size_t start()' cannot have cv-qualifier
  603 | size_t           start()  const;
      |                           ^~~~~
p1320.cpp:604:25: error: non-member function 'std::valarray<long unsigned int> size()' cannot have cv-qualifier
  604 | valarray<size_t> size() const;
      |                         ^~~~~
p1320.cpp:604:18: error: ambiguating new declaration of 'std::valarray<long unsigned int> size()'
  604 | valarray<size_t> size() const;
      |                  ^~~~
p1320.cpp:522:8: note: old declaration 'size_t size()'
  522 | size_t size() const;
      |        ^~~~
p1320.cpp:605:27: error: non-member function 'std::valarray<long unsigned int> stride()' cannot have cv-qualifier
  605 | valarray<size_t> stride() const;
      |                           ^~~~~
p1320.cpp:605:18: error: ambiguating new declaration of 'std::valarray<long unsigned int> stride()'
  605 | valarray<size_t> stride() const;
      |                  ^~~~~~
p1320.cpp:523:8: note: old declaration 'size_t stride()'
  523 | size_t stride() const;
      |        ^~~~~~
p1320.cpp:633:34: error: 'T' was not declared in this scope
  633 |    void operator=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:633:35: error: template argument 1 is invalid
  633 |    void operator=(const valarray<T>&) const;
      |                                   ^
p1320.cpp:633:39: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  633 |    void operator=(const valarray<T>&) const;
      |                                       ^~~~~
p1320.cpp:633:9: error: 'void operator=(const int&)' must be a non-static member function
  633 |    void operator=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:634:34: error: class template placeholder 'std::gslice_array' not permitted in this context
  634 |    const gslice_array& operator=(const gslice_array&) const;
      |                                  ^~~~~
p1320.cpp:634:34: note: use 'auto' for an abbreviated function template
p1320.cpp:634:4: error: deduced class type 'gslice_array' in function return type
  634 |    const gslice_array& operator=(const gslice_array&) const;
      |    ^~~~~
p1320.cpp:23:25: note: 'template<class T> class std::gslice_array' declared here
   23 | template<class T> class gslice_array;
      |                         ^~~~~~~~~~~~
p1320.cpp:637:33: error: 'T' was not declared in this scope
  637 | void operator*= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:637:34: error: template argument 1 is invalid
  637 | void operator*= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:637:38: error: non-member function 'void operator*=(const int&)' cannot have cv-qualifier
  637 | void operator*= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:637:6: error: 'void operator*=(const int&)' must have an argument of class or enumerated type
  637 | void operator*= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:638:33: error: 'T' was not declared in this scope
  638 | void operator/= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:638:34: error: template argument 1 is invalid
  638 | void operator/= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:638:38: error: non-member function 'void operator/=(const int&)' cannot have cv-qualifier
  638 | void operator/= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:638:6: error: 'void operator/=(const int&)' must have an argument of class or enumerated type
  638 | void operator/= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:639:33: error: 'T' was not declared in this scope
  639 | void operator%= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:639:34: error: template argument 1 is invalid
  639 | void operator%= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:639:38: error: non-member function 'void operator%=(const int&)' cannot have cv-qualifier
  639 | void operator%= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:639:6: error: 'void operator%=(const int&)' must have an argument of class or enumerated type
  639 | void operator%= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:640:33: error: 'T' was not declared in this scope
  640 | void operator+= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:640:34: error: template argument 1 is invalid
  640 | void operator+= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:640:38: error: non-member function 'void operator+=(const int&)' cannot have cv-qualifier
  640 | void operator+= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:640:6: error: 'void operator+=(const int&)' must have an argument of class or enumerated type
  640 | void operator+= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:641:33: error: 'T' was not declared in this scope
  641 | void operator-= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:641:34: error: template argument 1 is invalid
  641 | void operator-= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:641:38: error: non-member function 'void operator-=(const int&)' cannot have cv-qualifier
  641 | void operator-= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:641:6: error: 'void operator-=(const int&)' must have an argument of class or enumerated type
  641 | void operator-= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:642:33: error: 'T' was not declared in this scope
  642 | void operator^= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:642:34: error: template argument 1 is invalid
  642 | void operator^= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:642:38: error: non-member function 'void operator^=(const int&)' cannot have cv-qualifier
  642 | void operator^= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:642:6: error: 'void operator^=(const int&)' must have an argument of class or enumerated type
  642 | void operator^= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:643:33: error: 'T' was not declared in this scope
  643 | void operator&= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:643:34: error: template argument 1 is invalid
  643 | void operator&= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:643:38: error: non-member function 'void operator&=(const int&)' cannot have cv-qualifier
  643 | void operator&= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:643:6: error: 'void operator&=(const int&)' must have an argument of class or enumerated type
  643 | void operator&= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:644:33: error: 'T' was not declared in this scope
  644 | void operator|= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:644:34: error: template argument 1 is invalid
  644 | void operator|= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:644:38: error: non-member function 'void operator|=(const int&)' cannot have cv-qualifier
  644 | void operator|= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:644:6: error: 'void operator|=(const int&)' must have an argument of class or enumerated type
  644 | void operator|= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:645:33: error: 'T' was not declared in this scope
  645 | void operator<<=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:645:34: error: template argument 1 is invalid
  645 | void operator<<=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:645:38: error: non-member function 'void operator<<=(const int&)' cannot have cv-qualifier
  645 | void operator<<=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:645:6: error: 'void operator<<=(const int&)' must have an argument of class or enumerated type
  645 | void operator<<=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:646:33: error: 'T' was not declared in this scope
  646 | void operator>>=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:646:34: error: template argument 1 is invalid
  646 | void operator>>=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:646:38: error: non-member function 'void operator>>=(const int&)' cannot have cv-qualifier
  646 | void operator>>=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:646:6: error: 'void operator>>=(const int&)' must have an argument of class or enumerated type
  646 | void operator>>=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:648:22: error: 'T' does not name a type
  648 | void operator=(const T&) const;
      |                      ^
p1320.cpp:648:26: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  648 | void operator=(const T&) const;
      |                          ^~~~~
p1320.cpp:648:6: error: 'void operator=(const int&)' must be a non-static member function
  648 | void operator=(const T&) const;
      |      ^~~~~~~~
p1320.cpp:676:34: error: 'T' was not declared in this scope
  676 |    void operator=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:676:35: error: template argument 1 is invalid
  676 |    void operator=(const valarray<T>&) const;
      |                                   ^
p1320.cpp:676:39: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  676 |    void operator=(const valarray<T>&) const;
      |                                       ^~~~~
p1320.cpp:676:9: error: 'void operator=(const int&)' must be a non-static member function
  676 |    void operator=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:677:32: error: class template placeholder 'std::mask_array' not permitted in this context
  677 |    const mask_array& operator=(const mask_array&) const;
      |                                ^~~~~
p1320.cpp:677:32: note: use 'auto' for an abbreviated function template
p1320.cpp:677:4: error: deduced class type 'mask_array' in function return type
  677 |    const mask_array& operator=(const mask_array&) const;
      |    ^~~~~
p1320.cpp:24:25: note: 'template<class T> class std::mask_array' declared here
   24 | template<class T> class mask_array;
      |                         ^~~~~~~~~~
p1320.cpp:680:33: error: 'T' was not declared in this scope
  680 | void operator*= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:680:34: error: template argument 1 is invalid
  680 | void operator*= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:680:38: error: non-member function 'void operator*=(const int&)' cannot have cv-qualifier
  680 | void operator*= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:680:6: error: 'void operator*=(const int&)' must have an argument of class or enumerated type
  680 | void operator*= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:681:33: error: 'T' was not declared in this scope
  681 | void operator/= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:681:34: error: template argument 1 is invalid
  681 | void operator/= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:681:38: error: non-member function 'void operator/=(const int&)' cannot have cv-qualifier
  681 | void operator/= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:681:6: error: 'void operator/=(const int&)' must have an argument of class or enumerated type
  681 | void operator/= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:682:33: error: 'T' was not declared in this scope
  682 | void operator%= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:682:34: error: template argument 1 is invalid
  682 | void operator%= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:682:38: error: non-member function 'void operator%=(const int&)' cannot have cv-qualifier
  682 | void operator%= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:682:6: error: 'void operator%=(const int&)' must have an argument of class or enumerated type
  682 | void operator%= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:683:33: error: 'T' was not declared in this scope
  683 | void operator+= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:683:34: error: template argument 1 is invalid
  683 | void operator+= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:683:38: error: non-member function 'void operator+=(const int&)' cannot have cv-qualifier
  683 | void operator+= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:683:6: error: 'void operator+=(const int&)' must have an argument of class or enumerated type
  683 | void operator+= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:684:33: error: 'T' was not declared in this scope
  684 | void operator-= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:684:34: error: template argument 1 is invalid
  684 | void operator-= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:684:38: error: non-member function 'void operator-=(const int&)' cannot have cv-qualifier
  684 | void operator-= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:684:6: error: 'void operator-=(const int&)' must have an argument of class or enumerated type
  684 | void operator-= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:685:33: error: 'T' was not declared in this scope
  685 | void operator^= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:685:34: error: template argument 1 is invalid
  685 | void operator^= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:685:38: error: non-member function 'void operator^=(const int&)' cannot have cv-qualifier
  685 | void operator^= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:685:6: error: 'void operator^=(const int&)' must have an argument of class or enumerated type
  685 | void operator^= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:686:33: error: 'T' was not declared in this scope
  686 | void operator&= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:686:34: error: template argument 1 is invalid
  686 | void operator&= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:686:38: error: non-member function 'void operator&=(const int&)' cannot have cv-qualifier
  686 | void operator&= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:686:6: error: 'void operator&=(const int&)' must have an argument of class or enumerated type
  686 | void operator&= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:687:33: error: 'T' was not declared in this scope
  687 | void operator|= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:687:34: error: template argument 1 is invalid
  687 | void operator|= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:687:38: error: non-member function 'void operator|=(const int&)' cannot have cv-qualifier
  687 | void operator|= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:687:6: error: 'void operator|=(const int&)' must have an argument of class or enumerated type
  687 | void operator|= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:688:33: error: 'T' was not declared in this scope
  688 | void operator<<=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:688:34: error: template argument 1 is invalid
  688 | void operator<<=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:688:38: error: non-member function 'void operator<<=(const int&)' cannot have cv-qualifier
  688 | void operator<<=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:688:6: error: 'void operator<<=(const int&)' must have an argument of class or enumerated type
  688 | void operator<<=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:689:33: error: 'T' was not declared in this scope
  689 | void operator>>=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:689:34: error: template argument 1 is invalid
  689 | void operator>>=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:689:38: error: non-member function 'void operator>>=(const int&)' cannot have cv-qualifier
  689 | void operator>>=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:689:6: error: 'void operator>>=(const int&)' must have an argument of class or enumerated type
  689 | void operator>>=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:691:22: error: 'T' does not name a type
  691 | void operator=(const T&) const;
      |                      ^
p1320.cpp:691:26: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  691 | void operator=(const T&) const;
      |                          ^~~~~
p1320.cpp:691:6: error: 'void operator=(const int&)' must be a non-static member function
  691 | void operator=(const T&) const;
      |      ^~~~~~~~
p1320.cpp:719:34: error: 'T' was not declared in this scope
  719 |    void operator=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:719:35: error: template argument 1 is invalid
  719 |    void operator=(const valarray<T>&) const;
      |                                   ^
p1320.cpp:719:39: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  719 |    void operator=(const valarray<T>&) const;
      |                                       ^~~~~
p1320.cpp:719:9: error: 'void operator=(const int&)' must be a non-static member function
  719 |    void operator=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:720:36: error: class template placeholder 'std::indirect_array' not permitted in this context
  720 |    const indirect_array& operator=(const indirect_array&) const;
      |                                    ^~~~~
p1320.cpp:720:36: note: use 'auto' for an abbreviated function template
p1320.cpp:720:4: error: deduced class type 'indirect_array' in function return type
  720 |    const indirect_array& operator=(const indirect_array&) const;
      |    ^~~~~
p1320.cpp:25:25: note: 'template<class T> class std::indirect_array' declared here
   25 | template<class T> class indirect_array;
      |                         ^~~~~~~~~~~~~~
p1320.cpp:724:34: error: invalid conversion from 'int*' to 'long unsigned int' [-fpermissive]
  724 |        valarray<size_t> indirect(addr, 5);
      |                                  ^~~~
      |                                  |
      |                                  int*
p1320.cpp:159:37: note:   initializing argument 1 of 'std::valarray<_Tp>::valarray(const T&, std::size_t) [with T = long unsigned int; std::size_t = long unsigned int]'
  159 | explicit valarray(size_t); valarray(const T&, size_t); valarray(const T*, size_t); valarray(const valarray&); valarray(valarray&&) noexcept; valarray(const slice_array<T>&); valarray(const gslice_array<T>&); valarray(const mask_array<T>&); valarray(const indirect_array<T>&); valarray(initializer_list<T>); ~valarray();
      |                                     ^~~~~~~~
p1320.cpp:726:8: error: 'a' does not name a type
  726 |        a[indirect] = b;
      |        ^
p1320.cpp:729:33: error: 'T' was not declared in this scope
  729 | void operator*= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:729:34: error: template argument 1 is invalid
  729 | void operator*= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:729:38: error: non-member function 'void operator*=(const int&)' cannot have cv-qualifier
  729 | void operator*= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:729:6: error: 'void operator*=(const int&)' must have an argument of class or enumerated type
  729 | void operator*= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:730:33: error: 'T' was not declared in this scope
  730 | void operator/= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:730:34: error: template argument 1 is invalid
  730 | void operator/= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:730:38: error: non-member function 'void operator/=(const int&)' cannot have cv-qualifier
  730 | void operator/= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:730:6: error: 'void operator/=(const int&)' must have an argument of class or enumerated type
  730 | void operator/= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:731:33: error: 'T' was not declared in this scope
  731 | void operator%= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:731:34: error: template argument 1 is invalid
  731 | void operator%= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:731:38: error: non-member function 'void operator%=(const int&)' cannot have cv-qualifier
  731 | void operator%= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:731:6: error: 'void operator%=(const int&)' must have an argument of class or enumerated type
  731 | void operator%= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:732:33: error: 'T' was not declared in this scope
  732 | void operator+= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:732:34: error: template argument 1 is invalid
  732 | void operator+= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:732:38: error: non-member function 'void operator+=(const int&)' cannot have cv-qualifier
  732 | void operator+= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:732:6: error: 'void operator+=(const int&)' must have an argument of class or enumerated type
  732 | void operator+= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:733:33: error: 'T' was not declared in this scope
  733 | void operator-= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:733:34: error: template argument 1 is invalid
  733 | void operator-= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:733:38: error: non-member function 'void operator-=(const int&)' cannot have cv-qualifier
  733 | void operator-= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:733:6: error: 'void operator-=(const int&)' must have an argument of class or enumerated type
  733 | void operator-= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:734:33: error: 'T' was not declared in this scope
  734 | void operator^= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:734:34: error: template argument 1 is invalid
  734 | void operator^= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:734:38: error: non-member function 'void operator^=(const int&)' cannot have cv-qualifier
  734 | void operator^= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:734:6: error: 'void operator^=(const int&)' must have an argument of class or enumerated type
  734 | void operator^= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:735:33: error: 'T' was not declared in this scope
  735 | void operator&= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:735:34: error: template argument 1 is invalid
  735 | void operator&= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:735:38: error: non-member function 'void operator&=(const int&)' cannot have cv-qualifier
  735 | void operator&= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:735:6: error: 'void operator&=(const int&)' must have an argument of class or enumerated type
  735 | void operator&= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:736:33: error: 'T' was not declared in this scope
  736 | void operator|= (const valarray<T>&) const;
      |                                 ^
p1320.cpp:736:34: error: template argument 1 is invalid
  736 | void operator|= (const valarray<T>&) const;
      |                                  ^
p1320.cpp:736:38: error: non-member function 'void operator|=(const int&)' cannot have cv-qualifier
  736 | void operator|= (const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:736:6: error: 'void operator|=(const int&)' must have an argument of class or enumerated type
  736 | void operator|= (const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:737:33: error: 'T' was not declared in this scope
  737 | void operator<<=(const valarray<T>&) const;
      |                                 ^
p1320.cpp:737:34: error: template argument 1 is invalid
  737 | void operator<<=(const valarray<T>&) const;
      |                                  ^
p1320.cpp:737:38: error: non-member function 'void operator<<=(const int&)' cannot have cv-qualifier
  737 | void operator<<=(const valarray<T>&) const;
      |                                      ^~~~~
p1320.cpp:737:6: error: 'void operator<<=(const int&)' must have an argument of class or enumerated type
  737 | void operator<<=(const valarray<T>&) const;
      |      ^~~~~~~~
p1320.cpp:738:36: error: 'T' was not declared in this scope
  738 |    void operator>>=(const valarray<T>&) const;
      |                                    ^
p1320.cpp:738:37: error: template argument 1 is invalid
  738 |    void operator>>=(const valarray<T>&) const;
      |                                     ^
p1320.cpp:738:41: error: non-member function 'void operator>>=(const int&)' cannot have cv-qualifier
  738 |    void operator>>=(const valarray<T>&) const;
      |                                         ^~~~~
p1320.cpp:738:9: error: 'void operator>>=(const int&)' must have an argument of class or enumerated type
  738 |    void operator>>=(const valarray<T>&) const;
      |         ^~~~~~~~
p1320.cpp:742:22: error: 'T' does not name a type
  742 | void operator=(const T&) const;
      |                      ^
p1320.cpp:742:26: error: non-member function 'void operator=(const int&)' cannot have cv-qualifier
  742 | void operator=(const T&) const;
      |                          ^~~~~
p1320.cpp:742:6: error: 'void operator=(const int&)' must be a non-static member function
  742 | void operator=(const T&) const;
      |      ^~~~~~~~
p1320.cpp:745:19: error: 'unspecified1' does not name a type
  745 | template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v);
      |                   ^~~~~~~~~~~~
p1320.cpp:745:73: error: 'unspecified2' does not name a type
  745 | template<class T> unspecified1 begin(valarray<T>& v); template<class T> unspecified2 begin(const valarray<T>& v);
      |                                                                         ^~~~~~~~~~~~
p1320.cpp:747:19: error: 'unspecified2' does not name a type
  747 | template<class T> unspecified2 end(const valarray<T>& v);
      |                   ^~~~~~~~~~~~
```

## 検討事項(agenda)
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。

<!-- リンクエラーの解説をする。clang++とg++の比較。意味のある出力。
コンパイルエラーを取るか、コンパイルエラーの理由を解説する。-->

## 応用例1　AUTOSAR C++

AUTOSARでC++のコーディング標準を作っている。　
MISRA-C++コーディング標準の改訂をまたずに、C++14に対応したかったためかもしれない。　


Autosar Guidelines C++14 example code compile list


https://qiita.com/kaizen_nagoya/items/8ccbf6675c3494d57a76

## 応用例2　MISRA C++

MISRA C++, AUTOSAR C++について

https://qiita.com/kaizen_nagoya/items/3436fbd49865e0da7d35

MISRA C++ 5-0-16

https://qiita.com/kaizen_nagoya/items/7df2d4e05db724752a74


## 応用例3 CERT C++

MISRA C/C++, AUTOSAR C++, CERT C/C++とC/C++工業標準をコンパイルする

https://qiita.com/kaizen_nagoya/items/8dff19511e42b2593db1

## 応用例4 箱庭　

箱庭ではUnityをはじめC++を使っているらしい。　

ここでコンパイルしたコードと同じようなコードを使っているか、
ここで出たコンパイルエラーと同じようなエラーがでたかを
いろいろな版のコンパイラでコンパイルして確認していく。

仮想戦略会議「箱庭」

https://qiita.com/kaizen_nagoya/items/73cb132707653176a461

お盆には「箱庭」記事を書きましょう「もくもく会」の題材になる（１）

https://qiita.com/kaizen_nagoya/items/a22bf2b1dab0ad3258d4

お盆には「箱庭」記事を書きましょう「もくもく会」の題材になる（2）

https://qiita.com/kaizen_nagoya/items/e3c0ceb2dcc9cf3f3fac


# 参考資料(reference)

エンジニア夏休み企画 個人開発

https://qiita.com/official-events/6d31965c499a69377c0b


## 自己参考資料(self reference)

関連する自己参照以外は、こちらの先頭に移転。

C言語（C++)に対する誤解、曲解、無理解、爽快。

https://qiita.com/kaizen_nagoya/items/3f3992c9722c1cee2e3a

#include "N4910.h"

https://qiita.com/kaizen_nagoya/items/163a47cef7d6bb1c33a8

C++N4910資料の改善点

https://qiita.com/kaizen_nagoya/items/fb4ceb5d117a54641af3

dockerにclang

https://qiita.com/kaizen_nagoya/items/8829ffeee397eda50e80

docker gnu(gcc/g++) and llvm(clang/clang++)

https://qiita.com/kaizen_nagoya/items/059874ea39c4de64c0f7

コンパイル用shell script C版(clangとgcc)とC++版(clang++とg++)

https://qiita.com/kaizen_nagoya/items/74220c0577a512c2d7da


C++N4910:2022 tag follower 300人超えました。ありがとうございます。

https://qiita.com/kaizen_nagoya/items/a63fb96d351ac5c16ff7

astyle 使ってみた

https://qiita.com/kaizen_nagoya/items/3c9a87a781d53a1a23f3

【個人開発】　効率的な背景　＜エンジニア夏休み企画＞

https://qiita.com/kaizen_nagoya/items/3ebab436e63731e4b885
<この項は書きかけです。順次追記します。>
This article is not completed. I will add some words and/or centences in order.
Este artículo no está completo. Agregaré algunas palabras en orden.

## 知人資料
' @kazuo_reve 私が効果を確認した「小川メソッド」
https://qiita.com/kazuo_reve/items/a3ea1d9171deeccc04da

' @kazuo_reve 新人の方によく展開している有益な情報
https://qiita.com/kazuo_reve/items/d1a3f0ee48e24bba38f1

' @kazuo_reve Vモデルについて勘違いしていたと思ったこと
https://qiita.com/kazuo_reve/items/46fddb094563bd9b2e1e

## 自己記事一覧
Qiitaで逆リンクを表示しなくなったような気がする。時々、スマフォで表示するとあらわっることがあり、完全に削除したのではなさそう。

４月以降、せっせとリンクリストを作り、統計を取って確率を説明しようとしている。
2025年２月末を目標にしている。

一覧の一覧( The directory of directories of mine.) Qiita(100)
https://qiita.com/kaizen_nagoya/items/7eb0e006543886138f39

仮説（0）一覧（目標100現在40）
https://qiita.com/kaizen_nagoya/items/f000506fe1837b3590df

Qiita(0)Qiita関連記事一覧（自分）
https://qiita.com/kaizen_nagoya/items/58db5fbf036b28e9dfa6

Error一覧 error(0)
https://qiita.com/kaizen_nagoya/items/48b6cbc8d68eae2c42b8

C++ Support(0)　
https://qiita.com/kaizen_nagoya/items/8720d26f762369a80514

Coding(0) Rules, C, Secure, MISRA and so on
https://qiita.com/kaizen_nagoya/items/400725644a8a0e90fbb0

Ethernet 記事一覧　Ethernet(0)
https://qiita.com/kaizen_nagoya/items/88d35e99f74aefc98794

Wireshark 一覧 wireshark(0)、Ethernet(48) 
https://qiita.com/kaizen_nagoya/items/fbed841f61875c4731d0

線網（Wi-Fi）空中線(antenna)(0) 記事一覧(118/300目標)
https://qiita.com/kaizen_nagoya/items/5e5464ac2b24bd4cd001

なぜdockerで機械学習するか 書籍・ソース一覧作成中 (目標100)
https://qiita.com/kaizen_nagoya/items/ddd12477544bf5ba85e2

プログラムちょい替え（0）一覧:4件
https://qiita.com/kaizen_nagoya/items/296d87ef4bfd516bc394

言語処理100本ノックをdockerで。python覚えるのに最適。:10+12
https://qiita.com/kaizen_nagoya/items/7e7eb7c543e0c18438c4

Python(0)記事をまとめたい。
https://qiita.com/kaizen_nagoya/items/088c57d70ab6904ebb53

安全（0）安全工学シンポジウムに向けて: 21
https://qiita.com/kaizen_nagoya/items/c5d78f3def8195cb2409

プログラマによる、プログラマのための、統計(0)と確率のプログラミングとその後
https://qiita.com/kaizen_nagoya/items/6e9897eb641268766909

転職(0)一覧
https://qiita.com/kaizen_nagoya/items/f77520d378d33451d6fe

技術士(0)一覧
https://qiita.com/kaizen_nagoya/items/ce4ccf4eb9c5600b89ea

Reserchmap(0) 一覧
https://qiita.com/kaizen_nagoya/items/506c79e562f406c4257e

物理記事　上位100
https://qiita.com/kaizen_nagoya/items/66e90fe31fbe3facc6ff

量子(0) 計算機, 量子力学 
https://qiita.com/kaizen_nagoya/items/1cd954cb0eed92879fd4

数学関連記事１００
https://qiita.com/kaizen_nagoya/items/d8dadb49a6397e854c6d

coq(0) 一覧
https://qiita.com/kaizen_nagoya/items/d22f9995cf2173bc3b13

統計(0)一覧
https://qiita.com/kaizen_nagoya/items/80d3b221807e53e88aba

図(0) state, sequence and timing. UML and お絵描き 
https://qiita.com/kaizen_nagoya/items/60440a882146aeee9e8f

色(0) 記事100書く切り口 
https://qiita.com/kaizen_nagoya/items/22331c0335ed34326b9b

品質一覧 
https://qiita.com/kaizen_nagoya/items/2b99b8e9db6d94b2e971

言語・文学記事　１００
https://qiita.com/kaizen_nagoya/items/42d58d5ef7fb53c407d6

医工連携関連記事一覧
https://qiita.com/kaizen_nagoya/items/6ab51c12ba51bc260a82

水の資料集(0)　方針と成果
https://qiita.com/kaizen_nagoya/items/f5dbb30087ea732b52aa

自動車　記事　１００
https://qiita.com/kaizen_nagoya/items/f7f0b9ab36569ad409c5

通信記事１００
https://qiita.com/kaizen_nagoya/items/1d67de5e1cd207b05ef7

日本語（０）一欄
https://qiita.com/kaizen_nagoya/items/7498dcfa3a9ba7fd1e68

英語(0) 一覧
https://qiita.com/kaizen_nagoya/items/680e3f5cbf9430486c7d

音楽　一覧(0) 
https://qiita.com/kaizen_nagoya/items/b6e5f42bbfe3bbe40f5d

「@kazuo_reve 新人の方によく展開している有益な情報」確認一覧 
https://qiita.com/kaizen_nagoya/items/b9380888d1e5a042646b

鉄道（０）鉄道のシステム考察はてっちゃんがてつだってくれる
https://qiita.com/kaizen_nagoya/items/faa4ea03d91d901a618a

OSEK OS設計の基礎　OSEK(100)
https://qiita.com/kaizen_nagoya/items/7528a22a14242d2d58a3

coding (101) 一覧を作成し始めた。omake:最近のQiitaで表示しない5つの事象
https://qiita.com/kaizen_nagoya/items/20667f09f19598aedb68

官公庁・学校・公的団体（NPOを含む）システムの課題、官（０）
https://qiita.com/kaizen_nagoya/items/04ee6eaf7ec13d3af4c3

「はじめての」シリーズ　 ベクタージャパン　
https://qiita.com/kaizen_nagoya/items/2e41634f6e21a3cf74eb

AUTOSAR(0)Qiita記事一覧, OSEK(75)
https://qiita.com/kaizen_nagoya/items/89c07961b59a8754c869

プログラマが知っていると良い「公序良俗」
https://qiita.com/kaizen_nagoya/items/9fe7c0dfac2fbd77a945

LaTeX(0) 一覧　
https://qiita.com/kaizen_nagoya/items/e3f7dafacab58c499792

自動制御、制御工学一覧（０）
https://qiita.com/kaizen_nagoya/items/7767a4e19a6ae1479e6b

Rust(0) 一覧　
https://qiita.com/kaizen_nagoya/items/5e8bb080ba6ca0281927

programの本質は計画だ。programは設計だ。
https://qiita.com/kaizen_nagoya/items/c8545a769c246a458c27

登壇直後版 色使い(JIS安全色) Qiita Engineer Festa 2023〜私しか得しないニッチな技術でLT〜 スライド編 0.15
https://qiita.com/kaizen_nagoya/items/f0d3070d839f4f735b2b

プログラマが知っていると良い「公序良俗」
https://qiita.com/kaizen_nagoya/items/9fe7c0dfac2fbd77a945

逆も真：社会人が最初に確かめるとよいこと。OSEK(69)、Ethernet(59)
https://qiita.com/kaizen_nagoya/items/39afe4a728a31b903ddc

統計の嘘。仮説（127）
https://qiita.com/kaizen_nagoya/items/63b48ecf258a3471c51b

自分の言葉だけで論理展開できるのが天才なら、文章の引用だけで論理展開できるのが秀才だ。仮説（136）
https://qiita.com/kaizen_nagoya/items/97cf07b9e24f860624dd

参考文献駆動執筆(references driven writing)・デンソークリエイト編
https://qiita.com/kaizen_nagoya/items/b27b3f58b8bf265a5cd1

「何を」よりも「誰を」。１０年後のために今見習いたい人たち
https://qiita.com/kaizen_nagoya/items/8045978b16eb49d572b2

Qiitaの記事に３段階または５段階で到達するための方法
https://qiita.com/kaizen_nagoya/items/6e9298296852325adc5e

出力(output)と呼ばないで。これは状態(state)です。
https://qiita.com/kaizen_nagoya/items/80b8b5913b2748867840

祝休日・謹賀新年 2025年の目標
https://qiita.com/kaizen_nagoya/items/dfa34827932f99c59bbc

Qiita 1年間をまとめた「振り返りページ」＠2024
https://qiita.com/kaizen_nagoya/items/ed6be239119c99b15828

2024 参加・主催Calendarと投稿記事一覧 Qiita(248)
https://qiita.com/kaizen_nagoya/items/d80b8fbac2496df7827f

主催Calendar2024分析 Qiita(254)
https://qiita.com/kaizen_nagoya/items/15807336d583076f70bc

Calendar 統計
https://qiita.com/kaizen_nagoya/items/e315558dcea8ee3fe43e

LLM 関連 Calendar 2024 
https://qiita.com/kaizen_nagoya/items/c36033cf66862d5496fa

Large Language Model Related Calendar 
https://qiita.com/kaizen_nagoya/items/3beb0bc3fb71e3ae6d66

博士論文 Calendar 2024 を開催します。 
https://qiita.com/kaizen_nagoya/items/51601357efbcaf1057d0

博士論文(0)関連記事一覧
https://qiita.com/kaizen_nagoya/items/8f223a760e607b705e78

coding (101) 一覧を作成し始めた。omake:最近のQiitaで表示しない5つの事象
https://qiita.com/kaizen_nagoya/items/20667f09f19598aedb68

あなたは「勘違いまとめ」から、勘違いだと言っていることが勘違いだといくつ見つけられますか。人間の間違い(human error(125))の種類と対策
https://qiita.com/kaizen_nagoya/items/ae391b77fffb098b8fb4

プログラマの「プログラムが書ける」思い込みは強みだ。３つの理由。仮説（168）統計と確率(17) , OSEK(79)
https://qiita.com/kaizen_nagoya/items/bc5dd86e414de402ec29

出力(output)と呼ばないで。これは状態(state)です。
https://qiita.com/kaizen_nagoya/items/80b8b5913b2748867840

これからの情報伝達手段の在り方について考えてみよう。炎上と便乗。
https://qiita.com/kaizen_nagoya/items/71a09077ac195214f0db

ISO/IEC JTC1 SC7 Software and System Engineering
https://qiita.com/kaizen_nagoya/items/48b43f0f6976a078d907

アクセシビリティの知見を発信しよう！（再び）
https://qiita.com/kaizen_nagoya/items/03457eb9ee74105ee618

統計論及確率論輪講（再び）
https://qiita.com/kaizen_nagoya/items/590874ccfca988e85ea3

読者の心をグッと惹き寄せる7つの魔法
https://qiita.com/kaizen_nagoya/items/b1b5e89bd5c0a211d862

「@kazuo_reve 新人の方によく展開している有益な情報」確認一覧
https://qiita.com/kaizen_nagoya/items/b9380888d1e5a042646b

ソースコードで議論しよう。日本語で議論するの止めましょう（あるプログラミング技術の議論報告）
https://qiita.com/kaizen_nagoya/items/8b9811c80f3338c6c0b0

脳内コンパイラの3つの危険
https://qiita.com/kaizen_nagoya/items/7025cf2d7bd9f276e382

心理学の本を読むよりはコンパイラ書いた方がよくね。仮説（34）
https://qiita.com/kaizen_nagoya/items/fa715732cc148e48880e

NASAを超えるつもりがあれば読んでください。
https://qiita.com/kaizen_nagoya/items/e81669f9cb53109157f6

データサイエンティストの気づき!「勉強して仕事に役立てない人。大嫌い!!」『それ自分かも?』ってなった!!! 
https://qiita.com/kaizen_nagoya/items/d85830d58d8dd7f71d07

「ぼくの好きな先生」「人がやらないことをやれ」プログラマになるまで。仮説（37）　
https://qiita.com/kaizen_nagoya/items/53e4bded9fe5f724b3c4

なぜ経済学徒を辞め、計算機屋になったか（経済学部入学前・入学後・卒業後対応） 転職(1)  
https://qiita.com/kaizen_nagoya/items/06335a1d24c099733f64    

プログラミング言語教育のXYZ。 仮説（52） 
https://qiita.com/kaizen_nagoya/items/1950c5810fb5c0b07be4

【24卒向け】9ヶ月後に年収１０００万円を目指す。二つの関門と三つの道。
https://qiita.com/kaizen_nagoya/items/fb5bff147193f726ad25

「【25卒向け】Qiita Career Meetup for STUDENT」予習の勧め
https://qiita.com/kaizen_nagoya/items/00eadb8a6e738cb6336f

大学入試不合格でも筆記試験のない大学に入って卒業できる。卒業しなくても博士になれる。
https://qiita.com/kaizen_nagoya/items/74adec99f396d64b5fd5

全世界の不登校の子供たち「博士論文」を書こう。世界子供博士論文遠隔実践中心 安全(99)
https://qiita.com/kaizen_nagoya/items/912d69032c012bcc84f2

日本のプログラマが世界で戦える16分野。仮説(53),統計と確率(25) 転職(32)、Ethernet(58)
https://qiita.com/kaizen_nagoya/items/a7e634a996cdd02bc53b

小川メソッド　覚え（書きかけ）
https://qiita.com/kaizen_nagoya/items/3593d72eca551742df68

DoCAP（ドゥーキャップ）って何ですか？
https://qiita.com/kaizen_nagoya/items/47e0e6509ab792c43327

views 20,000越え自己記事一覧
https://qiita.com/kaizen_nagoya/items/58e8bd6450957cdecd81

Views１万越え、もうすぐ１万記事一覧 最近いいねをいただいた213記事
https://qiita.com/kaizen_nagoya/items/d2b805717a92459ce853

amazon 殿堂入りNo1レビュアになるまで。仮説(102)
https://qiita.com/kaizen_nagoya/items/83259d18921ce75a91f4

100以上いいねをいただいた記事16選
https://qiita.com/kaizen_nagoya/items/f8d958d9084ffbd15d2a

水道局10年(1976,4-1986,3)を振り返る
https://qiita.com/kaizen_nagoya/items/707fcf6fae230dd349bf

小川清最終講義、最終講義（再）計画, Ethernet(100) 英語(100) 安全(100)
https://qiita.com/kaizen_nagoya/items/e2df642e3951e35e6a53

＜この記事は個人の過去の経験に基づく個人の感想です。現在所属する組織、業務とは関係がありません。＞
This article is an individual impression based on my individual experience. It has nothing to do with the organization or business to which I currently belong.
Este artículo es una impresión personal basada en mi experiencia personal. No tiene nada que ver con la organización o empresa a la que pertenezco actualmente.
### 文書履歴(document history)
ver. 0.01 初稿 　20220817
### 最後までおよみいただきありがとうございました。
いいね　💚、フォローをお願いします。
#### Thank you very much for reading to the last sentence.
Please press the like icon 💚　and follow me for your happy life.
#### Muchas gracias por leer hasta la última oración.
Por favor, haz clic en el ícono Me gusta 💚 y sígueme para tener una vida feliz.