Iterative Statements Research Articles

A Requiem for Women: Narrative Strategy, Rhetoric, and Ideology in Candrāvatī’s Bengali Rāmāyaṇa

Abstract The numerous versions of Vālmīki’s original Rāmāyaṇa in different languages and milieus display an almost limitless cultural and ideological variety. Whether purportedly faithful translations or interpretive re-creations, these versions present a vast range of responses to a narrative that has been often transformed to reflect contemporary social and spiritual experiences and positions. A particularly intriguing example of such a transformation is the late 15th c. Bengali Rāmāyaṇa of Candrāvatī, of interest not only because this is the first extant work by a female author in the tradition of Bengali poetry but more importantly because (i) she composed the narrative from a woman’s point of view, and (ii) she converted the original battle narrative into a dirge for the victims of war, especially women. In her poem the validation of war and conquest is set aside, justice is shown to be unjust, and even faith as a spiritual axiom is undermined. Candrāvatī’s literary strategy, including her diction, iterative statements and lyrical forms, replaces the heroic style of the conventional epic with the language of feminine domesticity. The Rāmāyaṇa is thus turned against itself emotionally and ideologically by being reoriented to women’s repeatedly authenticated experience of the world. My essay traces through the literary and ideological processes of Candrāvatī’s poem its assault upon the chains that bind women as victims of justice perverted in the dominant Rāma legend. Whether and how far that assault also affects the integrity of religious faith lends a speculative edge to my enquiry.

Iterative-Taxis Intercategorial Interaction in German and Russian

The article features iterative-taxis categorical situations of simultaneity and non-simultaneity in German and Russian. The functional and semantic categories of taxis and iteration are closely interrelated. The intersection and syncretic unification of these functional-semantic categories makes it possible to define the model of their intercategorial interaction as a model of intercategorical crossing. Intercategorical crossing of taxis and iterative categories determines the actualization of various iterative-taxis categorical situations of simultaneity and non-simultaneity. They are actualized in iterative statements of various subtypes, e.g., verbal-iterative, deverbial-iterative, attributive-iterative, adverbial-iterative, etc., which contain iterative deverbatives, iterative verbs, and iterative quantifiers, i.e., attributes and adverbials. German and Russian proved to have such varieties of iterative-taxis categorial situations of simultaneity and non-simultaneity as (1) deverbative-iterative, (2) verbaliterative, and (3) adverbial-iterative and attributive-iterative. Actualization of certain iterative-taxis categorial situations of simultaneity and non-simultaneity depends on genetically-iterative, genetically-multiplicative, and word-formation-iterative deverbatives, as well as on iterative verbs of different semantics (actual iteratives, diminutives, multiplicatives, distributives, etc.) and iterative quantifiers (attributes and adverbials).

Numerical studies of steel pipe sheet pile

The sheet pile wall (SPW) is carried out from pipes of big diameter which plunge into soil very deeply. Depth of pipes is the settlement size depending on a set of parameters. Depth of pipes provides rigidity and reliability of a construction. SPW has a high rate of a consumption of steel on his production. Authors of the present article suggest to reduce a material capacity of SPW at the expense of reduction of depth of blockage of every second pipe. Decrease in depth of blockage of separate pipes is carried out at preservation of the maximum depth of blockage of other pipes. The design similar to a «comb» because of alternation of long and short pipes turns out. Such decision allows to reduce the total depth of blockage of pipes and as a result leads to decrease in a material capacity and cost of a construction in general. The problem of search of possible reduction of length of a part of pipes is the purpose of the real research. As solutions of the put problem we suggest to execute numerical experimenting in iterative statement with use of modern software. Results of numerical researches of SPW are presented in the present article. The presented results allow to draw a conclusion on efficiency of the solution on decrease in a material capacity of SPW proposed by authors. For obtaining the generalized decision and obtaining undoubtedly the best result of a design of SPW authors consider necessary to execute problem definition in the form of parametrical optimization.

Reconceptualising the notion of place in school geography

ABSTRACTOver the past two decades school geography in South Africa has undergone many changes to establish its own identity. Just as in the previous versions of the National Curriculum Statement, its new iteration, the Curriculum and Assessment Policy Statement (CAPS) (Department of Basic Education (DBE), 2011), has a strong environmental focus. Wilmot and Dube (2015) assert that more than 50% of the content in school geography is based on environment and sustainability learning. However, empirical evidence indicates that geography teachers in South Africa find it challenging to integrate an environmental focus and to implement enquiry and issue-based pedagogical approaches. We argue that one way of addressing this challenge might be through place-based education (PBE). The main purpose of this article is to explore PBE as a transformative educational avenue for broadening and enhancing the teaching and learning of school geography within a South African context. In order for PBE to be practiced meaningfully the notion of place needs to be strengthened in the CAPS specifically, and among teachers and the geography community generally.

Fault localization based on statement frequency

Spectrum-based automatic fault localization techniques play an important role in facilitating the quick and accurate localization of faults in programs. Unfortunately, since these techniques are based on the binary coverage information, counting only the coverage of statements in each execution and ignoring the statement frequency information, their diagnostic accuracies are inherently limited, especially when faults occur in the iteration statements or loop bodies. To address this problem, we introduce statement frequency conception into spectrum-based fault localization (SFL) and then propose a fault localization method based on statement frequency (FLSF). We also conduct a case study involving seven programs in Siemens suite and two risk evaluation formulas to compare the effectiveness of the proposed method against Tarantula. The experimental results show that our method outperforms Tarantula in most situations with regard to stability and effectiveness.

Sémantique des énoncés itératifs

This article is about the semantics of iterative statements, expressing repetition in time of a type-eventuality. With these statements are associated frequency properties, quantified by iterative adverbs (often, sometimes, sporadically, n times out of p…). Our purpose is to design a formal representation, with a method allowing to compute it from the text. The interpretation of an iterative statement closely relies on its information structure so that we first study precisely the topic-focus partition for a significant range of configurations. In the formal model, the occurrences of iterative eventualities or circumstants are represented by sequences of intervals. The temporal semantic of a sentence is then formalised as an instanciation of generic formulas using two types of generalised quantifiers.

Design and Implementation of Java Dynamic Testing Tool using Instrumentation

This work reports the design of Java Dynamic Testing tool by using Instrumentation, which is the statement inserted into the program to count the number of iteration process and conditional statement process in Java Programming by must not affecting the program behavior. In addition, it focuses on Java Source Instrumentation to count the number process of Iteration and conditional statement process by using three main approaches for designing this Dynamic Java Testing tool such as Java controller, Java Iteration and Iteration Counting Process. The Java Dynamic Testing by using Instrumentation is to give the engineer manager the report of counting iteration process which is the main key indicator of knowing the software cost and time as well as the input for estimating project effort which use to calculate productivity and other measurements.

State-cover testing for nondeterministic terminating concurrent programs with an infinite number of synchronization sequences

Concurrent programs exhibit nondeterministic behavior in that multiple executions thereof with the same input might produce different sequences of synchronization events and different results. This is because different executions of a concurrent program with the same input may exhibit different interleavings. Thus, one of the major issues in the testing of concurrent programs is how to explore different interleavings or exhaust all the possible interleavings of the target programs. However, for terminating concurrent programs that have cyclic state spaces due to using iterative statements such as busy-waiting loops, they might have an infinite number of feasible synchronization sequences; that is, there is an infinite number of possible interleavings, which makes it impossible to explore all the possible interleavings for this type of concurrent program. To overcome this problem, we propose a testing scheme called dynamic effective testing that can perform state-cover testing for nondeterministic terminating concurrent programs with an infinite number of synchronization sequences. Dynamic effective testing does not require static analysis of the target concurrent program or the assistance of a model checker, and thus is loosely coupled to the syntax of the target concurrent program. It only needs to analyze sequences of synchronization events produced by the execution of the concurrent programs for race detection and state-traversal control. Therefore, the method is easy to port to different programming languages. In addition, only reiterated states discovered in a single SYN-sequence need to be stored. The implementation and experimental results obtained with real code demonstrate that source-code-level dynamic testing can be systematically performed on nondeterministic concurrent programs with infinite synchronization sequences.

Induction-Oriented Verification of Replicated Architectures Described in VHDL

This paper is concerned with the application of theorem proving techniques to the formal proof of hardware. More precisely, we aim at providing a methodology for applying provers like Nqthm or Acl2 to the formal verification of parameterized replicated circuits. Nqthm (the Boyer–Moore theorem prover) and its successor Acl2 are induction-based systems; their formalisms are respectively a simplified Lisp-like language and Common Lisp. Hence, the circuits we consider must be given a purely functional representation. Moreover, our work puts the emphasis on the integration of formal proof techniques in CAD (Computer Aided Design) environments which support Hardware Description Languages in which replication is expressed by iteration. Therefore, we associate with the iterative statement of the VHDL language a functional semantics that guarantees an easy translation from VHDL to Nqthm/Acl2 while simplifying the subsequent inductive proofs. The approach has been successfully applied to one-dimensional as well as two-dimensional structures.

INDUCTION-ORIENTED VERIFICATION OF REPLICATED ARCHITECTURES DESCRIBED IN VHDL

This paper is concerned with the application of theorem proving techniques to the formal proof of hardware. More precisely, we aim at providing a methodology for applying provers like Nqthm or Acl2 to the formal verification of parameterized replicated circuits. Nqthm (the Boyer–Moore theorem prover) and its successor Acl2 are induction-based systems; their formalisms are respectively a simplified Lisp-like language and Common Lisp. Hence, the circuits we consider must be given a purely functional representation. Moreover, our work puts the emphasis on the integration of formal proof techniques in CAD (Computer Aided Design) environments which support Hardware Description Languages in which replication is expressed by iteration. Therefore, we associate with the iterative statement of the VHDL language a functional semantics that guarantees an easy translation from VHDL to Nqthm/Acl2 while simplifying the subsequent inductive proofs. The approach has been successfully applied to one-dimensional as well as two-dimensional structures.

Refinement of fair action systems

An action system is a framework for describing parallel or distributed systems, for which the refinement calculus offers a formalisation of the stepwise development method. Fairness is an important notion in modelling parallel or distributed systems, and this paper investigates a calculus for refinement of fair action systems. Simulations, which are proof techniques for refinement, are extended to verify fair action systems. Our work differs from others' in that the additional condition concerning fairness is expressed through termination of related iteration statements. For this purpose, existing proof rules for termination are extended. In the tradition of the refinement calculus, our approach to fairness is based on techniques developed mainly for sequential programming.

Evaluation and optimization of query programs in an object-oriented and symbolic information system

OASIS, a database programming environment that extends UNIX with the concept of persistent objects, is discussed. The OASIS query languages extend conventional database query languages with procedural methods and general control statements. As the complexity of the languages makes it difficult to device a query optimizer based on a universally applicable algorithm, each query in OASIS is optimized based on a collection of basic patterns for which each pattern is associated with a separation query optimization algorithm. The optimization techniques for a set of basic patterns consisting of iterative statements and a set of nested statements is described. The optimization techniques discussed include an extended decomposition algorithm, evaluation of multiple conditions, data dependence analysis, and optimization of queries with arbitrary nesting. >

Programming with streams in a Pascal-like language

A description is given of features which were added to a conventional programming language that will manipulate streams of values. A stream is a sequence of values of a certain fixed type. The number of elements of a stream may be determined at execution time, and evaluation of each element can be postponed until its value is actually needed. Many programs can be expressed naturally and clearly as networks of processes communicating by means of streams. The network is called a composite function and consists of several component functions. Since component functions are connected solely by streams, they greatly increase the flexibility of combinations and the reusability of programs. Loop statements can be considered as iterative statements over streams. One general problem in these networks is the mechanism of terminating each process of the network. A practical solution for this problem is presented. Comparisons to other programming styles, such as coroutines, Lisp, functional programming, and dataflow languages, are described. Three modes of execution are considered for the implementation of composite functions: parallel mode, coroutine mode, and inline mode. In the inline mode, a composite function is expanded and transformed into a single function, realizing maximum run-time efficiency. Algorithms for this expansion are given. >

Distributed cooperation with action systems

Action systems provide a method to program distributed systems that emphasizes the overall behavior of the system. System behavior is described in terms of the possible interactions (actions) that the processes can engage in, rather than in terms of the sequential code that the processes execute. The actions provide a symmetric communication mechanism that permits an arbitrary number of processes to be synchronized by a common handshake. This is a generalization of the usual approach, employed in languages like CSP and Ada, in which communication is asymmetric and restricted to involve only two processes. Two different execution models are given for action systems: a sequential one and a concurrent one. The sequential model is easier to use for reasoning, and is essentially equivalent to the guarded iteration statement by Dijkstra. It is well suited for reasoning about system properties in temporal logic, but requires a stronger fairness notion than it is reasonable to assume a distributed implementation will support. The concurrent execution model reflects the true concurrency that is present in a distributed execution, and corresponds to the way in which the system is actually implemented. An efficient distributed implementation of action systems on a local area network is described. The fairness assumptions of the concurrent model can be guaranteed in this implementation. The relationship between the two execution models is studied in detail in the paper. For systems that will be called fairly serializable, the two models are shown to be equivalent. Proof methods are given for verifying this property of action systems. It is shown that for fairly serializable systems, properties that hold for any concurrent execution of the system can be established by temporal proofs that are conducted entirely within the simpler sequential execution model.

The robust implementation of sequence‐controlled iteration

AbstractMany Pascal compilers generate incorrect code for statements. The trap that catches many implementors, whereby overflow is generated incorrectly, is explained and means for avoiding it are discussed (with attention to cost). Most common languages have a similar construct in which iteration is ‘controlled’ by a sequence of values in that a variable takes on successive values of the sequence for the several executions of the ‘body’. Often, the size step is not restricted to plus‐or‐minus one (as in Pascal) and the correctness situation cannot be characterized in such black and white terms. Typically, there is a range of behaviours that are valid and the compiler writer is able to choose a compromise between time‐space overheads and avoidance of unnecessary overflow indications; we describe the latter behaviour as robust. We present techniques for implementation appropriate to several languages and direct comments at language designers warning against both ignoring and overestimating the cost of robustly implementing iteration statements with arbitrary step size. Lastly, we criticize the design of instructions available in some machines, ostensibly to support the implementation of such sequence controlled iteration statements.

ACM SIGPLAN history of programming languages conference ALGOL 60 language summary

The term ALGOL is reported to have sprung from “ALGOrithmic Language”. Many forget, however, that ALGOL is the second brightest star in the constellation Perseus and part of an eclipsing binary. ALGOL exhibits a variation in light, which is caused by the fact that once every 69-odd hours it is partially eclipsed by a dark body, its partner star, for about 10 hours. But note that ALGOL always manages to regain its brilliance. ALGOL and its eclipsing companion (could it be FORTRAN?) are miles and miles apart (about 6,000,000). ALGOL 60 and FORTRAN are both algebraic languages designed primarily for writing programs to solve numerical problems. Both have simple variables and arrays, declarations, assignment statements, conditional and iterative statements, and procedures (subroutines).

Abstraction and verification in Alphard

The Alphard “form” provides the programmer with a great deal of control over the implementation of abstract data types. In this paper the abstraction techniques are extended from simple data representation and function definition to the iteration statement, the most important point of interaction between data and the control structure of the language itself. A means of specializing Alphard's loops to operate on abstract entities without explicit dependence on the representation of those entities is introduced. Specification and verification techniques that allow the properties of the generators for such iterations to be expressed in the form of proof rules are developed. Results are obtained that for common special cases of these loops are essentially identical to the corresponding constructs in other languages. A means of showing that a generator will terminate is also provided.

A new data structure — the grid

Grids are arrays that can have any shape. Grid elements need not be contiguous i.e. grids can have holes in them. For example, grids can be trapezoidal, parabolic, rectangular with a hole, or pyramid-like. Programs written using grids and the grid iteration statement are more general than those written using arrays and/or functions to simulate non-array shapes. To alter an existing program to work for another grid shape, one need only modify the grid declaration suitably, leaving the rest of the program intact. Programs are smaller, semantically clearer and have a more natural problem representation. Grids may be used to represent sparse matrices. Using Fortran as the base language, we show by means of examples from numerical analysis and engineering that the use of grids simplifies programming considerably. Efficient ways of implementing grids are discussed. Grids have been implemented as an extension to Fortran.

A lambda-calculus model of programming languages—II. Jumps and procedures

The correspondence between programming languages and the lambda-calculus presented in Part I of the paper is extended here to include iteration statements, jumps, and procedures. Programs containing loops are represented by lambda-expressionswhose components are specified recursively by means of systems of simultaneous conversion relations. The representation of call-by-name and side-effects in a program is accomplished without any resort to the concepts of memory and address by making use of a number of variables in addition to those declared by the programs; with the aid of these additional variables, the parameter linkage operations can be simulated by pure substitution. The applicability of the model to the problems of proving program correctness and equivalence is demonstrated by means of examples.

Fen—an axiomatic basis for program semantics

A formal system is presented which abstracts the notions of data item, function, and relation. It is argued that the system is more suitable than set theory (or its derivatives) for the concise and accurate description of program semantics. It is shown how the system can be used to build composite data types out of simpler ones with the operations of rowing, structuring, and uniting. It is also demonstrated that completely new primitive types can be introduced into languages through the mechanism of singleton data types. Both deterministic and nondeterministic functions are shown to be definable in the system. It is described how the local environment can be modeled as a data item and how imperative statements can be considered functions on the environment. The nature of recursive functions is briefly discussed, and a technique is presented by which they can be introduced into the system. The technique is contrasted with the use of the paradoxical combinator, Y . The questions of local and global environments and of various modes of function calling and parameter passing are touched upon. The theory is applied to the proof of several elementary theorems concerning the semantics of the assignment, conditional, and iterative statements. An appendix is included which presents in detail the formal system governing webs and fen , the abstractions used informally in the body of the paper.