scs 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a3d577e9f481249087408220ac5a609c9eef5efcd8befd5b81368f3b84daca30
+  data.tar.gz: 1d1a05bcb8326b8a5f06a29715bae4a9788fdf9ee416410d33134da102efc1e9
+SHA512:
+  metadata.gz: 50e6df0f1faef9c92d5659557b0dcaf4fc1342ea224a61fee1f45abf3c22031314ccc7c61ec7c4756722d29f02f30dddb3e5dc0bdba3e1618e3b6f600622f38b
+  data.tar.gz: 6a2e023b50207693e349dac6f159fe97d58dfc3fa3dc095c6a580da24c61a39b795b412c4120b3950ffa3f3ffec5e1b93319ca537e0b645e431ad02fb96943c7

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.2.0 (2019-11-16)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2019 Andrew Kane
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# SCS
+
+[SCS](https://github.com/cvxgrp/scs) - the splitting conic solver - for Ruby
+
+:fire: Supports many different [problem types](https://www.cvxpy.org/tutorial/advanced/index.html#choosing-a-solver)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'scs'
+```
+
+## Getting Started
+
+Prep the problem
+
+```ruby
+data = {a: [[1], [-1]], b: [1, 0], c: [-1]}
+cone = {q: [], l: 2}
+```
+
+And solve it
+
+```ruby
+solver = SCS::Solver.new
+result = solver.solve(data, cone)
+```
+
+## Settings
+
+Default values shown
+
+```ruby
+solver.solve(data, cone, {
+  normalize: true,            # heuristic data rescaling
+  scale: 1.0,                 # if normalized, rescales by this factor
+  rho_x: 1e-3,                # x equality constraint scaling
+  max_iters: 5000,            # maximum iterations to take
+  eps: 1e-5,                  # convergence tolerance
+  alpha: 1.5,                 # relaxation parameter
+  cg_rate: 2.0,               # for indirect, tolerance goes down like (1/iter)^cg_rate
+  verbose: true,              # write out progress
+  warm_start: false,          # warm start
+  acceleration_lookback: 10,  # memory for acceleration
+  write_data_filename: nil    # filename to write data if set
+})
+```
+
+## Direct vs Indirect
+
+SCS comes with two solvers: a direct solver which uses a cached LDL factorization and an indirect solver based on conjugate gradients. For the indirect solver, use:
+
+```ruby
+SCS::Solver.new(indirect: true)
+```
+
+## Resources
+
+- [Conic Optimization via Operator Splitting and Homogeneous Self-Dual Embedding](https://web.stanford.edu/~boyd/papers/scs.html)
+
+## History
+
+View the [changelog](https://github.com/ankane/scs/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/scs/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/scs/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development and testing:
+
+```sh
+git clone https://github.com/ankane/scs.git
+cd scs
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```

data/ext/scs/Rakefile

@@ -0,0 +1,11 @@
+desc "Compile extensions"
+task :compile do
+  scs = File.expand_path("../../vendor/scs", __dir__)
+  Dir.chdir(scs) do
+    sh "make"
+  end
+end
+
+unless Rake::Task.task_defined?("default")
+  task default: :compile
+end

data/lib/scs/ffi.rb

@@ -0,0 +1,117 @@
+module SCS
+  module FFI
+    module Direct
+      def self.lib_name
+        "libscsdir"
+      end
+    end
+
+    module Indirect
+      def self.lib_name
+        "libscsindir"
+      end
+    end
+
+    ext =
+      if Gem.win_platform?
+        "dll"
+      elsif RbConfig::CONFIG["host_os"] =~ /darwin/i
+        "dylib"
+      else
+        "so"
+      end
+
+    [Direct, Indirect].each do |m|
+      m.module_eval do
+        extend Fiddle::Importer
+
+        dlload File.expand_path("../../vendor/scs/out/#{lib_name}.#{ext}", __dir__)
+
+        extern "size_t scs_sizeof_int(void)"
+        extern "size_t scs_sizeof_float(void)"
+
+        # TODO support other sizes
+        raise Error, "Unsupported int size" if scs_sizeof_int != 4
+        raise Error, "Unsupported float size" if scs_sizeof_float != 8
+
+        typealias "scs_float", "double"
+        typealias "scs_int", "int"
+
+        m::Data = struct [
+          "scs_int m",
+          "scs_int n",
+          "ScsMatrix *a",
+          "scs_float *b",
+          "scs_float *c",
+          "ScsSettings *stgs"
+        ]
+
+        m::Cone = struct [
+          "scs_int f",
+          "scs_int l",
+          "scs_int *q",
+          "scs_int qsize",
+          "scs_int *s",
+          "scs_int ssize",
+          "scs_int ep",
+          "scs_int ed",
+          "scs_float *p",
+          "scs_int psize",
+        ]
+
+        m::Solution = struct [
+          "scs_float *x",
+          "scs_float *y",
+          "scs_float *s"
+        ]
+
+        m::Info = struct [
+          "scs_int iter",
+          "char status[32]",
+          "scs_int status_val",
+          "scs_float pobj",
+          "scs_float dobj",
+          "scs_float res_pri",
+          "scs_float res_dual",
+          "scs_float res_infeas",
+          "scs_float res_unbdd",
+          "scs_float rel_gap",
+          "scs_float setup_time",
+          "scs_float solve_time"
+        ]
+
+        m::Settings = struct [
+          "scs_int normalize",
+          "scs_float scale",
+          "scs_float rho_x",
+          "scs_int max_iters",
+          "scs_float eps",
+          "scs_float alpha",
+          "scs_float cg_rate",
+          "scs_int verbose",
+          "scs_int warm_start",
+          "scs_int acceleration_lookback",
+          "const char* write_data_filename"
+        ]
+
+        m::Matrix = struct [
+          "scs_float *x",
+          "scs_int *i",
+          "scs_int *p",
+          "scs_int m",
+          "scs_int n"
+        ]
+
+        # scs.h
+        extern "ScsWork *scs_init(const ScsData *d, const ScsCone *k, ScsInfo *info)"
+        extern "scs_int scs_solve(ScsWork *w, const ScsData *d, const ScsCone *k, ScsSolution *sol, ScsInfo *info)"
+        extern "void scs_finish(ScsWork *w)"
+        extern "scs_int scs(const ScsData *d, const ScsCone *k, ScsSolution *sol, ScsInfo *info)"
+        extern "const char *scs_version(void)"
+
+        # utils.h
+        extern "void scs_set_default_settings(ScsData *d)"
+      end
+    end
+  end
+end

data/lib/scs/solver.rb

@@ -0,0 +1,178 @@
+module SCS
+  class Solver
+    def initialize(indirect: false)
+      @ffi = indirect ? FFI::Indirect : FFI::Direct
+    end
+
+    def solve(data, cone, **settings)
+      cdata = create_data(data)
+      set_settings(cdata, settings)
+      ccone = create_cone(cone)
+
+      solution = calloc(ffi::Solution.size) # alloc clear memory
+      info = ffi::Info.malloc
+
+      ffi.scs(cdata, ccone, solution, info)
+
+      solution = ffi::Solution.new(solution)
+      x = read_float_array(solution.x, cdata.n)
+      y = read_float_array(solution.y, cdata.m)
+      s = read_float_array(solution.s, cdata.m)
+
+      {
+        x: x,
+        y: y,
+        s: s,
+        iter: info.iter,
+        status: read_string(info.status),
+        status_val: info.status_val,
+        pobj: info.pobj,
+        dobj: info.dobj,
+        res_pri: info.res_pri,
+        res_dual: info.res_dual,
+        res_infeas: info.res_infeas,
+        res_unbdd: info.res_unbdd,
+        rel_gap: info.rel_gap,
+        setup_time: info.setup_time,
+        solve_time: info.solve_time
+      }
+    end
+
+    private
+
+    def check_result(ret)
+      raise Error, "Error code #{ret}" if ret != 0
+    end
+
+    def read_string(char_ptr)
+      idx = char_ptr.index { |v| v == 0 }
+      char_ptr[0, idx].map(&:chr).join
+    end
+
+    def float_array(arr)
+      # SCS float = double
+      Fiddle::Pointer[arr.to_a.pack("d*")]
+    end
+
+    def read_float_array(ptr, size)
+      # SCS float = double
+      ptr[0, size * Fiddle::SIZEOF_DOUBLE].unpack("d*")
+    end
+
+    def int_array(arr)
+      # SCS int = int
+      Fiddle::Pointer[arr.to_a.pack("i!*")]
+    end
+
+    def read_string(char_ptr)
+      idx = char_ptr.index { |v| v == 0 }
+      char_ptr[0, idx].map(&:chr).join
+    end
+
+    # TODO add support sparse matrices
+    def csc_matrix(mtx, upper: false)
+      mtx = mtx.to_a
+
+      m, n = shape(mtx)
+
+      cx = []
+      ci = []
+      cp = []
+
+      # CSC format
+      # https://www.gormanalysis.com/blog/sparse-matrix-storage-formats/
+      cp << 0
+      n.times do |j|
+        mtx.each_with_index do |row, i|
+          if row[j] != 0 && (!upper || i <= j)
+            cx << row[j]
+            ci << i
+          end
+        end
+        # cumulative column values
+        cp << cx.size
+      end
+
+      # construct matrix
+      matrix = ffi::Matrix.malloc
+      matrix.x = float_array(cx)
+      matrix.i = int_array(ci)
+      matrix.p = int_array(cp)
+      matrix.m = m
+      matrix.n = n
+      matrix
+    end
+
+    def shape(a)
+      if defined?(Matrix) && a.is_a?(Matrix)
+        [a.row_count, a.column_count]
+      elsif defined?(Numo::NArray) && a.is_a?(Numo::NArray)
+        a.shape
+      else
+        [a.size, a.first.size]
+      end
+    end
+
+    def create_data(data)
+      m, n = shape(data[:a])
+      cdata = ffi::Data.malloc
+      cdata.m = m
+      cdata.n = n
+      cdata.a = csc_matrix(data[:a])
+      cdata.b = float_array(data[:b])
+      cdata.c = float_array(data[:c])
+      cdata
+    end
+
+    def create_cone(cone)
+      ccone = ffi::Cone.malloc
+      ccone.f = cone[:f].to_i
+      ccone.l = cone[:l].to_i
+      ccone.q = int_array(cone[:q])
+      ccone.qsize = cone[:q].to_a.size
+      ccone.s = int_array(cone[:s])
+      ccone.ssize = cone[:s].to_a.size
+      ccone.ep = cone[:ep].to_i
+      ccone.ed = cone[:ed].to_i
+      ccone.p = float_array(cone[:p])
+      ccone.psize = cone[:p].to_a.size
+      ccone
+    end
+
+    def set_settings(data, settings)
+      set = ffi::Settings.malloc
+      data.stgs = set
+      ffi.scs_set_default_settings(data)
+
+      # hack for setting members with []=
+      # safer than send("#{k}=", v)
+      entity = set.to_ptr
+      settings.each do |k, v|
+        entity[k.to_s] = settings_value(v)
+      end
+
+      set
+    end
+
+    # handle booleans
+    def settings_value(v)
+      case v
+      when true
+        1
+      when false
+        0
+      else
+        v
+      end
+    end
+
+    # alloc clear memory
+    def calloc(size)
+      Fiddle::Pointer["\x00" * size]
+    end
+
+    def ffi
+      @ffi
+    end
+  end
+end

data/lib/scs/version.rb

@@ -0,0 +1,3 @@
+module SCS
+  VERSION = "0.2.0"
+end

data/lib/scs.rb

@@ -0,0 +1,17 @@
+# stdlib
+require "fiddle/import"
+
+# modules
+require "scs/solver"
+require "scs/version"
+
+module SCS
+  class Error < StandardError; end
+
+  def self.lib_version
+    FFI::Direct.scs_version.to_s
+  end
+
+  # friendlier error message
+  autoload :FFI, "scs/ffi"
+end

data/vendor/scs/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Brendan O'Donoghue (bodonoghue85@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/scs/Makefile

@@ -0,0 +1,164 @@
+# MAKEFILE for scs
+include scs.mk
+
+SCS_OBJECTS = src/scs.o src/util.o src/cones.o src/aa.o src/rw.o src/linalg.o src/ctrlc.o src/scs_version.o src/normalize.o
+
+SRC_FILES = $(wildcard src/*.c)
+INC_FILES = $(wildcard include/*.h)
+
+AMD_SOURCE = $(wildcard $(EXTSRC)/amd/*.c)
+LDL_SOURCE = $(EXTSRC)/qdldl/qdldl.c
+AMD_OBJS = $(AMD_SOURCE:.c=.o)
+LDL_OBJS = $(LDL_SOURCE:.c=.o)
+TARGETS = $(OUT)/demo_socp_indirect $(OUT)/demo_socp_direct $(OUT)/run_from_file_indirect $(OUT)/run_from_file_direct
+
+.PHONY: default
+
+default: $(TARGETS) $(OUT)/libscsdir.a $(OUT)/libscsindir.a $(OUT)/libscsdir.$(SHARED) $(OUT)/libscsindir.$(SHARED)
+	@echo "****************************************************************************************"
+	@echo "Successfully compiled scs, copyright Brendan O'Donoghue 2012."
+	@echo "To test, type '$(OUT)/demo_socp_indirect' to solve a random SOCP."
+	@echo "**********************************************************************************"
+ifneq ($(USE_LAPACK), 0)
+	@echo "Compiled with blas and lapack, can solve LPs, SOCPs, SDPs, ECPs, and PCPs"
+else
+	@echo "NOT compiled with blas/lapack, cannot solve SDPs (can solve LPs, SOCPs, ECPs, and PCPs)."
+	@echo "To solve SDPs, install blas and lapack, then edit scs.mk to set USE_LAPACK=1"
+	@echo "and point to the library install locations, and recompile with 'make purge', 'make'."
+endif
+	@echo "****************************************************************************************"
+
+%.o : src/%.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+src/scs.o	: $(SRC_FILES) $(INC_FILES)
+src/util.o	: src/util.c include/util.h include/glbopts.h
+src/cones.o	: src/cones.c include/cones.h include/scs_blas.h
+src/aa.o	: src/aa.c include/aa.h include/scs_blas.h
+src/rw.o	: src/rw.c include/rw.h
+src/cs.o	: src/cs.c include/cs.h
+src/linalg.o: src/linalg.c include/linalg.h
+src/ctrl.o  : src/ctrl.c include/ctrl.h
+src/scs_version.o: src/scs_version.c include/glbopts.h
+
+$(DIRSRC)/private.o: $(DIRSRC)/private.c  $(DIRSRC)/private.h
+$(INDIRSRC)/indirect/private.o: $(INDIRSRC)/private.c $(INDIRSRC)/private.h
+$(LINSYS)/amatrix.o: $(LINSYS)/amatrix.c $(LINSYS)/amatrix.h
+
+$(OUT)/libscsdir.a: $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/amatrix.o
+	mkdir -p $(OUT)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
+
+$(OUT)/libscsindir.a: $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/amatrix.o
+	mkdir -p $(OUT)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
+
+$(OUT)/libscsdir.$(SHARED): $(SCS_OBJECTS) $(DIRSRC)/private.o $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/amatrix.o
+	mkdir -p $(OUT)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/libscsindir.$(SHARED): $(SCS_OBJECTS) $(INDIRSRC)/private.o $(LINSYS)/amatrix.o
+	mkdir -p $(OUT)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/demo_socp_direct: test/random_socp_prob.c $(OUT)/libscsdir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/demo_socp_indirect: test/random_socp_prob.c $(OUT)/libscsindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/run_from_file_direct: test/run_from_file.c $(OUT)/libscsdir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/run_from_file_indirect: test/run_from_file.c $(OUT)/libscsindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+$(OUT)/run_from_file_gpu_indirect: test/run_from_file.c $(OUT)/libscsgpuindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+
+# basic testing
+.PHONY: test
+test: $(OUT)/run_tests_indirect $(OUT)/run_tests_direct
+$(OUT)/run_tests_indirect: test/run_tests.c $(OUT)/libscsindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -Itest
+$(OUT)/run_tests_direct: test/run_tests.c $(OUT)/libscsdir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) -Itest
+
+.PHONY: test_gpu
+test_gpu: $(OUT)/run_tests_gpu_indirect # $(OUT)/run_tests_gpu_direct
+
+$(OUT)/run_tests_gpu_indirect: test/run_tests.c $(OUT)/libscsgpuindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS) -Itest
+
+# $(OUT)/run_tests_gpu_direct: test/run_tests.c $(OUT)/libscsgpudir.a
+# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS) -Itest
+
+# REQUIRES GPU AND CUDA INSTALLED
+gpu: gpu_indirect # gpu_direct
+
+# gpu_direct: $(OUT)/demo_socp_gpu_direct $(OUT)/libscsgpudir.$(SHARED) $(OUT)/libscsgpudir.a $(OUT)/run_from_file_gpu_direct
+gpu_indirect: $(OUT)/demo_socp_gpu_indirect $(OUT)/libscsgpuindir.$(SHARED) $(OUT)/libscsgpuindir.a $(OUT)/run_from_file_gpu_indirect
+
+$(LINSYS)/gpu/gpu.o: $(LINSYS)/gpu/gpu.c
+	$(CUCC) -c -o $@ $^ $(CUDAFLAGS)
+
+# $(GPUDIR)/private.o: $(GPUDIR)/private.c
+# 	$(CUCC) -c -o $(GPUDIR)/private.o $^ $(CUDAFLAGS)
+
+$(GPUINDIR)/private.o: $(GPUINDIR)/private.c
+	$(CUCC) -c -o $(GPUINDIR)/private.o $^ $(CUDAFLAGS)
+
+# $(OUT)/libscsgpudir.$(SHARED): $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+#	 mkdir -p $(OUT)
+# 	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+
+# $(OUT)/libscsgpudir.a: $(SCS_OBJECTS) $(GPUDIR)/private.o $(AMD_OBJS) $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+#  	mkdir -p $(OUT)
+# 	$(ARCHIVE) $@ $^
+# 	- $(RANLIB) $@
+
+$(OUT)/libscsgpuindir.$(SHARED): $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+	mkdir -p $(OUT)
+	$(CC) $(CFLAGS) -shared -Wl,$(SONAME),$(@:$(OUT)/%=%) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+
+$(OUT)/libscsgpuindir.a: $(SCS_OBJECTS) $(GPUINDIR)/private.o $(LINSYS)/amatrix.o $(LINSYS)/gpu/gpu.o
+	mkdir -p $(OUT)
+	$(ARCHIVE) $@ $^
+	- $(RANLIB) $@
+
+# $(OUT)/demo_socp_gpu_direct: test/random_socp_prob.c $(OUT)/libscsgpudir.a
+# 	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+
+$(OUT)/demo_socp_gpu_indirect: test/random_socp_prob.c $(OUT)/libscsgpuindir.a
+	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(CULDFLAGS)
+
+.PHONY: clean purge
+clean:
+	@rm -rf $(TARGETS) $(SCS_OBJECTS) $(AMD_OBJS) $(LDL_OBJS) $(LINSYS)/*.o $(DIRSRC)/*.o $(INDIRSRC)/*.o $(GPUDIR)/*.o $(GPUINDIR)/*.o
+	@rm -rf $(OUT)/*.dSYM
+	@rm -rf matlab/*.mex*
+	@rm -rf .idea
+	@rm -rf python/*.pyc
+	@rm -rf python/build
+purge: clean
+	@rm -rf $(OUT)
+
+INSTALL_INC_FILES = $(INC_FILES)
+
+INSTALL_TARGETS = $(OUT)/libscsdir.a $(OUT)/libscsindir.a $(OUT)/libscsdir.$(SHARED) $(OUT)/libscsindir.$(SHARED)
+INSTALL_GPU_TARGETS = $(OUT)/libscsgpuindir.a $(OUT)/libscsgpuindir.$(SHARED) # $(OUT)/libscsgpudir.a $(OUT)/libscsgpudir.$(SHARED)
+
+INSTALL_INC_DIR = $(DESTDIR)$(PREFIX)/include/scs/
+INSTALL_LIB_DIR = $(DESTDIR)$(PREFIX)/lib/
+
+.PHONY: install install_gpu
+install: $(INSTALL_INC_FILES) $(INSTALL_TARGETS)
+	$(INSTALL) -d $(INSTALL_INC_DIR) $(INSTALL_LIB_DIR)
+	$(INSTALL) -m 644 $(INSTALL_INC_FILES) $(INSTALL_INC_DIR)
+	$(INSTALL) -m 644 $(INSTALL_TARGETS) $(INSTALL_LIB_DIR)
+install_gpu: $(INSTALL_INC_FILES) $(INSTALL_GPU_TARGETS)
+	$(INSTALL) -d $(INSTALL_INC_DIR) $(INSTALL_LIB_DIR)
+	$(INSTALL) -m 644 $(INSTALL_INC_FILES) $(INSTALL_INC_DIR)
+	$(INSTALL) -m 644 $(INSTALL_GPU_TARGETS) $(INSTALL_LIB_DIR)