OpenRaiser/Intern-Atlas huggingface dataset:
Modelling of the gravity compensators in robotic manufacturing cells
Venue: arXiv cs.RO 2013
Year: 2013

The paper deals with the modeling and identification of the gravity compensators used in heavy industrial robots. The main attention is paid to the geometrical parameters identification and calibration accuracy. To reduce impact of the measurement errors, the design of calibration experiments is used. The advantages of the developed technique are illustrated by experimental results
Detection of Partially Visible Objects
Venue: arXiv cs.CV 2013
Year: 2013

An "elephant in the room" for most current object detection and localization methods is the lack of explicit modelling of partial visibility due to occlusion by other objects or truncation by the image boundary. Based on a sliding window approach, we propose a detection method which explicitly models partial visibility by treating it as a latent variable. A novel non-maximum suppression scheme is proposed which takes into account the inferred partial visibility of objects while providing a globally optimal solution. The method gives more detailed scene interpretations than conventional detectors in that we are able to identify the visible parts of an object. We report improved average precision on the PASCAL VOC 2010 dataset compared to a baseline detector.
Random Residue Sequences and the Number Theoretic Hilbert Transform
Venue: arXiv cs.CR 2013
Year: 2013

This paper presents random residue sequences derived from the number theoretic Hilbert (NHT) transform and their correlation properties. The autocorrelation of a NHT derived sequence is zero for all non-zero shifts which illustrates that these are self-orthogonal sequences. The cross correlation function between two sequences may be computed with respect to the moduli of the either sequence. There appears to be some kind of an inverse qualitative relationship between these two different computations for many sets of residue sequences.
A UML-based Approach to Design Parallel and Distributed Applications
Venue: arXiv cs.SE 2013
Year: 2013

Parallel and distributed application design is a major area of interest in the domain of high performance scientific and industrial computing. Over the years, various approaches have been proposed to aid parallel program developers to modeling their applications. In this paper it will be used some concepts from agile development methodologies and Unified Modeling Language (UML) to modeling parallel and distributed applications. The UML-based approach of this paper describes through different artifacts and graphs the main flows of events in the development of parallel and high performance applications. Here, we presented three work flows to describe and to model our parallel program, Domain Model, Design and Modeling and Test. All these phases of the development software allow to programmers convert the requirements of the problem in a good and efficient solution.
Introduction to Neutrosophic Measure, Neutrosophic Integral, and Neutrosophic Probability
Venue: arXiv cs.AI 2013
Year: 2013

In this paper, we introduce for the first time the notions of neutrosophic measure and neutrosophic integral, and we develop the 1995 notion of neutrosophic probability. We present many practical examples. It is possible to define the neutrosophic measure and consequently the neutrosophic integral and neutrosophic probability in many ways, because there are various types of indeterminacies, depending on the problem we need to solve. Neutrosophics study the indeterminacy. Indeterminacy is different from randomness. It can be caused by physical space materials and type of construction, by items involved in the space, etc.
Formal Verification of `Programming to Interfaces' Programs
Venue: arXiv cs.LO 2013
Year: 2013

This paper presents a formal approach to specify and verify object-oriented programs written in the `programming to interfaces' paradigm. Besides the methods to be invoked by its clients, an interface also declares a set of abstract function/predicate symbols, together with a set of constraints on these symbols. For each method declared in this interface, a specification template is given using these abstract symbols. A class implementing this interface can give its own definitions to the abstract symbols, as long as all the constraints are satisfied. This class implements all the methods declared in the interface such that the method specification templates declared in the interface are satisfied w.r.t. the definitions of the abstract function symbols in this class. Based on the constraints on the abstract symbols, the client code using interfaces can be specified and verified precisely without knowing what classes implement these interfaces. Given more information about the implementing classes, the specifications of the client code can be specialized into more precise ones without re-verifying the client code. Several commonly used interfaces and their implementations (including Iterator, Observer, Comparable, and Comparator) are used to demonstrate that the approach in this paper is both precise and flexible.
ADMM Algorithm for Graphical Lasso with an $\ell_{\infty}$ Element-wise Norm Constraint
Venue: arXiv cs.LG 2013
Year: 2013

We consider the problem of Graphical lasso with an additional $\ell_{\infty}$ element-wise norm constraint on the precision matrix. This problem has applications in high-dimensional covariance decomposition such as in \citep{Janzamin-12}. We propose an ADMM algorithm to solve this problem. We also use a continuation strategy on the penalty parameter to have a fast implemenation of the algorithm.
QoS Based Framework for Effective Web Services in Cloud Computing
Venue: arXiv cs.DC 2013
Year: 2013

Enhancements in technology always follow Consumer requirements. Consumer requires best of service with least possible mismatch and on time. Numerous applications available today are based on Web Services and Cloud Computing. Recently, there exist many Web Services with similar functional characteristics. Choosing a right Service from group of similar Web Service is a complicated task for Service Consumer. In that case, Service Consumer can discover the required Web Service using non functional attributes of the Web Services such as QoS. Proposed layered architecture and Web Service Cloud i.e.WS Cloud computing Framework synthesizes the Non functional attributes that includes reliability, availability, response time, latency etc. The Service Consumer is projected to provide the QoS requirements as part of Service discovery query. This framework will discover and filter the Web Services form the cloud and rank them according to Service Consumer preferences to facilitate Service on time.
Finding a Maximum Clique using Ant Colony Optimization and Particle Swarm Optimization in Social Networks
Venue: arXiv cs.SI 2013
Year: 2013

Interaction between users in online social networks plays a key role in social network analysis. One on important types of social group is full connected relation between some users, which known as clique structure. Therefore finding a maximum clique is essential for some analysis. In this paper, we proposed a new method using ant colony optimization algorithm and particle swarm optimization algorithm. In the proposed method, in order to attain better results, it is improved process of pheromone update by particle swarm optimization. Simulation results on popular standard social network benchmarks in comparison standard ant colony optimization algorithm are shown a relative enhancement of proposed algorithm.
Improving CASA Runtime Performance by Exploiting Basic Feature Model Analysis
Venue: arXiv cs.SE 2013
Year: 2013

In Software Product Line Engineering (SPLE) families of systems are designed, rather than developing the individual systems independently. Combinatorial Interaction Testing has proven to be effective for testing in the context of SPLE, where a representative subset of products is chosen for testing in place of the complete family. Such a subset of products can be determined by computing a so called t-wise Covering Array (tCA), whose computation is NP-complete. Recently, reduction rules that exploit basic feature model analysis have been proposed that reduce the number of elements that need to be considered during the computation of tCAs for Software Product Lines (SPLs). We applied these rules to CASA, a simulated annealing algorithm for tCA generation for SPLs. We evaluated the adapted version of CASA using 133 publicly available feature models and could record on average a speedup of $61.8\%$ of median execution time, while at the same time preserving the coverage of the generated array.
Zak transforms and Gabor frames of totally positive functions and exponential B-splines
Venue: arXiv cs.IT 2013
Year: 2013

We study totally positive (TP) functions of finite type and exponential B-splines as window functions for Gabor frames. We establish the connection of the Zak transform of these two classes of functions and prove that the Zak transforms have only one zero in their fundamental domain of quasi-periodicity. Our proof is based on the variation-diminishing property of shifts of exponential B-splines. For the exponential B-spline B_m of order m, we determine a large set of lattice parameters a,b>0 such that the Gabor family of time-frequency shifts is a frame for L^2(R). By the connection of its Zak transform to the Zak transform of TP functions of finite type, our result provides an alternative proof that TP functions of finite type provide Gabor frames for all lattice parameters with ab<1. For even two-sided exponentials and the related exponential B-spline of order 2, we find lower frame-bounds A, which show the asymptotically linear decay A (1-ab) as the density ab of the time-frequency lattice tends to the critical density ab=1.
Super-polylogarithmic hypergraph coloring hardness via low-degree long codes
Venue: arXiv cs.CC 2013
Year: 2013

We prove improved inapproximability results for hypergraph coloring using the low-degree polynomial code (aka, the 'short code' of Barak et. al. [FOCS 2012]) and the techniques proposed by Dinur and Guruswami [FOCS 2013] to incorporate this code for inapproximability results. In particular, we prove quasi-NP-hardness of the following problems on $n$-vertex hyper-graphs: * Coloring a 2-colorable 8-uniform hypergraph with $2^{2^{Ω(\sqrt{\log\log n})}}$ colors. * Coloring a 4-colorable 4-uniform hypergraph with $2^{2^{Ω(\sqrt{\log\log n})}}$ colors. * Coloring a 3-colorable 3-uniform hypergraph with $(\log n)^{Ω(1/\log\log\log n)}$ colors. In each of these cases, the hardness results obtained are (at least) exponentially stronger than what was previously known for the respective cases. In fact, prior to this result, polylog n colors was the strongest quantitative bound on the number of colors ruled out by inapproximability results for O(1)-colorable hypergraphs. The fundamental bottleneck in obtaining coloring inapproximability results using the low- degree long code was a multipartite structural restriction in the PCP construction of Dinur-Guruswami. We are able to get around this restriction by simulating the multipartite structure implicitly by querying just one partition (albeit requiring 8 queries), which yields our result for 2-colorable 8-uniform hypergraphs. The result for 4-colorable 4-uniform hypergraphs is obtained via a 'query doubling' method. For 3-colorable 3-uniform hypergraphs, we exploit the ternary domain to design a test with an additive (as opposed to multiplicative) noise function, and analyze its efficacy in killing high weight Fourier coefficients via the pseudorandom properties of an associated quadratic form.
Experimenting with BitTorrent on a Cluster: A Good or a Bad Idea?
Venue: arXiv cs.DC 2013
Year: 2013

Evaluation of large-scale network systems and applications is usually done in one of three ways: simulations, real deployment on Internet, or on an emulated network testbed such as a cluster. Simulations can study very large systems but often abstract out many practical details, whereas real world tests are often quite small, on the order of a few hundred nodes at most, but have very realistic conditions. Clusters and other dedicated testbeds offer a middle ground between the two: large systems with real application code. They also typically allow configuring the testbed to enable repeatable experiments. In this paper we explore how to run large BitTorrent experiments in a cluster setup. We have chosen BitTorrent because the source code is available and it has been a popular target for research. Our contribution is twofold. First, we show how to tweak and configure the BitTorrent client to allow for a maximum number of clients to be run on a single machine, without running into any physical limits of the machine. Second, our results show that the behavior of BitTorrent can be very sensitive to the configuration and we revisit some existing BitTorrent research and consider the implications of our findings on previously published results. As we show in this paper, BitTorrent can change its behavior in subtle ways which are sometimes ignored in published works.
Irreducibility is Minimum Synergy Among Parts
Venue: arXiv cs.IT 2013
Year: 2013

For readers already familiar with Partial Information Decomposition (PID), we show that PID's definition of synergy enables quantifying at least four different notions of irreducibility. First, we show four common notions of "parts" give rise to a spectrum of four distinct measures of irreducibility. Second, we introduce a nonnegative expression based on PID for each notion of irreducibility. Third, we delineate these four notions of irreducibility with exemplary binary circuits. This work will become more useful once the complexity community has converged on a palatable $\operatorname{I}_{\cap}$ or $\operatorname{I}_{\cup}$ measure.
Continuous Collision Detection for Composite Quadric Models
Venue: arXiv cs.GR 2013
Year: 2013

A composite quadric model (CQM) is an object modeled by piecewise linear or quadric patches. We study the continuous detection problem of a special type of CQM objects which are commonly used in CAD/CAM, that is, the boundary surfaces of such a CQM intersect only in straight line segments or conic curve segments. We present a framework for continuous collision detection (CCD) of this special type of CQM (which we also call CQM for brevity) in motion. We derive algebraic formulations and compute numerically the first contact time instants and the contact points of two moving CQMs in $\mathbb R^3$. Since it is difficult to process CCD of two CQMs in a direct manner because they are composed of semi-algebraic varieties, we break down the problem into subproblems of solving CCD of pairs of boundary elements of the CQMs. We present procedures to solve CCD of different types of boundary element pairs in different dimensions. Some CCD problems are reduced to their equivalents in a lower dimensional setting, where they can be solved more efficiently.
Energy Efficient Spectrum Sensing and Handoff Strategies in Cognitive Radio Networks
Venue: arXiv cs.NI 2013
Year: 2013

The limited spectrum resources and dramatic growth of high data rate communications have motivated opportunistic spectrum access using the promising concept of cognitive radio networks. Although this concept has emerged primarily to enhance spectrum utilization, the importance of energy consumption poses new challenges, because energy efficiency and communication performance can be at odds. In this paper, the existing approaches to energy efficiency spectrum sensing and handoff are classified. The tradeoff between energy consumption and throughput is established as function of the numerous design parameters of cognitive radio networks, both in the case of local and of cooperative spectrum sensing. It is argued that a number of important aspects still needs to be researched, such as fairness, dynamic behavior, reactive and proactive schemes for energy efficiency.
Hop and HipHop : Multitier Web Orchestration
Venue: arXiv cs.PL 2013
Year: 2013

Rich applications merge classical computing, client-server concurrency, web-based interfaces, and the complex time- and event-based reactive programming found in embedded systems. To handle them, we extend the Hop web programming platform by HipHop, a domain-specific language dedicated to event-based process orchestration. Borrowing the synchronous reactive model of Esterel, HipHop is based on synchronous concurrency and preemption primitives that are known to be key components for the modular design of complex reactive behaviors. HipHop departs from Esterel by its ability to handle the dynamicity of Web applications, thanks to the reflexivity of Hop. Using a music player example, we show how to modularly build a non-trivial Hop application using HipHop orchestration code.
A Framework for Genetic Algorithms Based on Hadoop
Venue: arXiv cs.NE 2013
Year: 2013

Genetic Algorithms (GAs) are powerful metaheuristic techniques mostly used in many real-world applications. The sequential execution of GAs requires considerable computational power both in time and resources. Nevertheless, GAs are naturally parallel and accessing a parallel platform such as Cloud is easy and cheap. Apache Hadoop is one of the common services that can be used for parallel applications. However, using Hadoop to develop a parallel version of GAs is not simple without facing its inner workings. Even though some sequential frameworks for GAs already exist, there is no framework supporting the development of GA applications that can be executed in parallel. In this paper is described a framework for parallel GAs on the Hadoop platform, following the paradigm of MapReduce. The main purpose of this framework is to allow the user to focus on the aspects of GA that are specific to the problem to be addressed, being sure that this task is going to be correctly executed on the Cloud with a good performance. The framework has been also exploited to develop an application for Feature Subset Selection problem. A preliminary analysis of the performance of the developed GA application has been performed using three datasets and shown very promising performance.
Approximation Algorithms for Non-Single-minded Profit-Maximization Problems with Limited Supply
Venue: arXiv cs.GT 2013
Year: 2013

We consider {\em profit-maximization} problems for {\em combinatorial auctions} with {\em non-single minded valuation functions} and {\em limited supply}. We obtain fairly general results that relate the approximability of the profit-maximization problem to that of the corresponding {\em social-welfare-maximization} (SWM) problem, which is the problem of finding an allocation $(S_1,\ldots,S_n)$ satisfying the capacity constraints that has maximum total value $\sum_j v_j(S_j)$. For {\em subadditive valuations} (and hence {\em submodular, XOS valuations}), we obtain a solution with profit $\OPT_\swm/O(\log c_{\max})$, where $\OPT_\swm$ is the optimum social welfare and $c_{\max}$ is the maximum item-supply; thus, this yields an $O(\log c_{\max})$-approximation for the profit-maximization problem. Furthermore, given {\em any} class of valuation functions, if the SWM problem for this valuation class has an LP-relaxation (of a certain form) and an algorithm "verifying" an {\em integrality gap} of $\al$ for this LP, then we obtain a solution with profit $\OPT_\swm/O(\al\log c_{\max})$, thus obtaining an $O(\al\log c_{\max})$-approximation. For the special case, when the tree is a path, we also obtain an incomparable $O(\log m)$-approximation (via a different approach) for subadditive valuations, and arbitrary valuations with unlimited supply. Our approach for the latter problem also gives an $\frac{e}{e-1}$-approximation algorithm for the multi-product pricing problem in the Max-Buy model, with limited supply, improving on the previously known approximation factor of 2.
The bitwise operations related to a fast sorting algorithm
Venue: arXiv cs.PL 2013
Year: 2013

In the work we discuss the benefit of using bitwise operations in programming. Some interesting examples in this respect have been shown. What is described in detail is an algorithm for sorting an integer array with the substantial use of the bitwise operations. Besides its correctness we strictly prove that the described algorithm works in time O(n). In the work during the realisation of each of the examined algorithms we use the apparatus of the object-oriented programming with the syntax and the semantics of the programming language C++.
Datom: Towards modular data management
Venue: arXiv cs.DB 2013
Year: 2013

Recent technology breakthroughs have enabled data collection of unprecedented scale, rate, variety and complexity that has led to an explosion in data management requirements. Existing theories and techniques are not adequate to fulfil these requirements. We endeavour to rethink the way data management research is being conducted and we propose to work towards modular data management that will allow for unification of the expression of data management problems and systematization of their solution. The core of such an approach is the novel notion of a datom, i.e. a data management atom, which encapsulates generic data management provision. The datom is the foundation for comparison, customization and re-usage of data management problems and solutions. The proposed approach can signal a revolution in data management research and a long anticipated evolution in data management engineering.
An NMF solution for the Flowgraphs case at the TTC 2013
Venue: arXiv cs.SE 2013
Year: 2013

Software systems are getting more and more complex. Model-driven engineering (MDE) offers ways to handle such increased complexity by lifting development to a higher level of abstraction. A key part in MDE are transformations that transform any given model into another. These transformations are used to generate all kinds of software artifacts from models. However, there is little consensus about the transformation tools. Thus, the Transformation Tool Contest (TTC) 2013 aims to compare different transformation engines. This is achieved through three different cases that have to be tackled. One of these cases is the Flowgraphs case. A solution has to transform a Java code model into a simplified version and has to derive control and data flow. This paper presents the solution for this case using NMF Transformations as transformation engine.
Solving the Class Diagram Restructuring Transformation Case with FunnyQT
Venue: arXiv cs.SE 2013
Year: 2013

FunnyQT is a model querying and model transformation library for the functional Lisp-dialect Clojure providing a rich and efficient querying and transformation API. This paper describes the FunnyQT solution to the TTC 2013 Class Diagram Restructuring Transformation Case. This solution and the GROOVE solution share the best overall solution award for this case.
Class Diagram Restructuring with GROOVE
Venue: arXiv cs.LO 2013
Year: 2013

This paper describes the GROOVE solution to the "Class Diagram Restructuring" case study of the Tool Transformation Contest 2013. We show that the visual rule formalism enables the required restructuring to be formulated in a very concise manner. Moreover, the GROOVE functionality for state space exploration allows checking confluence. Performance-wise, however, the solution does not scale well.
PN2SC Case Study: An EMF-IncQuery solution
Venue: arXiv cs.SE 2013
Year: 2013

The paper presents a solution for the Petri-Net to Statecharts case study of the Transformation Tool Contest 2013, using EMF-IncQuery and Xtend for implementing the model transformation.