DOCSLIB.ORG

Exercise #5 – Extended Lab Proposal and Exploratory Coding

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Exercise #5 – Extended Lab Proposal and Exploratory Coding Exercise #5 – Extended Lab Proposal and Exploratory Coding DUE: As indicated on Canvas Please read Chapter 10 and Chapter 11 in Programming Language Pragmatics. The goal of this lab is to expose you to alternative programming paradigms including functional programming with Lisp and declarative programming with Prolog. The idea is that with this exploratory programming, you can then choose and in-depth comparative programming algorithm study. Once you have done this, then I’d like to you choose an algorithms from your data structures, algorithms and general programming experience to explore with your native imperative procedural (perhaps also object oriented) programming language of choice and in a new language that uses an alternate paradigm by comparison (see language types on page 11 of PLP for review). Alternative languages you can choose from include: R, Halide, Lisp, Scheme, Java, Python and Prolog (or other with instructor approval) and Primary languages to compare to can include: C/C++, Ada83, Ada95, and MATLAB that are taught in the SWE program. So, choose TWO programming languages and ONE example to compare from the following: 1. Concurrency – Use a library for concurrency in C/C++ like POSIX threads (simple example) or OpenMP and compare to language supported concurrency in Java or Ada95. Tale a simple example like this one for Sieve of Eratosthenes (simple single thread and more complex threaded C code) and compare with language supported concurrency and take a position on which is better and substantiate with performance, ease of programming, maintainability, etc. (in Lab #6). Other options are even simpler initial exploration through Fibonacci (single thread, multi-thread, and functional). 2. Functional Programming with Lisp – Compare functional programming for a data structure and algorithm you know that is reasonably complex (e.g. a binary tree with insert, delete and search) and implement in Java/C++ and Lisp and compare. Use GNU Common Lisp on Virtual-Box Linux as we’ll learn in this lab. 3. Declarative Programming with Prolog – Compare declarative programming for a logical problem such as feasibility in discrete mathematics or within a rule and fact system of your own devising. One interesting feasibility problem from discrete mathematics worthy of consideration is proving that a real-time schedule is feasible. 4. Scripting with R – Use “R” as we did in Exercise #1, but to explore a complex set of equations similar to Lorenz or real data from the Internet gathered by Google or others to analyze large and/or non-linear data models and to make use of 3-D plotting and analysis – e.g. use Regula Falsi to find the root of a complex function (e.g. polynomials, the Lorenz equations, etc.). 5. Dataflow programming with Halide – Use Halide for image processing and transformation and compare to alternatives like GIMP (sudo apt-get install gimp) and OpenCV (build opencv on Linux, install on Windows, sudo apt-get install libopencv-dev for quick install on Linux) for image processing tasks such as scaling an image, converting a color image to a graymap, etc. Note that at ERAU we have opencv installed on all of the Sims & Games computers in Building 61 as well and you can use that lab if you wish. 6. Make up your Own (get approved) e.g. I want to implement a dictionary-based spell checker in both Lisp and Java and compare best known data structure and algorithm implementation in each or I want to compare lossy image compression methods in Java and Halide. The point of this assignment is to explore implementation in the language you are most comfortable with as well as an alternative. If your outcome in Lab #5 is that it’s very awkward or implementation in the alternative is not possible, that’s ok (and interesting), but you’ll have to pick a project for Lab #6 that can be implemented in both and compare the two and make a case for one language or the other as “better” for implementation of the algorithm and data structures you choose to investigate. Exercise #5 Requirements: 1) [30 points] As a rapid introduction to Lisp programming, this exercise asks you to download, install, and start to use Lisp. a) [3 pts] First download and install GNU Common Lisp (sudo apt-get install gcl and sudo apt-get install gcl-doc) on Virtual-Box Ubuntu Linux as follows and show that you can reduce a simple expression with a screen-shot (e.g. (* 2 (cos 0) (+ 4 6)) => 20.0). Spend more time reading through Lisp tutorials and teaching yourself basics with Lisp. Alternatively, just use Steel Bank LISP on PRClab1 as described in class notes. b) [12 pts] Define the Fibonacci sequence as a recursive “defun” in Lisp (you may find this helpful) and enable tracing for you function fibonacci with “(trace fibonacci)”. Compute the Fibonacci sequence value for 3 and show a trace for this as a screen shot. Then, do a trace for 17 and capture this output to a file and count how many recursive calls are made and provide that number here. (Note: the Linux “script” command might be useful to capture all terminal input and output – as documented here and described here). c) [6 pts] Download the C, Java and C++ Fibonacci iterative and recursive implementations (found here as C, here as C++ and here as Java). Describe one advantage and disadvantage of each and then pick what you believe is the best of these three imperative procedural implementations and describe why. d) [9 pts] Compare to the Lisp implementation and take a position on whether Lisp and functional programming makes mathematics like sequences easier to understand and implement or not. You must provide at least 3 arguments in favor or against Lisp and support them with specific examples or observations from this quick study. 2) [15 points] Install SWI Prolog or gprolog on VB-Linux and prove that your installation works with a simple example rule/fact base and derivation, or use SWI Prolog on PRClab1 as described in class notes. a) [5 pts] Install SWI Prolog and documents or simply test use of Prolog as shown in class (/usr/local/gprolog-1.4.4/gprolog) on PRClab1 (for SWI Prolog on your own Linux machine use sudo apt-get install swi-prolog and sudo apt-get install swi-prolog-doc) and show a screen shot of the prolog interpreter. b) [10 pts] Enter 3 simple logic rules of your own creation (e.g. you could enter logical AND, OR and NOT types of rules for something like rules for SWE graduation) and some facts (derive whether a student can graduate based on facts given ERAU SWE rules or made up). Any example is acceptable as long as it uses at least 3 rules and 3 or more facts and you can run a derivation (see documentation) and learn by examples. 3) [15 points] Read our textbook, lecture notes, and supporting materials, consider example code, and choose an alternative PL comparison study topic that is ONE of the six example algorithm/application areas described in the introduction for this assignment: a) Concurrency b) Functional programming c) Declarative programming d) Scripting with “R” e) Dataflow programming with Halide f) Of your own creation Describe your selection and approach for comparison in good detail (several paragraphs with diagrams or examples). 4) [15 points] Write a 3 paragraph proposal for your comparative implementation proposal above that describes how you believe that one language or the other will provide a better implementation based on features that are: a) Optimal – describe how a programming language can provide improved performance, debug visibility or accuracy in the implementation and how you will verify this. b) Target – describe the expected basic features of the implementation in both languages (e.g. the implementation should be able to find all roots of any polynomial in bounded time to precision of 15 digits). c) Minimum – simple objectives that define basic success (both run and produce a result for 3 simple test cases). 5) [25 points] Develop a working proof-of-concept that shows that the application you propose is feasible in both your native imperative procedural programming language and the alternate. Provide make files, source code and details on how to run the alternate implementation (assume the reader is completely new to the alternate – e.g. tell them where to download the interpreter, how to install, and how to run your code). The code should convince you (and your instructor) that what you propose can be implemented. Report file MUST be separate from the ZIP file with code and other supporting materials. Grading Checklist [30 points] Introduction to Common Lisp: [3 pts] a) use screen shot__________________________________________________ [12 pts] b) recursive trace_________________________________________________ [6 pts] c) imperative compare______________________________________________ [9 pts] d) compare to Lisp_________________________________________________ [15 points] SWI Prolog introduction: [5 pts] screen shot of interpreter____________________________________________ [10 pts] 3 rules or more __________________________________________________ [15 points] Selection of alternate PL to study: [5 pts] selection ________________________________________________________ [10 pts] rationale_____ __________________________________________________ [15 points] Proposal for PL comparison: [5 pts] minimal objectives________________________________________________ [5 pts] target objectives __________________________________________________ [5 pts] goal objectives __________________________________________________ [25 points] Alternative PL Proof-of-concept __________________________________________ [5 pts] Code runs or builds__________________________________________________ [10 pts] Testing and demonstration___________________________________________ [10 pts] Concept __________________________________________________________ .
Load more

Recommended publications
  • GNU/Linux AI & Alife HOWTO
    GNU/Linux AI & Alife HOWTO GNU/Linux AI & Alife HOWTO Table of Contents GNU/Linux AI & Alife HOWTO......................................................................................................................1 by John Eikenberry..................................................................................................................................1 1. Introduction..........................................................................................................................................1 2. Symbolic Systems (GOFAI)................................................................................................................1 3. Connectionism.....................................................................................................................................1 4. Evolutionary Computing......................................................................................................................1 5. Alife & Complex Systems...................................................................................................................1 6. Agents & Robotics...............................................................................................................................1 7. Statistical & Machine Learning...........................................................................................................2 8. Missing & Dead...................................................................................................................................2 1. Introduction.........................................................................................................................................2
    [Show full text]
  • Bringing GNU Emacs to Native Code
    Bringing GNU Emacs to Native Code Andrea Corallo Luca Nassi Nicola Manca [email protected] [email protected] [email protected] CNR-SPIN Genoa, Italy ABSTRACT such a long-standing project. Although this makes it didactic, some Emacs Lisp (Elisp) is the Lisp dialect used by the Emacs text editor limitations prevent the current implementation of Emacs Lisp to family. GNU Emacs can currently execute Elisp code either inter- be appealing for broader use. In this context, performance issues preted or byte-interpreted after it has been compiled to byte-code. represent the main bottleneck, which can be broken down in three In this work we discuss the implementation of an optimizing com- main sub-problems: piler approach for Elisp targeting native code. The native compiler • lack of true multi-threading support, employs the byte-compiler’s internal representation as input and • garbage collection speed, exploits libgccjit to achieve code generation using the GNU Com- • code execution speed. piler Collection (GCC) infrastructure. Generated executables are From now on we will focus on the last of these issues, which con- stored as binary files and can be loaded and unloaded dynamically. stitutes the topic of this work. Most of the functionality of the compiler is written in Elisp itself, The current implementation traditionally approaches the prob- including several optimization passes, paired with a C back-end lem of code execution speed in two ways: to interface with the GNU Emacs core and libgccjit. Though still a work in progress, our implementation is able to bootstrap a func- • Implementing a large number of performance-sensitive prim- tional Emacs and compile all lexically scoped Elisp files, including itive functions (also known as subr) in C.
    [Show full text]
  • GNU MP the GNU Multiple Precision Arithmetic Library Edition 6.2.1 14 November 2020
    GNU MP The GNU Multiple Precision Arithmetic Library Edition 6.2.1 14 November 2020 by Torbj¨ornGranlund and the GMP development team This manual describes how to install and use the GNU multiple precision arithmetic library, version 6.2.1. Copyright 1991, 1993-2016, 2018-2020 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, with the Front-Cover Texts being \A GNU Manual", and with the Back-Cover Texts being \You have freedom to copy and modify this GNU Manual, like GNU software". A copy of the license is included in Appendix C [GNU Free Documentation License], page 132. i Table of Contents GNU MP Copying Conditions :::::::::::::::::::::::::::::::::::: 1 1 Introduction to GNU MP ::::::::::::::::::::::::::::::::::::: 2 1.1 How to use this Manual :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 2 2 Installing GMP ::::::::::::::::::::::::::::::::::::::::::::::::: 3 2.1 Build Options:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 3 2.2 ABI and ISA :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 8 2.3 Notes for Package Builds:::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 11 2.4 Notes for Particular Systems :::::::::::::::::::::::::::::::::::::::::::::::::::::: 12 2.5 Known Build Problems ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: 14 2.6 Performance
    [Show full text]
  • An Industrial Strength Theorem Prover for a Logic Based on Common Lisp
    An Industrial Strength Theorem Prover for a Logic Based on Common Lisp y z Matt Kaufmannand J Strother Moore Personal use of this material is permitted. particular style of formal veri®cation that has shown consid- However, permission to reprint/republish this erable promise in recent years is the use of general-purpose material for advertising or promotional pur- automated reasoning systems to model systems and prove poses or for creating new collective works for properties of them. Every such reasoning system requires resale or redistribution to servers or lists, or considerable assistance from the user, which makes it im- to reuse any copyrighted component of this portant that the system provide convenient ways for the user work in other works must be obtained from the to interact with it. IEEE.1 One state-of-the-art general-purpose automated reason- ing system is ACL2: ªA Computational Logic for Applica- AbstractÐACL2 is a re-implemented extended version tive Common Lisp.º A number of automated reasoning of Boyer and Moore's Nqthm and Kaufmann's Pc-Nqthm, systems now exist, as we discuss below (Subsection 1.1). In intended for large scale veri®cation projects. This paper this paper we describe ACL2's offerings to the user for con- deals primarily with how we scaled up Nqthm's logic to an venientªindustrial-strengthºuse. WebegininSection2with ªindustrial strengthº programming language Ð namely, a a history of theACL2 project. Next, Section 3 describes the large applicative subset of Common Lisp Ð while preserv- logic supportedby ACL2, which has been designed for con- ing the use of total functions within the logic.
    [Show full text]
  • Unix Quickref.Dvi
    Summary of UNIX commands Table of Contents df [dirname] display free disk space. If dirname is omitted, 1. Directory and file commands 1994,1995,1996 Budi Rahardjo ([email protected]) display all available disks. The output maybe This is a summary of UNIX commands available 2. Print-related commands in blocks or in Kbytes. Use df -k in Solaris. on most UNIX systems. Depending on the config- uration, some of the commands may be unavailable 3. Miscellaneous commands du [dirname] on your site. These commands may be a commer- display disk usage. cial program, freeware or public domain program that 4. Process management must be installed separately, or probably just not in less filename your search path. Check your local documentation or 5. File archive and compression display filename one screenful. A pager similar manual pages for more details (e.g. man program- to (better than) more. 6. Text editors name). This reference card, obviously, cannot de- ls [dirname] scribe all UNIX commands in details, but instead I 7. Mail programs picked commands that are useful and interesting from list the content of directory dirname. Options: a user's point of view. 8. Usnet news -a display hidden files, -l display in long format 9. File transfer and remote access mkdir dirname Disclaimer make directory dirname The author makes no warranty of any kind, expressed 10. X window or implied, including the warranties of merchantabil- more filename 11. Graph, Plot, Image processing tools ity or fitness for a particular purpose, with regard to view file filename one screenfull at a time the use of commands contained in this reference card.
    [Show full text]
  • The Embeddable Common Lisp
    ACM Lisp Pointers 8(1), 1995, 30-41 The Embeddable Common Lisp Giuseppe Attardi Dipartimento di Informatica, Universit`adi Pisa Corso Italia 40, I-56125 Pisa, Italy net: [email protected] Abstract The Embeddable Common Lisp is an implementation of Common Lisp designed for being embeddable within C based applications. ECL uses standard C calling conventions for Lisp compiled functions, which allows C programs to easily call Lisp functions and viceversa. No foreign function interface is required: data can be exchanged between C and Lisp with no need for conversion. ECL is based on a Common Runtime Support (CRS) which provides basic facilities for memory management, dynamic loading and dumping of binary images, support for multiple threads of execution. The CRS is built into a library that can be linked with the code of the application. ECL is modular: main modules are the program development tools (top level, debugger, trace, stepper), the compiler, and CLOS. A native implementation of CLOS is available in ECL: one can configure ECL with or without CLOS. A runtime version of ECL can be built with just the modules which are required by the application. 1 Introduction As applications become more elaborate, the facilities required to build them grow in number and sophistica- tion. Each facility is accessed through a specific package, quite complex itself, like in the cases of: modeling, simulation, graphics, hypertext facilities, data base management, numerical analysis, deductive capabilities, concurrent programming, heuristic search, symbolic manipulation, language analysis, special device control. Reusability is quite a significant issue: once a package has been developed, tested and debugged, it is un- desirable having to rewrite it in a different language just because the application is based in such other language.
    [Show full text]
  • GNU/Linux AI & Alife HOWTO
    GNU/Linux AI & Alife HOWTO GNU/Linux AI & Alife HOWTO Table of Contents GNU/Linux AI & Alife HOWTO......................................................................................................................1 by John Eikenberry..................................................................................................................................1 1. Introduction..........................................................................................................................................1 2. Traditional Artificial Intelligence........................................................................................................1 3. Connectionism.....................................................................................................................................1 4. Evolutionary Computing......................................................................................................................1 5. Alife & Complex Systems...................................................................................................................1 6. Agents & Robotics...............................................................................................................................1 7. Programming languages.......................................................................................................................2 8. Missing & Dead...................................................................................................................................2 1. Introduction.........................................................................................................................................2
    [Show full text]
  • Lisping Copyleft: a Close Reading of the Lisp LGPL 15
    Lisping Copyleft: A Close Reading of the Lisp LGPL 15 Lisping Copyleft: A Close Reading of the Lisp LGPL Eli Greenbaum a (a) Attorney, Yigal Arnon & Co. Jerusalem DOI: 10.5033/ifosslr.v5i1.75 Abstract: The idioms of both the General Public License (the “GPL”) and the Lesser General Public License (the “LGPL”) seem to be grounded in the C programming language. This article analyses the Lisp Lesser General Public License (colloquially and here referred to as the “LLGPL”), a specific attempt to apply the LGPL to a language with a programming paradigm and method of building and distributing programs that traditionally differs substantially from the approach of C. In addition, this article attempts to understand whether the LLGPL actually succeeds in its stated goal of translating the LGPL to the Lisp context or whether the LLGPL changes the requirements and philosophical moorings of the LGPL. Keywords: Law; information technology; Free and Open Source Software; copyleft, copyright; derivation; compilation; Lisp; LGPL; Introduction The idioms of both the General Public License (the “GPL”) and the Lesser General Public License 1 (the “LGPL”) seem to be grounded in the C programming language. The licenses refer to “compiling”, “linking” and “header files”, features of the C programming languages which may not be present in other languages that are not traditionally compiled. Similarly, the licenses do not expressly include provisions relating to features of object-oriented programming languages.2 Do the GNU licenses work as intended when applied in these other contexts? 3 This article analyses the Lisp 1 The LLGPL license is drafted as a preamble to version 2.1 of the LGPL.
    [Show full text]
  • Platform Freedom for a Graphical Lisp Application Through Armed Bear Common Lisp
    CARMA: Platform Freedom for a Graphical Lisp Application through Armed Bear Common Lisp John D. Hastings Alexandre V. Latchininsky Dept. of Computer Science Dept. of Renewable Resources University of Nebraska-Kearney University of Wyoming Kearney, NE, USA Laramie, WY, USA [email protected] [email protected] Abstract 1. Introduction CARMA is an advisory system that uses artificially- CARMA is an advisory system for grasshopper infesta- intelligent techniques including case-based reasoning tions that has been successfully used since 1996 (Hast- to provide advice about the most environmentally and ings, Branting, & Lockwood 2002). CARMA, short economically effective responses to grasshopper infes- for CAse-based Rangeland Management Advisor, em- tations. CARMA’s core AI reasoner was initially writ- ploys a variety of artificially-intelligent (AI) techniques ten in Common Lisp and integrated with an Allegro to provide advice about the most environmentally and Common Lisp for Windows graphical user interface economically effective responses to grasshopper infes- (GUI). CARMA went public in 1996 and has been tations. In the process, CARMA demonstrates an ap- used successfully since. Recently, CARMA’s architec- proach to providing advice concerning the behavior of ture was reworked in order to avoid periodic develop- a complex biological system by exploiting multiple, in- ment and deployment fees, and to produce a platform- dividually incomplete, knowledge sources (Hastings, independent system by following a philosophy called Branting, & Lockwood 1996) including utilization of a platform freedom which emphasizes freedom from technique known as approximate-model-based adapta- both platform dependence and software costs. The im- tion which integrates case-based reasoning with model- plementation also demonstrates an approach to creating based reasoning for the purposes of prediction within a Lisp application with an appealing GUI which is web complex physical systems.
    [Show full text]
  • 01}March 02} Issue Volume
    VolumeVolume 02}05} Issue 01}March 2013 Editorials Editorial 1 Daniel M. German Articles Copyleft, -right and the case law on APIs on both sides of the Atlantic 5 Walter van Holst Lisping Copyleft: A Close Reading of the Lisp LGPL 15 Eli Greenbaum Platform The Rise and Evolution of the Open Source Software Foundation 31 Paula Hunter, Stephen Walli Legislative Review FOSS in the Italian public administration: fundamental law principles 43 Simone Aliprandi, Carlo Piana Available online at: http://www.ifosslr.org Volume 02}05} Issue 01} March 2013 Editorial Committee !aniel German Daniel German is is Associate Professor, Computer Science, This publication is managed by a rotating Editorial Committee. University of Victoria. His main area of research is software The membership of the Committee for this issue is as follows: engineering. In particular, software evolution, open source and intellectual property. Daniel teaches several courses at Uvic, Malcolm Bain primarily Database Systems (CSC370), Social and Professional Malcolm is partner at id law partners, a Barcelona based law Issues (SENG401), Media Applications (SENG410) and more firm specialising in IT law, with a focus on FOSS projects. As recently Intro to Software Engineering (SENG265). well as his private practice, Malcolm participates pro bono in a number of FOSS related initiatives and teaches the legal "ilayne #o$e%oy aspects of FOSS at university. Jilayne Lovejoy is corporate counsel at OpenLogic, a provider of open source software support, provisioning, and compliance Amanda Brock solutions to enterprises. In addition to traditional corporate Amanda Brock is Director at the international technology law counsel responsibilities, Jilayne helps develop OpenLogic’s firm, Origin, www.origin.co.uk.
    [Show full text]
  • Summary of UNIX Commands Furnishing, Performance, Or the Use of These Previewers Commands Or the Associated Descriptions Available on Most UNIX Systems
    S u mmary of UNIX Commands- version 3.2 Disclaimer 8. Usnet news 9. File transfer and remote access Summary of UNIX The author and publisher make no warranty of any 10. X window kind, expressed or implied, including the warranties of 11. Graph, Plot, Image processing tools commands merchantability or fitness for a particular purpose, with regard to the use of commands contained in this 12. Information systems 1994,1995,1996 Budi Rahardjo reference card. This reference card is provided “as is”. 13. Networking programs <[email protected]> The author and publisher shall not be liable for 14. Programming tools damage in connection with, or arising out of the 15. Text processors, typesetters, and This is a summary of UNIX commands furnishing, performance, or the use of these previewers commands or the associated descriptions available on most UNIX systems. 16. Wordprocessors Depending on the configuration, some of 17. Spreadsheets the commands may be unavailable on your Conventions 18. Databases site. These commands may be a 1. Directory and file commands commercial program, freeware or public bold domain program that must be installed represents program name separately, or probably just not in your bdf search path. Check your local dirname display disk space (HP-UX). See documentation or manual pages for more represents directory name as an also df. details (e.g. man programname). argument cat filename This reference card, obviously, cannot filename display the content of file filename describe all UNIX commands in details, but represents file name as an instead I picked commands that are useful argument cd [dirname] and interesting from a user’s point of view.
    [Show full text]
  • Using CAS Sessions in TEXMACS
    Using CAS sessions in TEXMACS One important feature of TeXmacs is that users can "execute" external computer algebra system (CAS) within worksheet. Supported CAS’s include: maxima octave gnuplot yacas R qcl etc. The detailed menu will be listed in [Insert] [Session] according to exactly CAS’s installat- tions1 in your system. → 1. Octave When you choose from the [Octave] choice from [Insert] [Session] or from submenu in middle line, octave will be invoked and you can input the octave→ command after the prompt as follows: octave> A=[1 0 0 0;2 2 0 0;-1 0 2 0;0 -1 2 2] octave> A^2 octave> A.^2 octave> eig(A) octave> [U,V]=eig(A) octave> V.^1 octave> U.^1 octave> A’ octave> 1.1. Linear System Equations The following equation can be solved only by division: ax = b x = b/a if a 0 ⇒ The method for solving linear system equation is similar as follows: I I 1 I Am nXI n 1 = bm 1 Xn 1 = Am− nbm 1 × × × ⇒ × × × And octave support the operation for such solution: I 1 I I XI n 1 = Am− nbm 1 Xn 1 = Am n bm 1 × × × ⇒ × × × / Example 1. Solve the linear system of equations: x + x = 2 − 1 2 2x + 3x = 1 1 2 − This system of equations can be rewritten as: 1 1 x 2 1 = −2 3 x 1 2 − Now the solution by octave is: octave> A=[-1 1; 2 3];b=[2;-1] octave> A\b octave> Note the command is A b but neither A/b nor b/A.
    [Show full text]