Return Statement Research Articles

A Novel Example-Dependent Cost-Sensitive Stacking Classifier to Identify Tax Return Defaulters

Tax evasion refers to an entity indulging in illegal activities to avoid paying their actual tax liability. A tax return statement is a periodic report comprising information about income, expenditure, etc. One of the most basic tax evasion methods is failing to file tax returns or delay filing tax return statements. The taxpayers who do not file their returns, or fail to do so within the stipulated period are called tax return defaulters. As a result, the Government has to bear the financial losses due to a taxpayer defaulting, which varies for each taxpayer. Therefore, while designing any statistical model to predict potential return defaulters, we have to consider the real financial loss associated with the misclassification of each individual. This paper proposes a framework for an example-dependent cost-sensitive stacking classifier that uses cost-insensitive classifiers as base generalizers to make predictions on the input space. These predictions are used to train an example-dependent cost-sensitive meta generalizer. Based on the meta-generalizer choice, we propose four variant models used to predict potential return defaulters for the upcoming tax-filing period. These models have been developed for the Commercial Taxes Department, Government of Telangana, India. Applying our proposed variant models to GST data, we observe a significant increase in savings compared to conventional classifiers. Additionally, we develop an empirical study showing that our approach is more adept at identifying potential tax return defaulters than existing example-dependent cost-sensitive classification algorithms.

Name-based Approach to Identify Suspicious Return Statements

Identifier names account for 70 percent of source code in characters. Meaningful identifier names convey valuable natural language information of the corresponding software entities, and thus they can be exploited to analyse the program and comprehend the semantics of it. However, existing bug detection approaches often ignore such natural language information and semantics encoded in identifier names. To this end, we propose a name-based approach to identify suspicious return statements. The recent study suggests that source code elements are often lexically similar to their corresponding semantic related elements. Based on this assumption, we design a sequence of heuristic rules to determine whether the return statement of a given method matches the signature of it. Evaluations on 100 open-source Java projects suggest that the proposed approach detects 16 out of 60 real return bugs. The precision and recall of the proposed approach are 31% and 27%, respectively.

A formal actor-based model for streaming the future

Asynchronous Actor-based programming has gained increasing attention as a model of concurrency and distribution. The Abstract Behavioral Specification (ABS) language is an actor-based programming language that has been developed for both the modeling and formal analysis of distributed systems. In ABS, actors are modeled as concurrent objects that communicate by asynchronous method calls. Return values are also communicated asynchronously via return statements and so-called futures. Many modern distributed software applications require a form of continuous interaction between their components which consists of streaming data from a server to its clients. In this paper, we extend the ABS language in order to support the streaming of data. We introduce the notion of “future-based data streams” by augmenting the syntax, type system, and operational semantics of ABS. As a proof of concept, we further discuss a prototype implementation for supporting future-based data streams on top of ABS, and discuss the impact of the use of these data streams in ABS on the performance in the implementation of a distributed application for the generation of social networks.

“Religion” and Its Other

[Extract] Return Statements is a suggestive book, which opens more questions than it answers. The first sentence reads: “Most books are written with a clear statement in mind, usually in the space of a few years, as if to emulate a thought that unfolds as a continuous and unbroken element. This book is not among them.”1 I find it difficult to summarize Lambert’s main claims, but I take it that the book aims to stimulate reflection rather than resolve the issues it raises. In that spirit, this brief response continues the conversation Lambert has opened by sketching a question concerning the relation between religion and its other.

THE LEGISLATIVE VETO FROM THE PERSPECTIVE OF THE KOSOVO CONSTITUTION

The Constitution of Kosovo has established a number of mechanisms for the separation of powers and reciprocal checks and balances among which is the President’s authority to return legislation for reconsideration. However, the interaction between the President and the Assembly on matters confronting the legislative veto has unveiled a number of constitutional ambiguities and inconsistencies which rendered involvement of the Constitutional Court necessary to define further the constitutionally-contemplated powers of the President for returning legislation for reconsideration. The article analyses the Presidential legislative veto from the prospect of the 2008 Kosovo Constitution. Through constitutional interpretation and practical cases this article seeks to examine more closely the structural and the functional aspect of the Presidential legislative return statements in post-status Kosovo.

An Efficient Software Clone Detection System based on the Textual Comparison of Dynamic Methods and Metrics Computation

clone is a kind of software recycling that has a greater influence on the maintenance of huge software systems. The business services are provided by web applications that employ a combination of page design and language code scripting. Usually, code redundancy in applications result from copy and paste practices called code clones. Searching for software clones is the key objective of this research. The clone identification procedure which is introduced in this paper is a hybrid approach that depends on template conversion and metrics comparison. There are four phases involved in the proposed scheme, namely, input and pre-processing, template conversion, metrics computation and clone type detection. File integration, elimination of white noise and statement normalization are the steps involved in the pre-processing stage. The metrics that are calculated includes numerous lines of code, arguments, looping statements, return statements and conditional statements. The pairs that have identical characteristics during textual evaluation are termed as the clones. This method of clone detection seems to be less complex with better accuracy and efficiency in contrast to other existing methods. The performance analysis is made against the prevailing systems to show efficiency improvement obtained through this method. The implementations are carried out with the help of JAVA. Keywordsdetection, Template conversion, Metrics computation, File integration, Normalization.

On Block Structures in Quantum Computation

A block is a language construct in programming that temporarily enlarges the state space. It is typically opened by initialising some local variables, and closed via a return statement. The “scope” of these local variables is then restricted to the block in which they occur. In quantum computation such temporary extensions of the state space also play an important role. This paper axiomatises “logical” blocks in a categorical manner. Opening a block may happen via a measurement, so that the block captures the various possibilities that result from the measurement. Following work of Coecke and Pavlović we sho that von Neumann projective measurements can be described as an Eilenberg-Moore coalgebra of a comonad associated with a particular kind of block structure. Closing of a block involves a collapse of options. Such blocks are investigated in non-deterministic, probabilistic, and quantum computation. In the latter setting it is shown that there are two block structures in the category of C⁎-algebras, via copowers and via matrices.

Implementing the extended return statement for Ada 2005

Ada 2005 adds an important capability to the language by allowing the construction and return of an object of a limited type by a function. New syntax for an extended return statement was added to enhance this capability further. This capability to return newly constructed objects of a limited type from a function, when combined with the additional capability to use aggregates to construct objects of a limited type, goes a long way to making use of limited types far more friendly and effective. Although the extended return statement and the associated ability to construct and return objects of a limited type brings new power to Ada, it also brings new choices and challenges to the Ada compiler implementor, when trying to decide how best to implement this feature. This presentation will review some of these alternatives, and present a high-level description of one particular approach based on the notion of an object creation context (OCC) which is designed to minimize the complexity of the generated code while providing an efficient and flexible implementation.

Return on directors: maximizing return on investment in the board room

It’s relatively easy to measure the output of a light bulb. Simply flip the switch and see whether it lights up. For greater accuracy, use a light meter. Even the dimmest bulb can pass this test. The measurement task becomes infinitely more complex, though, when assessing the brightest lights of business: corporate directors. In the boardroom, measurement of individual directors and total board effectiveness is both lacking in depth and consistency. While the board might demand financial return statements on other corporate investments, it is a rare board that shines the same light on itself.

Firms' Off-Balance Sheet Financing: Evidence from their Book-Tax Reporting Differences

We examine large U.S. corporations' off-balance sheet financing over the period 1989-2001. We construct firm-level proxies of off-balance sheet debt by comparing firms' tax return vs. financial statement reporting for interest expense and debt. Our results indicate that firms' financial reporting motives significantly influence their use of off-balance sheet debt. In particular, firms report greater amounts of interest on their tax return than to shareholders and creditors when their S&P bond ratings are less favorable, they have higher existing book leverage, or they have a greater proportion of debt that must be renegotiated in the short term. These results suggest that firms with greater credit risks are more likely to use substantive off-balance sheet debt. In supplemental tests, we find some evidence that these financial reporting effects occurred primarily during 1994-1999. We also find within-firm effects that suggest changes in firms' reporting incentives impact their use of off-balance sheet debt.

Comparing Control Constructs by Double-Barrelled CPS

We investigate call-by-value continuation-passing style transforms that pass two continuations. Altering a single variable in the translation of λ-abstraction gives rise to different control operators: first-class continuationss dynamic controls and (depending on a further choice of a variable) either the \tt return statement of Cs or Landin's J-operator. In each case there is an associated simple typing. For those constructs that allow upward continuations, the typing is classical, for the others it remains intuitionistic, giving a clean distinction independent of syntactic details. Moreover, those constructs that make the typing classical in the source of the CPS transform break the linearity of continuation use in the target.

Comparing Control Constructs by Double-barrelled CPS Transforms

We investigate continuation-passing style transforms that pass two continuations. Altering a single variable in the translation of λ-abstraction gives rise to different control operators: first-class continuations; dynamic control; and (depending on a further choice of a variable) either the return statement of C; or Landin's J-operator. In each case there is an associated simple typing. For those constructs that allow upward continuations, the typing is classical, for the others it remains intuitionistic, giving a clean distinction independent of syntactic details.

Financial Measures in Nonprofit Organization Research: Comparing IRS 990 Return and Audited Financial Statement Data

The IRS 990 Return is becoming an increasingly prominent source of financial data underlying descriptions of the nonprofit sector and studies of nonprofit organizations. However, questions about the quality of the data continue to be of concern. This study of 350 nonprofit organizations investigates the adequacy, reliability, and appropriate interpretation of IRS 990 Return data through comparisons of selected entries with corresponding measures from each organization’s audited financial statements. Both quantitative and qualitative methods are used to examine and explain the consistency between the two data sources. The study concludes that the IRS 990 Return can be considered an adequate and reliable source of financial information for many types of investigations, but preparers and users of the data need a clearer understanding of its purposes to enable appropriate interpretations.

Continuations, functions and jumps

Practically all programming languages have some form of control structure or jumping. The more advanced forms of control structure tend to resemble function calls, so much so that they are usually not even described as jumps. Consider for example the library function exit in C. Its use is much like a function, in that it may be called with an argument; but the whole point of exit is of course that its behaviour is utterly non-functional, in that it jumps out of arbitrarily many surrounding blocks and pending function calls. Such a "non-returning function" or "jump with arguments" is an example of a continuation in the sense which we are interested in here.On the other hand, a simple but fundamental idea in compiling is that a function call is broken down into two jumps: one from the caller to the callee for the call itself, and another jump back from the callee to the caller upon returning. (The return statement in C is in fact listed among the "jump statements" [5].) This is most obvious for void-accepting and -returning functions, but it generalizes to other functions as well, if one is willing to understand "jump" in the broader sense of jump with arguments, i.e. continuation.In this view, then, continuations are everywhere. Continuations have been used in many different settings, in which they appear in different guises, ranging from mathematical functions to machine addresses. Rather than confine ourselves to a definition of what a continuation is, we will focus on continuation-passing style (CPS), as it brings out the commonalities. The CPS transform compresses a great deal of insight into three little equations in λ-calculus. Making sense of it intuitively, however, requires some background knowledge and a certain fluency. The purpose of this article, therefore, is to help the reader uncompress the CPS transform by way of a rational reconstruction from jumps.In the sequel, we will attempt to illustrate the correspondence between continuations and jumps (even in the guise of the abhorred goto). The intent is partly historical, to retrace some of the analysis of jumps that led to the discoveries of continuations. At the same time, the language of choice for many researchers during the (pre)history of continuations, ALGOL 60, is not so different from today's mainstream languages (i.e. C); we hope that occasional snippets of C may be more easily accessible to many readers than a functional language would be. So in each of the four sections (Sections 2-5 below) that make up the body of this paper, some C code will be used to give a naive but concrete example of the issue under consideration, before generalizing to a more abstract setting.

Procedures and atomicity refinement

The introduction of an early return from a (remote) procedure call can increase the degree of parallelism in a parallel or distributed algorithm modeled by an action system. We define a return statement for procedures in an action systems framework and show that it corresponds to carrying out an atomicity refinement.

Interactive control restructuring

An interactive algorithm for improving control flow is introduced. This algorithm has been implemented within the ENCORE re-engineering environment. The objective of the algorithm is to restructure input code so as to simplify the control flow. A key feature of the algorithm is that is permits user control during the restructuring. The algorithm also handles, in a natural manner, multiple return statements, multiple loop exits, multi-level loop exits and endless loops.

Computer Calculations Of Compressibility Of Natural Gas

Abstract An alternative method for the calculation of pseudo reduced compressibility of natural gas is presented. The method applies the definition of reduced compressibility (Equation Available In Full Paper), where both Pr and (Equation Available In Full Paper) are variables available as DR and DP in both the Dranchuk et al. and Dranchuk and Abou-Kassem Z-Jactor subroutines. This method is incorporated into these routines by adding a single FORTRAN statement CR = O.270/(DR*DP}before the RETURN statement. This method is suitable for computer and hand-held calculator applications. It produces the same reduced compressibility as other available methods but is computationally superior. Methodology The methods of calculating compressibility of natural gas are derived from the following relationship between C and Z: Equation (Available In Full Paper) Trube(1) presented a graphical correlation of cr as a function of Pr and Tr based on equation (2) using the Brown et al. (2) Z-factor chart. While this correlation is useful for hand calculation, it is not suited to computer usage. Mattar et al. (3) used the following expression for cr that was based on the manipulation of equation (2) Equation (Available In Full Paper) Although the last two methods are suited to computer usage; they require the Dranchuk et al.(4) Z-factor subroutine that calculates Z which in turn would be used to calculate Pro Both Z and P, are used in equations (2), (4), (5), (7) and (8). Close examination of the Dranchuk et al.(4) Z-factor routine reveals that this routine solves for Pr for a given Tr and Pr using the Newton-Raphson iteration. The form of the equation used is Equation (Available In Full Paper) The suggested approach is applicable to all equation-of-state based romines for calculating Z-factor (e.g. Hall and Yarborough(6), Dranchuk and Abou-Kassem(7). Because of the similarity between the Dranchuk et al. (4) equation and the Dranchuk and Abou-Kassem(7) equation (based on BWR EOS), and the wide-spread use of these two routines for predicting Z-factor, the following is an account of why and where to incorporate necessary modifications to calculate cr in both routines using the suggested approach. These two equations can be expressed in a general form as: Equation (Available In Full Paper) Finally, the numerator in the right-hand-side of equation (13) is represented by DP in these routines. Therefore, A statement for Cr that is based on equation (11), may be incorporated in both routines by inserting the following FORTRAN Statement before the RETURN statement: Equation (Available In Full Paper) The modified versions or both the Dranchuk el al. (4) and Dranchuk and Abou-Kassern(7) routines, which were tested and verified to reproduce the Mattar et al.(3) graphical correlation for er are presented in Appendix I and Appendix 2 respectively. The results of the various method considered in this paper are compared in Table 2 for T, = 1.05, l.5, 2.5 and 3.

Implications of structured programming for machine architecture

Based on an empirical study of more than 10,000 lines of program text written in a GOTO-less language, a machine architecture specifically designed for structured programs is proposed. Since assignment, CALL, RETURN, and IF statements together account for 93 percent of all executable statements, special care is given to ensure that these statements can be implemented efficiently. A highly compact instruction encoding scheme is presented, which can reduce program size by a factor of 3. Unlike a Huffman code, which utilizes variable length fields, this method uses only fixed length (1-byte) opcode and address fields. The most frequent instructions consist of a single 1-byte field. As a consequence, instruction decoding time is minimized, and the machine is efficient with respect to both space and time.

Remark on algorithm 24, regarding a very common violation of the Fortran standard

According to the Fortran standard, variables in a subprogram will become undefined at the execution of the RETURN statement, if they are not contained in the list of dummy arguments or in a common block.