Noreen Jamil

Extending Linear Relaxation for User Interface Layout

Linear relaxation is a common method for solving linear problems as they occur in science and engineering. In contrast to direct methods such as Gauss-elimination or QR-factorization, linear relaxation is inherently efficient for problems with sparse matrices as they are often encountered, for instance, in the application domain of constraint-based UI layout. However, the linear relaxation method as described in the literature has its limitations: it works only with square matrices and does not support soft constraints, which makes it inapplicable to the UI layout problem. In this paper we extend linear relaxation to non-square matrices and soft constraints, and identify pivot assignment as the major issue to overcome in this process. We propose two algorithms for pivot assignment: random pivot assignment, and a more complex deterministic pivot assignment algorithm. Compared to the standard pivot assignment, which selects the elements on the diagonal of the problem matrix as pivot elements, these algorithms make the solving process more robust and make it possible to solve non-square matrices. Furthermore, we propose two algorithms for solving specifications containing soft constraints: constraint insertion and constraint removal. With these algorithms, it is possible to prioritize constraints. That is, if there are conflicting constraints in a specification as is commonly the case for UI layout, only the constraints with lower priority are violated to resolve the conflict. The performance and convergence of the proposed algorithms are evaluated empirically using randomly generated UI layout specifications of various sizes. The results show that our best linear relaxation algorithm performs significantly better than that of LP-Solve, which is a well-known efficient linear programming solver, and QR-decomposition.

Kaczmarz Algorithm with Soft Constraints for User Interface Layout

The Kaczmarz method is an iterative method for solving large systems of equations that projects iterates orthogonally onto the solution space of each equation. In contrast to direct methods such as Gaussian elimination or QR-factorization, this algorithm is efficient for problems with sparse matrices, as they appear in constraint-based user interface (UI) layout specifications. However, the Kaczmarz method as described in the literature has its limitations: it considers only equality constraints and does not support soft constraints, which makes it inapplicable to the UI layout problem. In this paper we extend the Kaczmarz method for solving specifications containing soft constraints, using the prioritized IIS detection algorithm. Furthermore, the performance and convergence of the proposed algorithms are evaluated empirically using randomly generated UI layout specifications of various sizes. The results show that these methods offer improvements in performance over standard methods like Matlabs LINPROG, a well-known efficient linear programming solver.

Extending linear relaxation for non-square matrices and soft constraints

Linear relaxation is a common method for solving linear problems, as they occur in science and engineering. In contrast to direct methods such as Gauss-elimination or QR-factorization, linear relaxation is particularly efficient for problems with sparse matrices, as they appear in constraint-based user interface (UI) layout specifications. However, the linear relaxation method as described in the literature has its limitations: it works only with square matrices and does not support soft constraints, which makes it inapplicable to the UI layout problem.To overcome these limitations we propose two algorithms for selecting the pivot elements used during linear relaxation: random pivot assignment, and a more complex deterministic pivot assignment. Furthermore, we propose three algorithms for solving specifications containing soft constraints: prioritized IIS detection, prioritized deletion filtering and prioritized grouping constraints. With these algorithms, it is possible to prioritize constraints: if there are conflicting constraints in a specification, as it is commonly the case for UI layout, only the constraints with lower priority are violated to resolve the conflicts.The performance and convergence of the proposed algorithms are evaluated empirically using randomly generated UI layout specifications of various sizes. The results show that our best linear relaxation algorithm performs significantly better than Matlabs LINPROG, a well-known efficient linear programming solver.

Hildreth's algorithm with applications to soft constraints for user interface layout

Hildreths algorithm is a row action method for solving large systems of inequalities. This algorithm is efficient for problems with sparse matrices, as opposed to direct methods such as Gaussian elimination or QR-factorization. We apply Hildreths algorithm, as well as a randomized version, along with prioritized selection of the inequalities, to efficiently detect the highest priority feasible subsystem of equations. We prove convergence results and feasibility criteria for both cyclic and randomized Hildreths algorithm, as well as a mixed algorithm which uses Hildreths algorithm for inequalities and Kaczmarz algorithm for equalities. These prioritized, sparse systems of inequalities commonly appear in constraint-based user interface (UI) layout specifications. The performance and convergence of these proposed algorithms are evaluated empirically using randomly generated UI layout specifications of various sizes. The results show that these methods offer improvements in performance over standard methods like Matlabs LINPROG, a well-known efficient linear programming solver, and the recent developed Kaczmarz algorithm with prioritized IIS detection.

A refinement of an iterative orthogonal projection method

Abstract The Kaczmarz algorithm is an iterative orthogonal projection method for solving linear systems of equations. As compared to direct methods such as Gaussian elimination or sparse QR-factorization, this algorithm is efficient for problems with sparse matrices, as they appear in constraint-based User Interface (UI) layout specifications. We present a variant of the Kaczmarz method for solving non-square systems that can be applied to Graphical User Interface (GUI) layout problems. In its original form the Kaczmarz algorithm cannot handle soft constraints. Therefore, we propose two algorithms for handling specifications containing soft constraints using prioritized irreducible infeasible subsystem (IIS) detection and prioritized grouping constraints. If we use Kaczmarz during resizing of a window in a GUI then the system can also be under-determined. In this case, space is not distributed in an aesthetically pleasing way. To distribute the space according to the preferred size of the layout, we introduce the least squares Kaczmarz method to get the desired results. The performance and convergence of the proposed algorithms are evaluated empirically using randomly generated UI layout specifications of various sizes. The results show that these methods outperform Matlab’s LINPROG, a well-known efficient linear programming solver.

Uncovering useful patterns in shopping cart data

Understanding the shopping and purchasing behaviours of customers is an essential task for business and retail organizations. While customers look for useful information from retailers as they shop, businesses seek to collect increasing amounts of data in order to deliver added value to their customers. This requires an intensive analysis of sales data. Extracting shopping patterns across the many levels of information is a non-trivial task as datasets on sales transactions can contain many levels of information such as item category, brand name, colour, and price. This paper examines the use of multi-level association rules to uncover purchasing patterns at multiple levels of detail. It shows how different kinds of purchasing patterns can emerge at different association levels of analysis. This type of analysis is indeed helpful in assisting retailers to make wise decisions for their customers.

A Cached-Based Stream-Relation Join Operator for Semi-Stream Data Processing

Stream-based join algorithms got a prominent role in the field of real-time data warehouses. One particular type of stream-based joins is a semi-stream join where a single stream is joined with a disk -based relation. Normally the size of this disk-based relation is large enough and cannot be fit into memory, available for join operator. Therefore, the relation is loaded into memory in partitions. A well-known join algorithm called MESHJOIN Mesh Join has been presented in the literature to process semi-stream data. However, the algorithm has some limitations. In particular, MESHJOIN does not consider the characteristics of stream data and therefore does not perform well for skewed stream data. This article introduces the concept of caching and based on that presents a novel algorithm called Cached-based Stream-Relation Join CSRJ. The algorithm exploits skewed distributions more appropriately, and the authors present results for Zipfian distributions of the type that appear in many applications. They test their algorithm using synthetic, TPC-H and real datasets. Their experiments show that CSRJ forms significantly better than MESHJOIN. They also drive the cost model for their algorithm and based on that they tune the algorithm.

A Cached-based approach to enrich Stream data with master data

An enriching of stream data with disk-based master data is common in many applications. Real-time data warehousing is one of these applications where stream data is customers transactions producing by operational data source(s). This stream data needs to enrich by disk-based master data before loading this into the data warehouse. To implement this enrichment operation a join operator is required. Normally we call it semi-stream join as it is performed between stream data and disk data. The join operator typically works under limited main memory and this memory is generally not large enough to hold the whole disk-based master data. Therefore, the relation is loaded into memory in partitions. A well-known join algorithm called MESHJOIN (Mesh Join) has been presented in the literature to implement the semi-stream join operation. However, the algorithm suffers with some limitations. In particular, the algorithm can be improved based on the characteristics of stream data e.g. skew in stream data. In this paper we address this issue by presenting a novel algorithm called Cached-based Stream-Disk Join (CSDJ). The algorithm exploits skew characteristic in stream data more appropriately and over performs existing MESHJOIN. We present results for Zip-fian distributions of the type that appear in many applications. We evaluate our algorithm using synthetic, TPC-H and real datasets. Our experiments show that CSDJ performs significantly better than MESHJOIN.

A Cache-Based Semi-Stream Join to deal with Unmatched Stream Data

In Data Stream Management System (DSMS) semi-stream processing has become a popular area of research due to the high demand of applications (e.g. real-time data warehousing) for up-to-date information. One common operation in semi-stream processing is joining of incoming stream with disk-based master data. A recent algorithm called CACHEJOIN was proposed to implement this join operation. However, CACHEJOIN loads entire stream data into join module and consumes all its resources without eliminating those stream tuples which have no relevant tuples in disk-based master data. Due to this, the performance of CACHEJOIN remains suboptimal. In this paper we present a revised version of CACHEJOIN called Improved CACHEJOIN which removes this limitation. This reduces the processing cost for the new algorithm and as a consequence, the new algorithm outperforms existing CACHEJOIN significantly. In order to quantify the performance differences, we compare both algorithms using both synthetic and real datasets with a known skewed distribution. We also present the cost model for our new algorithm.

Speeding up SOR solvers for constraint-based GUIs with a warm-start strategy

Many computer programs have graphical user interfaces (GUIs), which need good layout to make efficient use of the available screen real estate. Most GUIs do not have a fixed layout, but are resizable and able to adapt themselves. Constraints are a powerful tool for specifying adaptable GUI layouts: they are used to specify a layout in a general form, and a constraint solver is used to find a satisfying concrete layout, e.g. for a specific GUI size. The constraint solver has to calculate a new layout every time a GUI is resized or changed, so it needs to be efficient to ensure a good user experience. One approach for constraint solvers is based on the Gauss-Seidel algorithm and successive over-relaxation (SOR). Our observation is that a solution after resizing or changing is similar in structure to a previous solution. Thus, our hypothesis is that we can increase the computational performance of an SOR-based constraint solver if we reuse the solution of a previous layout to warm-start the solving of a new layout. In this paper we report on experiments to test this hypothesis experimentally for three common use cases: big-step resizing, small-step resizing and constraint change. In our experiments, we measured the solving time for randomly generated GUI layout specifications of various sizes. For all three cases we found that the performance is improved if an existing solution is used as a starting solution for a new layout.