CoCalc -- container

Download
A (one dimensional) cellular automaton is a function1 F : Σ → Σ with the property that there is a K > 0 such that F (x)i depends only on the 2K + 1 coordinates xi−K , xi−K+1, . . . , xi−1, xi, xi+1, . . . , xi+K . A periodic point of σ is any x such that σ^p (x) = x for some p ∈ N, and a periodic point of F is any x such that F^q (x) = x for some q ∈ N. Given a cellular automaton F, a point x ∈ Σ is jointly periodic if there are p, q ∈ N such that σ^p (x) = F^q (x) = x, that is, it is a periodic point under both functions.
This project aims to explore the nature of one-dimensional Cellular Automata, in the hope of finding the structure of cellular automata through its periodic points.
Shared Project -- M498ES23-Cellular-Automata
LEMMA Research Project / Code / Source code / Program (1) / Program / Source / STL / container_concepts.h
²⁰³⁴ views
License: MIT
ubuntu2004
1
/*
2
 * Copyright (c) 1999
3
 * Silicon Graphics Computer Systems, Inc.
4
 *
5
 * Permission to use, copy, modify, distribute and sell this software
6
 * and its documentation for any purpose is hereby granted without fee,
7
 * provided that the above copyright notice appear in all copies and
8
 * that both that copyright notice and this permission notice appear
9
 * in supporting documentation.  Silicon Graphics makes no
10
 * representations about the suitability of this software for any
11
 * purpose.  It is provided "as is" without express or implied warranty.
12
 */
13

14
#ifndef __STL_CONTAINER_CONCEPTS_H
15
#define __STL_CONTAINER_CONCEPTS_H
16

17

18
#include <concept_checks.h>
19

20
#ifdef __STL_USE_CONCEPT_CHECKS
21

22

23
// This file covers the following concepts:
24
//       _Container
25
//       _ForwardContainer
26
//       _ReversibleContainer
27
//       _const_ReversibleContainer
28
//       _RandomAccessContainer
29
//
30

31
struct _ERROR_IN_STL_CONTAINER {
32

33
  /* Container expresssions */
34

35
  template <class _Container>
36
  static void
37
  __begin_iterator_accessor_requirement_violation(_Container __c) {
38
    __c.begin();
39
  }
40
  template <class _Container>
41
  static void
42
  __const_begin_iterator_accessor_requirement_violation(const _Container& __c) {
43
    __c.begin();
44
  }
45
  template <class _Container>
46
  static void
47
  __end_iterator_accessor_requirement_violation(_Container __c) {
48
    __c.end();
49
  }
50
  template <class _Container>
51
  static void
52
  __const_end_iterator_accessor_requirement_violation(const _Container& __c) {
53
    __c.end();
54
  }
55

56
  template <class _Container>
57
  static void
58
  __rbegin_iterator_accessor_requirement_violation(_Container __c) {
59
    __c.rbegin();
60
  }
61
  template <class _Container>
62
  static void
63
  __const_rbegin_iterator_accessor_requirement_violation(const _Container& __c) {
64
    __c.rbegin();
65
  }
66
  template <class _Container>
67
  static void
68
  __rend_iterator_accessor_requirement_violation(_Container __c) {
69
    __c.rend();
70
  }
71
  template <class _Container>
72
  static void
73
  __const_rend_iterator_accessor_requirement_violation(const _Container& __c) {
74
    __c.rend();
75
  }
76
  template <class _Container>
77
  static void
78
  __size_function_must_be_const(const _Container& __c) {
79
    __c.size();
80
  }
81
  template <class _Container>
82
  static void
83
  __size_function_requirement_violation(_Container& __c) {
84
    __c.size();
85
    __size_function_must_be_const(__c);
86
  }
87
  template <class _Container>
88
  static void
89
  __max_size_function_must_be_const(const _Container& __c) {
90
    __c.max_size();
91
  }
92
  template <class _Container>
93
  static void
94
  __max_size_function_requirement_violation(_Container& __c) {
95
    __c.max_size();
96
    __max_size_function_must_be_const(__c);
97
  }
98
  template <class _Container>
99
  static void
100
  __empty_function_must_be_const(const _Container& __c) {
101
    __c.empty();
102
  }
103
  template <class _Container>
104
  static void
105
  __empty_function_requirement_violation(_Container& __c) {
106
    __c.empty();
107
    __empty_function_must_be_const(__c);
108
  }
109
  template <class _Container>
110
  static void
111
  __swap_function_requirement_violation(_Container& __c) {
112
    __c.swap(__c);
113
  }
114

115
};
116

117

118
__STL_TYPEDEF_REQUIREMENT(iterator);
119
__STL_TYPEDEF_REQUIREMENT(const_iterator);
120

121
/* Containers */
122

123
template <class _Container>
124
struct _Container_concept_specification {
125
static void
126
_Container_requirement_violation(_Container __c) {
127
  // Refinement of Assignable
128
  _Assignable_concept_specification<_Container>::_Assignable_requirement_violation(__c);
129
  // Associated Types
130
  __value_type__typedef_requirement_violation<_Container>();
131
  __difference_type__typedef_requirement_violation<_Container>();
132
  __size_type__typedef_requirement_violation<_Container>();
133
  __reference__typedef_requirement_violation<_Container>();
134
  __const_reference__typedef_requirement_violation<_Container>();
135
  __pointer__typedef_requirement_violation<_Container>();
136
  __const_pointer__typedef_requirement_violation<_Container>();
137
  __iterator__typedef_requirement_violation<_Container>();
138
  __const_iterator__typedef_requirement_violation<_Container>();
139
  // Valid Expressions
140
  _ERROR_IN_STL_CONTAINER::__const_begin_iterator_accessor_requirement_violation(__c);
141
  _ERROR_IN_STL_CONTAINER::__const_end_iterator_accessor_requirement_violation(__c);
142
  _ERROR_IN_STL_CONTAINER::__begin_iterator_accessor_requirement_violation(__c);
143
  _ERROR_IN_STL_CONTAINER::__end_iterator_accessor_requirement_violation(__c);
144
  _ERROR_IN_STL_CONTAINER::__size_function_requirement_violation(__c);
145
  _ERROR_IN_STL_CONTAINER::__max_size_function_requirement_violation(__c);
146
  _ERROR_IN_STL_CONTAINER::__empty_function_requirement_violation(__c);
147
  _ERROR_IN_STL_CONTAINER::__swap_function_requirement_violation(__c);
148
  // Requirements on Iterators
149
  typedef typename _Container::iterator iter;
150
  typedef typename _Container::const_iterator const_iter;
151
  _InputIterator_concept_specification<const_iter>::_InputIterator_requirement_violation(const_iter());
152
  _InputIterator_concept_specification<iter>::_InputIterator_requirement_violation(iter());
153
}
154
};
155

156
template <class _ForwardContainer>
157
struct _ForwardContainer_concept_specification {
158
static void
159
_ForwardContainer_requirement_violation(_ForwardContainer __c) {
160
  // Refinement of Container
161
  _Container_concept_specification<_ForwardContainer>::_Container_requirement_violation(__c);
162
  // Requirements on Iterators
163
  typedef typename _ForwardContainer::iterator iter;
164
  typedef typename _ForwardContainer::const_iterator const_iter;
165
  _ForwardIterator_concept_specification<const_iter>::_ForwardIterator_requirement_violation(const_iter());
166
  _Mutable_ForwardIterator_concept_specification<iter>::_Mutable_ForwardIterator_requirement_violation(iter());
167
}
168
};
169

170

171
__STL_TYPEDEF_REQUIREMENT(reverse_iterator);
172
__STL_TYPEDEF_REQUIREMENT(const_reverse_iterator);
173

174
template <class _ReversibleContainer>
175
struct _ReversibleContainer_concept_specification {
176
static void
177
_ReversibleContainer_requirement_violation(_ReversibleContainer __c) {
178
  // Refinement of ForwardContainer
179
  _ForwardContainer_concept_specification<_ReversibleContainer>::_ForwardContainer_requirement_violation(__c);
180
  // Associated types
181
  __reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
182
  __const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
183
  // Valid Expressions
184
  _ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c);
185
  _ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c);
186
  _ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c);
187
  _ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c);
188
  // Requirements on Iterators
189
  typedef typename _ReversibleContainer::iterator iter;
190
  typedef typename _ReversibleContainer::const_iterator const_iter;
191
  _BidirectionalIterator_concept_specification<const_iter>::_BidirectionalIterator_requirement_violation(const_iter());
192
  _Mutable_BidirectionalIterator_concept_specification<iter>::_Mutable_BidirectionalIterator_requirement_violation(iter());
193
}
194
};
195

196
template <class _ReversibleContainer>
197
struct _const_ReversibleContainer_concept_specification {
198
static void
199
_const_ReversibleContainer_requirement_violation(_ReversibleContainer __c) {
200
  // Refinement of Container (JGS, not ForwardContainer)
201
  _Container_concept_specification<_ReversibleContainer>::_Container_requirement_violation(__c);
202
  // Associated types
203
  __reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
204
  __const_reverse_iterator__typedef_requirement_violation<_ReversibleContainer>();
205
  // Valid Expressions
206
  _ERROR_IN_STL_CONTAINER::__const_rbegin_iterator_accessor_requirement_violation(__c);
207
  _ERROR_IN_STL_CONTAINER::__const_rend_iterator_accessor_requirement_violation(__c);
208
  _ERROR_IN_STL_CONTAINER::__rbegin_iterator_accessor_requirement_violation(__c);
209
  _ERROR_IN_STL_CONTAINER::__rend_iterator_accessor_requirement_violation(__c);
210
  // Requirements on Iterators
211
  typedef typename _ReversibleContainer::iterator iter;
212
  typedef typename _ReversibleContainer::const_iterator const_iter;
213
  
214
  // This line won't compile on gcc 2.91 due to a compiler bug.
215
#if !(__GNUC__ == 2 && __GNUC_MINOR__ == 91)
216
  __BidirectionalIterator_concept_specification<const_iter>::_BidirectionalIterator_requirement_violation(const_iter());
217
#endif
218
}
219
};
220

221

222
template <class _RandomAccessContainer>
223
struct _RandomAccessContainer_concept_specification {
224
static void
225
_RandomAccessContainer_requirement_violation(_RandomAccessContainer __c) {
226
  // Refinement of ReversibleContainer
227
  _ReversibleContainer_concept_specification<_RandomAccessContainer>::_ReversibleContainer_requirement_violation(__c);
228
  // Valid Expressions
229
  typedef typename _RandomAccessContainer::value_type __T;
230
  typedef typename _RandomAccessContainer::difference_type _Dist;
231
  typedef typename _Mutable_trait<__T>::_Type Type;
232
  typedef Type* _TypePtr;
233
  typedef typename _Mutable_trait<_Dist>::_Type Dist;
234
  _STL_ERROR::__element_access_operator_requirement_violation(__c,
235
							      _TypePtr(), 
236
							      Dist());
237
  // Requirements on Iterators
238
  typedef typename _RandomAccessContainer::iterator iter;
239
  typedef typename _RandomAccessContainer::const_iterator const_iter;
240
  _RandomAccessIterator_concept_specification<const_iter>::_RandomAccessIterator_requirement_violation(const_iter());
241
  _Mutable_RandomAccessIterator_concept_specification<iter>::_Mutable_RandomAccessIterator_requirement_violation(iter());
242
}
243
};
244

245
#endif /* if __STL_USE_CONCEPT_CHECKS */
246

247
#endif /* __STL_CONTAINER_CONCEPTS_H */
248

249
Product

Resources

Company
