Octopus
utils.F90
Go to the documentation of this file.
1!! Copyright (C) 2002-2006 M. Marques, A. Castro, A. Rubio, G. Bertsch
2!! Copyright (C) 2021 S. Ohlmann
3!!
4!! This program is free software; you can redistribute it and/or modify
5!! it under the terms of the GNU General Public License as published by
6!! the Free Software Foundation; either version 2, or (at your option)
7!! any later version.
8!!
9!! This program is distributed in the hope that it will be useful,
10!! but WITHOUT ANY WARRANTY; without even the implied warranty of
11!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12!! GNU General Public License for more details.
13!!
14!! You should have received a copy of the GNU General Public License
15!! along with this program; if not, write to the Free Software
16!! Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17!! 02110-1301, USA.
18!!
19
20#include "global.h"
21#include "build_info.h"
22
25
26module utils_oct_m
27 use debug_oct_m
28 use global_oct_m
30 use io_oct_m
31 use iso_c_binding
32 use loct_oct_m
34 use mpi_oct_m
38 use unit_oct_m
40 use string_oct_m
41
42 implicit none
43
44 private
45 public :: &
47 index2axis, &
53 lead_dim, &
57
59 module procedure dleading_dimension_is_known, &
71 end interface leading_dimension_is_known
72
73 interface lead_dim
74 module procedure dlead_dim, zlead_dim
75 module procedure dlead_dim2, zlead_dim2
76 module procedure slead_dim, clead_dim
77 module procedure slead_dim2, clead_dim2
78 end interface lead_dim
79
80contains
81
82 ! ---------------------------------------------------------
83 subroutine get_divisors(nn, n_divisors, divisors)
84 integer, intent(in) :: nn
85 integer, intent(inout) :: n_divisors
86 integer, intent(out) :: divisors(:)
87
88 integer :: ii, max_d
89
90 push_sub(get_divisors)
91
92 assert(n_divisors > 1)
93 max_d = n_divisors
94
95 n_divisors = 1
96 divisors(n_divisors) = 1
97 do ii = 2, nn / 2
98 if (mod(nn, ii) == 0) then
99 n_divisors = n_divisors + 1
100
101 if (n_divisors > max_d - 1) then
102 message(1) = "Internal error in get_divisors. Please increase n_divisors"
103 call messages_fatal(1)
104 end if
105
106 divisors(n_divisors) = ii
107 end if
108 end do
109 n_divisors = n_divisors + 1
110 divisors(n_divisors) = nn
111
112 pop_sub(get_divisors)
113 end subroutine get_divisors
114
115
116 ! ---------------------------------------------------------
117 character pure function index2axis(idir) result(ch)
118 integer, intent(in) :: idir
119
120 select case (idir)
121 case (1)
122 ch = 'x'
123 case (2)
124 ch = 'y'
125 case (3)
126 ch = 'z'
127 case (4)
128 ch = 'w'
129 case default
130 write(ch,'(i1)') idir
131 end select
132
133 end function index2axis
134
135 ! ---------------------------------------------------------
136 pure function index2axisbz(idir) result(ch)
137 integer, intent(in) :: idir
138 character(len=2) :: ch
139
140 select case (idir)
141 case (1)
142 ch = "kx"
143 case (2)
144 ch = "ky"
145 case (3)
146 ch = "kz"
147 case (4)
148 ch = "kw"
149 case default
150 write(ch,'(i2)') idir
151 end select
152
153 end function index2axisbz
154
155
156 ! ---------------------------------------------------------
157 subroutine output_tensor(tensor, ndim, unit, write_average, iunit, namespace)
158 real(real64), intent(in) :: tensor(:,:)
159 integer, intent(in) :: ndim
160 type(unit_t), intent(in) :: unit
161 logical, optional, intent(in) :: write_average
162 integer, optional, intent(in) :: iunit
163 type(namespace_t), optional, intent(in) :: namespace
164
165 real(real64) :: trace
166 integer :: jj, kk
167 logical :: write_average_
168
169 push_sub(output_tensor)
170
171 write_average_ = optional_default(write_average, .true.)
172
173 trace = m_zero
174 message(1) = ""
175 do jj = 1, ndim
176 do kk = 1, ndim
177 write(message(1), '(a,f20.6)') trim(message(1)), units_from_atomic(unit, tensor(jj, kk))
178 end do
179 trace = trace + tensor(jj, jj)
180 call messages_info(1, iunit=iunit, namespace=namespace)
181 end do
182
183 if (write_average_) then
184 write(message(1), '(a, f20.6)') 'Isotropic average', units_from_atomic(unit, trace/real(ndim, real64) )
185 call messages_info(1, iunit=iunit, namespace=namespace)
186 end if
187
188 pop_sub(output_tensor)
189 end subroutine output_tensor
191
192 ! ---------------------------------------------------------
193 subroutine output_dipole(dipole, ndim, iunit, namespace)
194 real(real64), contiguous, intent(in) :: dipole(:)
195 integer, intent(in) :: ndim
196 integer, optional, intent(in) :: iunit
197 type(namespace_t), optional, intent(in) :: namespace
198
199 integer :: idir
200
201 push_sub(output_dipole)
202
203 write(message(1), '(a,a20,a17)') 'Dipole:', '[' // trim(units_abbrev(units_out%length)) // ']', &
204 '[' // trim(units_abbrev(unit_debye)) // ']'
205 do idir = 1, ndim
206 write(message(1+idir), '(6x,3a,es14.5,3x,2es14.5)') '<', index2axis(idir), '> = ', &
207 units_from_atomic(units_out%length, dipole(idir)), units_from_atomic(unit_debye, dipole(idir))
208 end do
209 call messages_info(1+ndim, iunit=iunit, namespace=namespace)
210
211 pop_sub(output_dipole)
212 end subroutine output_dipole
213
216 subroutine print_header()
217 use iso_fortran_env
218
219 character(len=256) :: sys_name
220
221 ! Let us print our logo
222 call io_dump_file(stdout, trim(trim(conf%share) // '/logo'))
223
224 ! Let us print the version
225 message(1) = ""
226 message(2) = str_center("Running octopus", 70)
227 message(3) = ""
228 call messages_info(3)
229
230 message(1) = &
231 "Version : " // trim(conf%version)
232 message(2) = &
233 "Commit : "// trim(conf%git_commit)
234 message(3) = &
235 "Configuration time : "// trim(conf%config_time)
236 call messages_info(3)
237
238 message(1) = 'Configuration options : ' // trim(get_config_opts())
239 message(2) = 'Optional libraries :' // trim(get_optional_libraries())
240
241 message(3) = 'Architecture : ' + tostring(oct_arch)
242 call messages_info(3)
243
245
246 message(1) = &
247 "C compiler : "//trim(conf%cc)
248 message(2) = &
249 "C compiler flags : "//trim(conf%cflags)
250 message(3) = &
251 "C++ compiler : "//trim(conf%cxx)
252 message(4) = &
253 "C++ compiler flags : "//trim(conf%cxxflags)
254 message(5) = "Fortran compiler : "//trim(conf%fc) //" ("//compiler_version()//")"
255 message(6) = &
256 "Fortran compiler flags : "//trim(conf%fcflags)
257 call messages_info(6)
258
259 message(1) = ""
260 call messages_info(1)
261
262 ! Let us print where we are running
263 call loct_sysname(sys_name)
264 write(message(1), '(a)') "The octopus is swimming in " // trim(sys_name)
265 write(message(2), '(a,i0,a,i0,a)') "CPU 0 data caches : L1 ", cpu_hardware%l1%size/1024, " kB, L2 ", &
266 cpu_hardware%l2%size/1024, " kB"
267 message(3) = ""
268 call messages_info(3)
269
270 call mpi_world%barrier()
271
272 call print_date("Calculation started on ")
273 end subroutine print_header
274
275
279 character(len=256) function get_config_opts()
280
281 get_config_opts = ''
282#ifdef HAVE_OPENMP
283 get_config_opts = trim(get_config_opts)//' openmp'
284#endif
285#ifdef HAVE_MPI
286 get_config_opts = trim(get_config_opts)//' mpi'
287#endif
288#ifdef HAVE_CUDA
290#endif
291#ifdef HAVE_CUDA_MPI
292 get_config_opts = trim(get_config_opts)//' cuda-mpi'
293#endif
294#ifdef HAVE_LIBXC_KXC
295 get_config_opts = trim(get_config_opts)//' libxc_kxc'
296#endif
297#ifdef HAVE_LIBXC_FUNCS
298 get_config_opts = trim(get_config_opts)//' libxc_funcs'
299#endif
300#ifdef HAVE_LIBXC_DEVICE
301 get_config_opts = trim(get_config_opts)//' libxc_device'
302#endif
303#ifdef HAVE_HIP
304 get_config_opts = trim(get_config_opts)//' hip'
305#endif
306#ifdef HAVE_FFTW3_THREADS
307 get_config_opts = trim(get_config_opts)//' fftw3_threads'
308#endif
309#ifdef HAVE_CUBIN
310 get_config_opts = trim(get_config_opts)//' cubin'
311#endif
312#ifdef HAVE_NVTX
313 get_config_opts = trim(get_config_opts)//' nvtx'
314#endif
315
316 end function get_config_opts
317
321 character(len=256) function get_optional_libraries()
322
323 ! keep in alphabetical order, for ease in seeing if something is listed
325#ifdef HAVE_ADIOS2
327#endif
328#ifdef HAVE_BERKELEYGW
330#endif
331#ifdef HAVE_CGAL
333#endif
334#ifdef HAVE_DFTBPLUS
336#endif
337#ifdef HAVE_ELPA
339#endif
340#ifdef HAVE_LIKWID
342#endif
343#ifdef HAVE_LIBVDWXC
345#endif
346#ifdef HAVE_LIBVDWXC_MPI
347 get_optional_libraries = trim(get_optional_libraries)//' libvdwxc_mpi'
348#endif
349#ifdef HAVE_MATTERSIM
351#endif
352#ifdef HAVE_METIS
354#endif
355#ifdef HAVE_NETCDF
357#endif
358#ifdef HAVE_NFFT
360#endif
361#ifdef HAVE_PARMETIS
363#endif
364#ifdef HAVE_PFFT
366#endif
367#ifdef HAVE_PNFFT
369#endif
370#ifdef HAVE_PSOLVER
372#endif
373#ifdef HAVE_PSPIO
375#endif
376#ifdef HAVE_SCALAPACK
378#endif
379#ifdef HAVE_SPARSKIT
381#endif
382#ifdef HAVE_NLOPT
384#endif
385#ifdef HAVE_VERROU
387#endif
388#ifdef HAVE_WANNIER90
390#endif
391
392 end function get_optional_libraries
393
394 ! ---------------------------------------------------------
395
396 logical function dleading_dimension_is_known(array) result(known)
397 real(real64), target, intent(in) :: array(:, :)
398
399 integer(c_intptr_t) :: addr1, addr2
400
401 known = .true.
402
403 if (ubound(array, dim = 2) > 1) then
404 addr1 = transfer(c_loc(array(1,1)), 0_c_intptr_t)
405 addr2 = transfer(c_loc(array(1,2)), 0_c_intptr_t)
406 known = ubound(array, dim = 1) == (addr2-addr1)/c_sizeof(array(1, 1))
407 end if
408
409 end function dleading_dimension_is_known
410
411
412 ! ---------------------------------------------------------
413
414 logical function zleading_dimension_is_known(array) result(known)
415 complex(real64), target, intent(in) :: array(:, :)
416
417 integer(c_intptr_t) :: addr1, addr2
418
419 known = .true.
420
421 if (ubound(array, dim = 2) > 1) then
422 addr1 = transfer(c_loc(array(1,1)), 0_c_intptr_t)
423 addr2 = transfer(c_loc(array(1,2)), 0_c_intptr_t)
424 known = ubound(array, dim = 1) == (addr2-addr1)/c_sizeof(array(1, 1))
425 end if
426
427 end function zleading_dimension_is_known
428
429 ! ---------------------------------------------------------
430
431 logical function ileading_dimension_is_known(array) result(known)
432 integer, target, intent(in) :: array(:, :)
433
434 integer(c_intptr_t) :: addr1, addr2
435
436 known = .true.
437
438 if (ubound(array, dim = 2) > 1) then
439 addr1 = transfer(c_loc(array(1,1)), 0_c_intptr_t)
440 addr2 = transfer(c_loc(array(1,2)), 0_c_intptr_t)
442 known = ubound(array, dim = 1) == (addr2-addr1)/c_sizeof(array(1, 1))
443 end if
444
445 end function ileading_dimension_is_known
446
447
448 logical function lleading_dimension_is_known(array) result(known)
449 integer(int64), target, intent(in) :: array(:, :)
450
451 integer(c_intptr_t) :: addr1, addr2
452
453 known = .true.
454
455 if (ubound(array, dim = 2) > 1) then
456 addr1 = transfer(c_loc(array(1,1)), 0_c_intptr_t)
457 addr2 = transfer(c_loc(array(1,2)), 0_c_intptr_t)
458
459 known = ubound(array, dim = 1) == (addr2-addr1)/c_sizeof(array(1, 1))
460 end if
461
462 end function lleading_dimension_is_known
463
464
465 ! ---------------------------------------------------------
466
467 logical function sleading_dimension_is_known(array) result(known)
468 real(real32), target, intent(in) :: array(:, :)
469
470 integer(c_intptr_t) :: addr1, addr2
471
472 known = .true.
473
474 if (ubound(array, dim = 2) > 1) then
475 addr1 = transfer(c_loc(array(1,1)), 0_c_intptr_t)
476 addr2 = transfer(c_loc(array(1,2)), 0_c_intptr_t)
477 known = ubound(array, dim = 1) == (addr2-addr1)/c_sizeof(array(1, 1))
478 end if
479
480 end function sleading_dimension_is_known
481
482
483 ! ---------------------------------------------------------
484
485 logical function cleading_dimension_is_known(array) result(known)
486 complex(real32), target, intent(in) :: array(:, :)
487
488 integer(c_intptr_t) :: addr1, addr2
489
490 known = .true.
491
492 if (ubound(array, dim = 2) > 1) then
493 addr1 = transfer(c_loc(array(1,1)), 0_c_intptr_t)
494 addr2 = transfer(c_loc(array(1,2)), 0_c_intptr_t)
495 known = ubound(array, dim = 1) == (addr2-addr1)/c_sizeof(array(1, 1))
496 end if
497
498 end function cleading_dimension_is_known
499
500
501 ! ---------------------------------------------------------
502
503 logical function dleading_dimension_is_known2(array) result(known)
504 real(real64), target, intent(in) :: array(:, :, :)
505
506 integer(c_intptr_t) :: addr1, addr2
507
508 known = .true.
509
510 if (ubound(array, dim = 2) > 1) then
511 addr1 = transfer(c_loc(array(1,1,1)), 0_c_intptr_t)
512 addr2 = transfer(c_loc(array(1,2,1)), 0_c_intptr_t)
513 known = ubound(array, dim = 1) == (addr2 - addr1)/c_sizeof(array(1, 1, 1))
514 end if
515
517
518
519 ! ---------------------------------------------------------
520
521 logical function zleading_dimension_is_known2(array) result(known)
522 complex(real64), target, intent(in) :: array(:, :, :)
523
524 integer(c_intptr_t) :: addr1, addr2
525
526 known = .true.
527
528 if (ubound(array, dim = 2) > 1) then
529 addr1 = transfer(c_loc(array(1,1,1)), 0_c_intptr_t)
530 addr2 = transfer(c_loc(array(1,2,1)), 0_c_intptr_t)
531 known = ubound(array, dim = 1) == (addr2 - addr1)/c_sizeof(array(1, 1, 1))
532 end if
533
535
536 ! ---------------------------------------------------------
537
538 logical function ileading_dimension_is_known2(array) result(known)
539 integer, target, intent(in) :: array(:, :, :)
540
541 integer(c_intptr_t) :: addr1, addr2
542
543 known = .true.
544
545 if (ubound(array, dim = 2) > 1) then
546 addr1 = transfer(c_loc(array(1,1,1)), 0_c_intptr_t)
547 addr2 = transfer(c_loc(array(1,2,1)), 0_c_intptr_t)
548 known = ubound(array, dim = 1) == (addr2 - addr1)/c_sizeof(array(1, 1, 1))
549 end if
550
552
553
554 logical function lleading_dimension_is_known2(array) result(known)
555 integer(int64), target, intent(in) :: array(:, :, :)
556
557 integer(c_intptr_t) :: addr1, addr2
558
559 known = .true.
560
561 if (ubound(array, dim = 2) > 1) then
562 addr1 = transfer(c_loc(array(1,1,1)), 0_c_intptr_t)
563 addr2 = transfer(c_loc(array(1,2,1)), 0_c_intptr_t)
564 known = ubound(array, dim = 1) == (addr2 - addr1)/c_sizeof(array(1, 1, 1))
565 end if
566
568
569 ! ---------------------------------------------------------
570
571 logical function sleading_dimension_is_known2(array) result(known)
572 real(real32), target, intent(in) :: array(:, :, :)
573
574 integer(c_intptr_t) :: addr1, addr2
575
576 known = .true.
577
578 if (ubound(array, dim = 2) > 1) then
579 addr1 = transfer(c_loc(array(1,1,1)), 0_c_intptr_t)
580 addr2 = transfer(c_loc(array(1,2,1)), 0_c_intptr_t)
581 known = ubound(array, dim = 1) == (addr2 - addr1)/c_sizeof(array(1, 1, 1))
582 end if
583
585
586 ! ---------------------------------------------------------
587
588 logical function cleading_dimension_is_known2(array) result(known)
589 complex(real32), target, intent(in) :: array(:, :, :)
590
591 integer(c_intptr_t) :: addr1, addr2
592
593 known = .true.
594
595 if (ubound(array, dim = 2) > 1) then
596 addr1 = transfer(c_loc(array(1,1,1)), 0_c_intptr_t)
597 addr2 = transfer(c_loc(array(1,2,1)), 0_c_intptr_t)
598 known = ubound(array, dim = 1) == (addr2 - addr1)/c_sizeof(array(1, 1, 1))
599 end if
600
602
603 ! ---------------------------------------------------------
604
605 integer function dlead_dim(array) result(lead_dim)
606 real(real64), intent(in) :: array(:, :)
607
608 assert(leading_dimension_is_known(array))
610 lead_dim = ubound(array, dim = 1)
611 end function dlead_dim
612
613 ! ---------------------------------------------------------
614
615 integer function zlead_dim(array) result(lead_dim)
616 complex(real64), intent(in) :: array(:, :)
617
618 assert(leading_dimension_is_known(array))
620 lead_dim = ubound(array, dim = 1)
621 end function zlead_dim
622
623 ! ---------------------------------------------------------
624
625 integer function dlead_dim2(array) result(lead_dim)
626 real(real64), intent(in) :: array(:, :, :)
627
628 assert(leading_dimension_is_known(array))
630 lead_dim = ubound(array, dim = 1) * ubound(array, dim = 2)
631 end function dlead_dim2
632
633 ! ---------------------------------------------------------
634
635 integer function zlead_dim2(array) result(lead_dim)
636 complex(real64), intent(in) :: array(:, :, :)
637
638 assert(leading_dimension_is_known(array))
640 lead_dim = ubound(array, dim = 1) * ubound(array, dim = 2)
641 end function zlead_dim2
642
643 ! ---------------------------------------------------------
644
645 integer function slead_dim(array) result(lead_dim)
646 real(real32), intent(in) :: array(:, :)
647
648 assert(leading_dimension_is_known(array))
650 lead_dim = ubound(array, dim = 1)
651 end function slead_dim
652
653 ! ---------------------------------------------------------
654
655 integer function clead_dim(array) result(lead_dim)
656 complex(real32), intent(in) :: array(:, :)
658 assert(leading_dimension_is_known(array))
659
660 lead_dim = ubound(array, dim = 1)
661 end function clead_dim
662
663 ! ---------------------------------------------------------
664
665 integer function slead_dim2(array) result(lead_dim)
666 real(real32), intent(in) :: array(:, :, :)
667
668 assert(leading_dimension_is_known(array))
669
670 lead_dim = ubound(array, dim = 1) * ubound(array, dim = 2)
671 end function slead_dim2
672
673 ! ---------------------------------------------------------
674
675 integer function clead_dim2(array) result(lead_dim)
676 complex(real32), intent(in) :: array(:, :, :)
678 assert(leading_dimension_is_known(array))
679
680 lead_dim = ubound(array, dim = 1) * ubound(array, dim = 2)
681 end function clead_dim2
682
683 subroutine make_array_larger(array, new_size)
684 integer(int64), allocatable, intent(inout) :: array(:)
685 integer, intent(in) :: new_size
686
687 integer(int64), allocatable :: tmp(:)
688 integer :: copy_size
689
690 push_sub(make_array_larger)
691
692 ! Use allocate here as move_alloc deallocate internally the from array
693 allocate(tmp(1:new_size))
694 copy_size = min(new_size, size(array))
695 tmp(1:copy_size) = array(1:copy_size)
696 safe_deallocate_a(array)
697 call move_alloc(tmp, array)
698
699 pop_sub(make_array_larger)
700 end subroutine make_array_larger
701
703 subroutine write_vectorization_level()
704 character(len=32) :: vec
705 character(kind=c_char) :: c_str(33)
706
707 c_str = c_null_char
708 call get_vectorization_level(c_str)
709 call string_c_to_f(c_str, vec)
710 message(1) = 'Vectorization level : ' // trim(vec)
711 call messages_info(1)
712
713 end subroutine write_vectorization_level
714
715end module utils_oct_m
716
717!! Local Variables:
718!! mode: f90
719!! coding: utf-8
720!! End:
Definition: io.F90:93
System information (time, memory, sysname)
Definition: loct.F90:94
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
Definition: messages.F90:138
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
Definition: messages.F90:386
This module contains interfaces for routines in operate.c.
Definition: operate_f.F90:96
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
Definition: profiling.F90:122
brief This module defines the class unit_t which is used by the unit_systems_oct_m module.
Definition: unit.F90:111
This module defines the unit system, used for input and output.
This module is intended to contain simple general-purpose utility functions and procedures.
Definition: utils.F90:99
subroutine, public output_tensor(tensor, ndim, unit, write_average, iunit, namespace)
Definition: utils.F90:231
character(len=256) function, public get_config_opts()
Character string containing compile-time options.
Definition: utils.F90:353
logical function cleading_dimension_is_known(array)
Definition: utils.F90:460
integer function zlead_dim2(array)
Definition: utils.F90:610
subroutine write_vectorization_level()
Prints the level of vectorization used for the vectorized finite differences.
Definition: utils.F90:678
subroutine, public output_dipole(dipole, ndim, iunit, namespace)
Definition: utils.F90:267
logical function zleading_dimension_is_known2(array)
Definition: utils.F90:496
logical function lleading_dimension_is_known(array)
Definition: utils.F90:423
logical function zleading_dimension_is_known(array)
Definition: utils.F90:389
subroutine, public get_divisors(nn, n_divisors, divisors)
Definition: utils.F90:157
integer function dlead_dim(array)
Definition: utils.F90:580
subroutine, public make_array_larger(array, new_size)
Definition: utils.F90:658
integer function clead_dim(array)
Definition: utils.F90:630
logical function dleading_dimension_is_known2(array)
Definition: utils.F90:478
character(len=256) function, public get_optional_libraries()
Character string containing optional external libraries.
Definition: utils.F90:362
logical function ileading_dimension_is_known(array)
Definition: utils.F90:406
integer function dlead_dim2(array)
Definition: utils.F90:600
integer function slead_dim2(array)
Definition: utils.F90:640
logical function cleading_dimension_is_known2(array)
Definition: utils.F90:563
character pure function, public index2axis(idir)
Definition: utils.F90:191
integer function clead_dim2(array)
Definition: utils.F90:650
logical function lleading_dimension_is_known2(array)
Definition: utils.F90:529
integer function slead_dim(array)
Definition: utils.F90:620
logical function ileading_dimension_is_known2(array)
Definition: utils.F90:513
logical function sleading_dimension_is_known(array)
Definition: utils.F90:442
pure character(len=2) function, public index2axisbz(idir)
Definition: utils.F90:210
subroutine, public print_header()
This subroutine prints the logo followed by information about the compilation and the system....
Definition: utils.F90:290
logical function sleading_dimension_is_known2(array)
Definition: utils.F90:546
integer function zlead_dim(array)
Definition: utils.F90:590
logical function dleading_dimension_is_known(array)
Definition: utils.F90:371
void get_vectorization_level(char *level)
Definition: operate.c:3534
int true(void)