├── CHANGELOG.md ├── CONTRIBUTING.md ├── VectorArithmetic.xcodeproj ├── project.xcworkspace │ └── contents.xcworkspacedata ├── xcshareddata │ └── xcschemes │ │ ├── iOS-VectorArithmetic.xcscheme │ │ └── OSX-VectorArithmetic.xcscheme └── project.pbxproj ├── .travis.yml ├── Source ├── VectorArithmetic.h ├── Info.plist └── Shared │ └── VectorArithmetic.swift ├── Tests ├── InfoTests.plist └── Shared │ ├── TestProtocol.swift │ ├── TestsMathFunctions.swift │ ├── TestsInitializerVectorOperatable.swift │ ├── TestsGenericMathFunctions.swift │ ├── TestsOperators.swift │ └── TestsGenericOperators.swift ├── LICENSE.md ├── VectorArithmetic.podspec └── README.md /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /VectorArithmetic.xcodeproj/project.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: objective-c 2 | osx_image: xcode7.3 3 | script: 4 | - xctool -project VectorArithmetic.xcodeproj -scheme OSX-VectorArithmetic test 5 | - xctool -project VectorArithmetic.xcodeproj -scheme iOS-VectorArithmetic test -sdk iphonesimulator 6 | -------------------------------------------------------------------------------- /Source/VectorArithmetic.h: -------------------------------------------------------------------------------- 1 | // 2 | // iOS-VectorArithmetic.h 3 | // iOS-VectorArithmetic 4 | // 5 | // Created by Seivan Heidari on 30/05/16. 6 | // 7 | // 8 | 9 | 10 | #if TARGET_OS_IPHONE 11 | 12 | #import 13 | 14 | #elif TARGET_OS_MAC 15 | 16 | #import 17 | 18 | #endif 19 | 20 | #import 21 | 22 | 23 | 24 | //! Project version number for VectorArithmetic. 25 | FOUNDATION_EXPORT double VectorArithmeticVersionNumber; 26 | 27 | //! Project version string for VectorArithmetic. 28 | FOUNDATION_EXPORT const unsigned char VectorArithmeticVersionString[]; 29 | 30 | // In this header, you should import all the public headers of your framework using statements like #import 31 | 32 | 33 | -------------------------------------------------------------------------------- /Tests/InfoTests.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | en 7 | CFBundleExecutable 8 | $(EXECUTABLE_NAME) 9 | CFBundleIdentifier 10 | $(PRODUCT_BUNDLE_IDENTIFIER) 11 | CFBundleInfoDictionaryVersion 12 | 6.0 13 | CFBundleName 14 | $(PRODUCT_NAME) 15 | CFBundlePackageType 16 | BNDL 17 | CFBundleShortVersionString 18 | 1.0 19 | CFBundleSignature 20 | ???? 21 | CFBundleVersion 22 | 1 23 | 24 | 25 | -------------------------------------------------------------------------------- /Source/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | en 7 | CFBundleExecutable 8 | $(EXECUTABLE_NAME) 9 | CFBundleIdentifier 10 | $(PRODUCT_BUNDLE_IDENTIFIER) 11 | CFBundleInfoDictionaryVersion 12 | 6.0 13 | CFBundleName 14 | $(PRODUCT_NAME) 15 | CFBundlePackageType 16 | FMWK 17 | CFBundleShortVersionString 18 | 1.3.4 19 | CFBundleSignature 20 | ???? 21 | CFBundleVersion 22 | $(CURRENT_PROJECT_VERSION) 23 | NSPrincipalClass 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | Copyright (c) 2014 Seivan Heidari. 2 | 3 | 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: 4 | 5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 6 | 7 | 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. -------------------------------------------------------------------------------- /Tests/Shared/TestProtocol.swift: -------------------------------------------------------------------------------- 1 | // 2 | // SuperTestsOperators.swift 3 | // TestsAndSample 4 | // 5 | // Created by Seivan Heidari on 06/07/14. 6 | // Copyright (c) 2014 Seivan Heidari. All rights reserved. 7 | // 8 | 9 | import XCTest 10 | import CoreGraphics 11 | 12 | protocol TestOperators { 13 | func testEqual() 14 | // func testNotEqual() 15 | func testLessThanOrEqual() 16 | func testLessThan() 17 | func testMoreThanOrEqual() 18 | func testMoreThan() 19 | func testSubtraction() 20 | func testSubtractionAssignment() 21 | func testAddition() 22 | func testAdditionAssignment() 23 | func testMultiplication() 24 | func testMultiplicationAssignment() 25 | func testDivision() 26 | func testDivisionAssignment() 27 | func testMultiplicationScalar() 28 | func testMultiplicationScalarAssignment() 29 | func testDivisionScalar() 30 | func testDivisionScalarAssignment() 31 | 32 | } 33 | 34 | protocol TestMathFunctions { 35 | func testAngleInRadians() 36 | func testMagnitude() 37 | func testLength() 38 | func testLengthSquared() 39 | func testDotProduct() 40 | func testCrossProduct() 41 | func testDistanceTo() 42 | func testReversed() 43 | func testNormalized() 44 | func testLimited() 45 | func testScaled() 46 | func testAngled() 47 | } 48 | 49 | -------------------------------------------------------------------------------- /VectorArithmetic.podspec: -------------------------------------------------------------------------------- 1 | Pod::Spec.new do |s| 2 | name = "VectorArithmetic" 3 | url = "https://github.com/seivan/#{name}" 4 | git_url = "#{url}.git" 5 | s.name = name 6 | version = "1.3.4" 7 | source_files = "Source/**/*.{swift}" 8 | 9 | s.version = version 10 | s.summary = "Operators for Double and math properties and functions" 11 | s.description = <<-DESC 12 | 13 | * Using generics to unify the three different structs 14 | * Add the protocol easily on top of your own similar structs 15 | * Namespaced generic functions to use with other structs if necessary. 16 | * Perform operations on two different generic types CGPoint - CGVector -> CGPoint (always returns lhs) 17 | * Well-tested & documented and lightweight 18 | * Easy selectors to get started quickly. 19 | 20 | DESC 21 | 22 | s.homepage = url 23 | s.license = 'MIT' 24 | s.author = { "Seivan Heidari" => "seivan.heidari@icloud.com" } 25 | 26 | s.source = { :git => git_url, :tag => version} 27 | 28 | 29 | s.platform = :ios, "8.0" 30 | 31 | s.source_files = source_files 32 | 33 | s.requires_arc = true 34 | s.social_media_url = 'https://twitter.com/seivan' 35 | 36 | 37 | 38 | end 39 | -------------------------------------------------------------------------------- /Tests/Shared/TestsMathFunctions.swift: -------------------------------------------------------------------------------- 1 | // 2 | // TestsCGPointMathFunctions.swift 3 | // TestsAndSample 4 | // 5 | // Created by Seivan Heidari on 06/07/14. 6 | // Copyright (c) 2014 Seivan Heidari. All rights reserved. 7 | // 8 | 9 | import XCTest 10 | import CoreGraphics 11 | import VectorArithmetic 12 | 13 | 14 | class TestsMathFunctions: XCTestCase,TestMathFunctions { 15 | let testerCGPoint:TestsGenericMathFunctions = TestsGenericMathFunctions() 16 | let testerCGSize:TestsGenericMathFunctions = TestsGenericMathFunctions() 17 | let testerCGVector:TestsGenericMathFunctions = TestsGenericMathFunctions() 18 | 19 | func testAngleInRadians() { 20 | self.testerCGPoint.testAngleInRadians() 21 | self.testerCGSize.testAngleInRadians() 22 | self.testerCGVector.testAngleInRadians() 23 | } 24 | 25 | func testMagnitude() { 26 | self.testerCGPoint.testMagnitude() 27 | self.testerCGSize.testMagnitude() 28 | self.testerCGVector.testMagnitude() 29 | } 30 | 31 | func testLength() { 32 | self.testerCGPoint.testLength() 33 | self.testerCGSize.testLength() 34 | self.testerCGVector.testLength() 35 | } 36 | 37 | func testLengthSquared() { 38 | self.testerCGPoint.testLengthSquared() 39 | self.testerCGSize.testLengthSquared() 40 | self.testerCGVector.testLengthSquared() 41 | } 42 | 43 | func testDotProduct() { 44 | self.testerCGPoint.testDotProduct() 45 | self.testerCGSize.testDotProduct() 46 | self.testerCGVector.testDotProduct() 47 | } 48 | func testCrossProduct() { 49 | self.testerCGPoint.testCrossProduct() 50 | self.testerCGSize.testCrossProduct() 51 | self.testerCGVector.testCrossProduct() 52 | } 53 | 54 | func testDistanceTo() { 55 | self.testerCGPoint.testDistanceTo() 56 | self.testerCGSize.testDistanceTo() 57 | self.testerCGVector.testDistanceTo() 58 | } 59 | 60 | func testReversed() { 61 | self.testerCGPoint.testReversed() 62 | self.testerCGSize.testReversed() 63 | self.testerCGVector.testReversed() 64 | } 65 | 66 | func testNormalized() { 67 | self.testerCGPoint.testNormalized() 68 | self.testerCGSize.testNormalized() 69 | self.testerCGVector.testNormalized() 70 | } 71 | 72 | func testLimited() { 73 | self.testerCGPoint.testLimited() 74 | self.testerCGSize.testLimited() 75 | self.testerCGVector.testLimited() 76 | } 77 | 78 | func testScaled() { 79 | self.testerCGPoint.testScaled() 80 | self.testerCGSize.testScaled() 81 | self.testerCGVector.testScaled() 82 | } 83 | 84 | func testAngled() { 85 | self.testerCGPoint.testAngled() 86 | self.testerCGSize.testAngled() 87 | self.testerCGVector.testAngled() 88 | } 89 | 90 | } 91 | 92 | -------------------------------------------------------------------------------- /Tests/Shared/TestsInitializerVectorOperatable.swift: -------------------------------------------------------------------------------- 1 | // 2 | // TestsVectorOperatable.swift 3 | // TestsAndSample 4 | // 5 | // Created by Seivan Heidari on 30/06/14. 6 | // Copyright (c) 2014 Seivan Heidari. All rights reserved. 7 | // 8 | 9 | import XCTest 10 | import CoreGraphics 11 | import VectorArithmetic 12 | 13 | class TestsInitializerVectorOperatable : XCTestCase { 14 | let doubleValue = 2.0 15 | 16 | func testCGPointCustomInit() { 17 | let vectorPoint = CGPoint(horizontal: self.doubleValue, vertical: self.doubleValue) 18 | var vectorGeneric = vectorPoint 19 | 20 | XCTAssertEqual(vectorPoint.x, CGFloat(self.doubleValue)) 21 | XCTAssertEqual(vectorPoint.y, CGFloat(self.doubleValue)) 22 | XCTAssertEqual(vectorGeneric.horizontal, self.doubleValue) 23 | XCTAssertEqual(vectorGeneric.vertical, self.doubleValue) 24 | 25 | } 26 | 27 | func testCGPointOverloadInit() { 28 | let vectorPoint = CGPoint(x: self.doubleValue, y: self.doubleValue) 29 | var vectorGeneric = vectorPoint 30 | 31 | XCTAssertEqual(vectorPoint.x, CGFloat(self.doubleValue)) 32 | XCTAssertEqual(vectorPoint.y, CGFloat(self.doubleValue)) 33 | XCTAssertEqual(vectorGeneric.horizontal, self.doubleValue) 34 | XCTAssertEqual(vectorGeneric.vertical, self.doubleValue) 35 | 36 | } 37 | 38 | func testCGSizeCustomInit() { 39 | let vectorSize = CGSize(horizontal: self.doubleValue, vertical: self.doubleValue) 40 | var vectorGeneric = vectorSize 41 | 42 | XCTAssertEqual(vectorSize.width, CGFloat(self.doubleValue)) 43 | XCTAssertEqual(vectorSize.height, CGFloat(self.doubleValue)) 44 | XCTAssertEqual(vectorGeneric.horizontal, self.doubleValue) 45 | XCTAssertEqual(vectorGeneric.vertical, self.doubleValue) 46 | 47 | } 48 | 49 | func testCGSizeOverloadInit() { 50 | let vectorSize = CGSize(width: self.doubleValue, height: self.doubleValue) 51 | var vectorGeneric = vectorSize 52 | 53 | XCTAssertEqual(vectorSize.width, CGFloat(self.doubleValue)) 54 | XCTAssertEqual(vectorSize.height, CGFloat(self.doubleValue)) 55 | XCTAssertEqual(vectorGeneric.horizontal, self.doubleValue) 56 | XCTAssertEqual(vectorGeneric.vertical, self.doubleValue) 57 | 58 | } 59 | func testCGVectorCustomInit() { 60 | let vectorVector = CGVector(horizontal: self.doubleValue, vertical: self.doubleValue) 61 | var vectorGeneric = vectorVector 62 | 63 | XCTAssertEqual(vectorVector.dx, CGFloat(self.doubleValue)) 64 | XCTAssertEqual(vectorVector.dy, CGFloat(self.doubleValue)) 65 | XCTAssertEqual(vectorGeneric.horizontal, self.doubleValue) 66 | XCTAssertEqual(vectorGeneric.vertical, self.doubleValue) 67 | 68 | } 69 | 70 | func testCGVectorOverloadInit() { 71 | let vectorVector = CGVector(self.doubleValue,self.doubleValue) 72 | var vectorGeneric = vectorVector 73 | 74 | XCTAssertEqual(vectorVector.dx, CGFloat(self.doubleValue)) 75 | XCTAssertEqual(vectorVector.dy, CGFloat(self.doubleValue)) 76 | XCTAssertEqual(vectorGeneric.horizontal, self.doubleValue) 77 | XCTAssertEqual(vectorGeneric.vertical, self.doubleValue) 78 | 79 | } 80 | 81 | 82 | } 83 | -------------------------------------------------------------------------------- /Tests/Shared/TestsGenericMathFunctions.swift: -------------------------------------------------------------------------------- 1 | // 2 | // TestsCGPointMathFunctions.swift 3 | // TestsAndSample 4 | // 5 | // Created by Seivan Heidari on 06/07/14. 6 | // Copyright (c) 2014 Seivan Heidari. All rights reserved. 7 | // 8 | 9 | import XCTest 10 | import CoreGraphics 11 | import VectorArithmetic 12 | 13 | class TestsGenericMathFunctions:TestMathFunctions { 14 | let vector:T = T(horizontal: 2, vertical: 2) 15 | 16 | func testAngleInRadians() { 17 | let candidate:Double = self.vector.angleInRadians 18 | let expected = -0.785398163397448 19 | XCTAssertEqualWithAccuracy(candidate, expected, accuracy: 0.000000000000001) 20 | } 21 | func testMagnitude() { 22 | let candidate:Double = self.vector.magnitude 23 | let expected = 2.82842712474619 24 | XCTAssertEqualWithAccuracy(candidate, expected, accuracy: 0.000000000000001) 25 | 26 | } 27 | func testLength() { 28 | let candidate:Double = self.vector.length 29 | let expected = 2.82842712474619 30 | XCTAssertEqualWithAccuracy(candidate, expected, accuracy: 0.000000000000001) 31 | 32 | } 33 | 34 | func testLengthSquared() { 35 | let candidate:Double = self.vector.lengthSquared 36 | let expected = 8.0 37 | XCTAssertEqualWithAccuracy(candidate, expected, accuracy: 0.000000000000001) 38 | 39 | } 40 | func testDotProduct() { 41 | let candidate:Double = self.vector.dotProduct(CGPoint(x: 100, y: 100)) 42 | let expected = 400.0 43 | XCTAssertEqualWithAccuracy(candidate, expected, accuracy: 0.000000000000001) 44 | 45 | } 46 | func testCrossProduct() { 47 | let candidate:Double = self.vector.crossProduct(CGPoint(x: 1, y: 2)) 48 | let expected = -2.0 49 | XCTAssertEqualWithAccuracy(candidate, expected, accuracy: 0.000000000000001) 50 | 51 | } 52 | 53 | func testDistanceTo() { 54 | let candidate:Double = self.vector.distanceTo(CGPoint(x: 100, y: 100)) 55 | let expected = 138.592929112563 56 | XCTAssertEqualWithAccuracy(candidate, expected, accuracy: 0.000000000001) 57 | 58 | } 59 | func testReversed() { 60 | let candidate:T = self.vector.reversed 61 | let expected = -2.0 62 | XCTAssertEqual(candidate.horizontal, expected); 63 | XCTAssertEqual(candidate.vertical, expected); 64 | 65 | } 66 | func testNormalized() { 67 | let candidate:T = self.vector.normalized 68 | let expected = 0.70710676908493 69 | XCTAssertEqualWithAccuracy(candidate.horizontal, expected, accuracy: 0.0000001) 70 | XCTAssertEqualWithAccuracy(candidate.vertical, expected, accuracy: 0.0000001) 71 | 72 | } 73 | func testLimited() { 74 | let candidate:T = self.vector.limited(0.5) 75 | let expected = 0.353553384542465 76 | XCTAssertEqualWithAccuracy(candidate.horizontal, expected, accuracy: 0.00000001) 77 | XCTAssertEqualWithAccuracy(candidate.vertical, expected, accuracy: 0.00000001) 78 | 79 | } 80 | func testScaled() { 81 | let candidate:T = self.vector.scaled(0.5) 82 | let expected = 0.353553384542465 83 | XCTAssertEqualWithAccuracy(candidate.horizontal, expected, accuracy: 0.00000001) 84 | XCTAssertEqualWithAccuracy(candidate.vertical, expected, accuracy: 0.00000001) 85 | 86 | } 87 | func testAngled() { 88 | let candidate:T = self.vector.angled(90) 89 | let expectedX = -1.26734352111816 90 | let expectedY = 2.52860450744629 91 | XCTAssertEqualWithAccuracy(candidate.horizontal, expectedX, accuracy: 0.00001) 92 | XCTAssertEqualWithAccuracy(candidate.vertical, expectedY, accuracy: 0.000001) 93 | 94 | } 95 | 96 | } 97 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## VectorArithmetic 2 | 3 | ### Overview 4 | Extending ```CGPoint```, ```CGSize``` and ```CGVector``` with the protocols 5 | ```VectorOperatable``` & ```VectorArithmetic``` 6 | 7 | Handles some of the Swift bugs related to architecture differences. 8 | 9 | Just want to point out that Apple themselves uses **CGPoint** throughout UIKit for **velocity** and other vectors. So remember that when you see ```myPoint + myOtherPoint * 2``` 10 | 11 | 12 | ### Dependency 13 | >To get better interoperability between different numerical types use 14 | * [ScalarArithmetic](https://github.com/seivan/ScalarArithmetic) 15 | 16 | ### Usage 17 | 18 | ##### Math Functions 19 | ```swift 20 | let vector = CGVector(20, 5.5) 21 | let point = CGPoint(x: 5, y: 5) 22 | 23 | vector.angleInRadians // -1.30243011588899 24 | vector.magnitude // 20.7424685126915 25 | vector.length // synonym to magnitude 26 | vector.lengthSquared // 430.25 27 | vector.dotProduct(point) // 127.5 28 | vector.crossProduct(point) // -72.5 29 | vector.distanceTo(point) // 15.0083310198036 30 | vector.reversed // {dx -20.0, dy -5.5} 31 | vector.normalized // {dx 0.96420539280379, dy 0.265156483021042} 32 | vector.limited(20) // {dx 19.2841078560758, dy 5.30312966042085} 33 | vector.scaled(20) // synonym to limited() 34 | vector.angled(90) // {dx -9.29415287392715, dy 18.5436976451859} 35 | ``` 36 | 37 | ##### Operators 38 | ```swift 39 | var point:CGPoint = CGPoint(x: 2.0, y: 2.0) 40 | var vector:CGVector = CGVector(horizontal: 2.0, vertical: 2.0) 41 | 42 | point = point + vector 43 | point += vector 44 | 45 | point = point - vector 46 | point -= vector 47 | 48 | point = point * vector 49 | point *= vector 50 | 51 | point = point / vector 52 | point /= vector 53 | 54 | vector = vector * 4.5 55 | vector *= 20.5 56 | 57 | vector = vector / 2.0 58 | vector /= 2.0 59 | ``` 60 | 61 | ##### Equatable and Comparable 62 | ```swift 63 | point == vector 64 | point != vector 65 | point < vector 66 | point <= vector 67 | point > vector 68 | point >= vector 69 | ``` 70 | 71 | 72 | ##### Generic initializer 73 | ```swift 74 | let point = CGPoint(horizontal:2.0,vertical:2.0) 75 | let vector = CGVector(horizontal:2.0,vertical:2.0) 76 | let yourStruct = YourStruct(horizontal:2.0,vertical:2.0) 77 | ``` 78 | 79 | ##### Type constraints 80 | ```swift 81 | class Boid { 82 | var position = T(horizontal: 2.0, vertical: 2.5) 83 | var velocity = U(horizontal: 2.0, vertical: 2.5) 84 | } 85 | 86 | let boid = Boid() 87 | boid.position = CGPointZero 88 | boid.velocity = CGVectorMake(20, 20) 89 | boid.velocity > boid.position // True 90 | ``` 91 | 92 | ### Extending 93 | 94 | ##### Equatable and Comparable 95 | ```swift 96 | protocol VectorOperatable { 97 | init(horizontal:Double,vertical:Double) 98 | var horizontal:Double { get set } 99 | var vertical:Double { get set } 100 | } 101 | ``` 102 | 103 | ##### Math Functions 104 | ```swift 105 | protocol VectorArithmetic : VectorOperatable { 106 | var angleInRadians:Double {get} 107 | var magnitude:Double {get} 108 | var length:Double {get} 109 | var lengthSquared:Double {get} 110 | func dotProduct (vector:T) -> Double 111 | func distanceTo (vector:T) -> Double 112 | var reversed:Self {get} 113 | var normalized:Self {get} 114 | func limited(scalar:Double) -> Self 115 | func scaled(scalar:Double) -> Self 116 | func angled(scalar:Double) -> Self 117 | } 118 | ``` 119 | 120 | 121 | ###Contact 122 | 123 | 124 | If you end up using VectorArithmetic in a project, I'd love to hear about it. 125 | 126 | email: [seivan.heidari@icloud.com](mailto:seivan.heidari@icloud.com) 127 | twitter: [@seivanheidari](https://twitter.com/seivanheidari) 128 | 129 | *** 130 | 131 | ### License 132 | 133 | VectorArithmetic is © 2014 [Seivan](http://www.github.com/seivan) and may be freely 134 | distributed under the [MIT license](http://opensource.org/licenses/MIT). 135 | See the [`LICENSE.md`](https://github.com/seivan/VectorArithmetic/blob/master/LICENSE.md) file. 136 | 137 | *** -------------------------------------------------------------------------------- /Tests/Shared/TestsOperators.swift: -------------------------------------------------------------------------------- 1 | // 2 | // TestsOperators.swift 3 | // TestsAndSample 4 | // 5 | // Created by Seivan Heidari on 11/07/14. 6 | // Copyright (c) 2014 Seivan Heidari. All rights reserved. 7 | // 8 | 9 | import XCTest 10 | import CoreGraphics 11 | import VectorArithmetic 12 | 13 | class TestsOperators: XCTestCase, TestOperators { 14 | let testerCGPoint:TestsGenericOperators = TestsGenericOperators() 15 | let testerCGSize:TestsGenericOperators = TestsGenericOperators() 16 | let testerCGVector:TestsGenericOperators = TestsGenericOperators() 17 | 18 | func testEqual() { 19 | self.testerCGPoint.testEqual() 20 | self.testerCGSize.testEqual() 21 | self.testerCGVector.testEqual() 22 | } 23 | 24 | // func testNotEqual() 25 | func testLessThanOrEqual() { 26 | self.testerCGPoint.testLessThanOrEqual() 27 | self.testerCGSize.testLessThanOrEqual() 28 | self.testerCGVector.testLessThanOrEqual() 29 | } 30 | 31 | func testLessThan() { 32 | self.testerCGPoint.testLessThan() 33 | self.testerCGSize.testLessThan() 34 | self.testerCGVector.testLessThan() 35 | } 36 | 37 | func testMoreThanOrEqual() { 38 | self.testerCGPoint.testMoreThanOrEqual() 39 | self.testerCGSize.testMoreThanOrEqual() 40 | self.testerCGVector.testMoreThanOrEqual() 41 | } 42 | 43 | func testMoreThan() { 44 | self.testerCGPoint.testMoreThan() 45 | self.testerCGSize.testMoreThan() 46 | self.testerCGVector.testMoreThan() 47 | } 48 | 49 | func testSubtraction() { 50 | self.testerCGPoint.testSubtraction() 51 | self.testerCGSize.testSubtraction() 52 | self.testerCGVector.testSubtraction() 53 | } 54 | 55 | func testSubtractionAssignment() { 56 | self.testerCGPoint.testSubtractionAssignment() 57 | self.testerCGSize.testSubtractionAssignment() 58 | self.testerCGVector.testSubtractionAssignment() 59 | } 60 | 61 | func testAddition() { 62 | self.testerCGPoint.testAddition() 63 | self.testerCGSize.testAddition() 64 | self.testerCGVector.testAddition() 65 | } 66 | 67 | func testAdditionAssignment() { 68 | self.testerCGPoint.testAdditionAssignment() 69 | self.testerCGSize.testAdditionAssignment() 70 | self.testerCGVector.testAdditionAssignment() 71 | } 72 | 73 | func testMultiplication() { 74 | self.testerCGPoint.testMultiplication() 75 | self.testerCGSize.testMultiplication() 76 | self.testerCGVector.testMultiplication() 77 | } 78 | 79 | func testMultiplicationAssignment() { 80 | self.testerCGPoint.testMultiplicationAssignment() 81 | self.testerCGSize.testMultiplicationAssignment() 82 | self.testerCGVector.testMultiplicationAssignment() 83 | } 84 | 85 | func testDivision() { 86 | self.testerCGPoint.testDivision() 87 | self.testerCGSize.testDivision() 88 | self.testerCGVector.testDivision() 89 | } 90 | 91 | func testDivisionAssignment() { 92 | self.testerCGPoint.testDivisionAssignment() 93 | self.testerCGSize.testDivisionAssignment() 94 | self.testerCGVector.testDivisionAssignment() 95 | } 96 | 97 | func testMultiplicationScalar() { 98 | self.testerCGPoint.testMultiplicationScalar() 99 | self.testerCGSize.testMultiplicationScalar() 100 | self.testerCGVector.testMultiplicationScalar() 101 | } 102 | 103 | func testMultiplicationScalarAssignment() { 104 | self.testerCGPoint.testMultiplicationScalarAssignment() 105 | self.testerCGSize.testMultiplicationScalarAssignment() 106 | self.testerCGVector.testMultiplicationScalarAssignment() 107 | } 108 | 109 | func testDivisionScalar() { 110 | self.testerCGPoint.testDivisionScalar() 111 | self.testerCGSize.testDivisionScalar() 112 | self.testerCGVector.testDivisionScalar() 113 | } 114 | 115 | func testDivisionScalarAssignment() { 116 | self.testerCGPoint.testDivisionScalarAssignment() 117 | self.testerCGSize.testDivisionScalarAssignment() 118 | self.testerCGVector.testDivisionScalarAssignment() 119 | } 120 | 121 | 122 | 123 | } 124 | -------------------------------------------------------------------------------- /VectorArithmetic.xcodeproj/xcshareddata/xcschemes/iOS-VectorArithmetic.xcscheme: -------------------------------------------------------------------------------- 1 | 2 | 5 | 8 | 9 | 15 | 21 | 22 | 23 | 24 | 25 | 30 | 31 | 33 | 39 | 40 | 41 | 42 | 43 | 49 | 50 | 51 | 52 | 53 | 54 | 64 | 65 | 71 | 72 | 73 | 74 | 75 | 76 | 82 | 83 | 89 | 90 | 91 | 92 | 94 | 95 | 98 | 99 | 100 | -------------------------------------------------------------------------------- /VectorArithmetic.xcodeproj/xcshareddata/xcschemes/OSX-VectorArithmetic.xcscheme: -------------------------------------------------------------------------------- 1 | 2 | 5 | 8 | 9 | 15 | 21 | 22 | 23 | 29 | 35 | 36 | 37 | 38 | 39 | 44 | 45 | 47 | 53 | 54 | 55 | 56 | 57 | 63 | 64 | 65 | 66 | 67 | 68 | 78 | 79 | 85 | 86 | 87 | 88 | 89 | 90 | 96 | 97 | 103 | 104 | 105 | 106 | 108 | 109 | 112 | 113 | 114 | -------------------------------------------------------------------------------- /Tests/Shared/TestsGenericOperators.swift: -------------------------------------------------------------------------------- 1 | // 2 | // TestsCGVectorOperators.swift 3 | // TestsAndSample 4 | // 5 | // Created by Seivan Heidari on 06/07/14. 6 | // Copyright (c) 2014 Seivan Heidari. All rights reserved. 7 | // 8 | 9 | import XCTest 10 | import CoreGraphics 11 | import VectorArithmetic 12 | 13 | class TestsGenericOperators: TestOperators { 14 | var vectorVector:T = T(horizontal: 2, vertical: 2) 15 | var vectorPoint:U = U(horizontal: 2, vertical: 2) 16 | var vectorSize:Z = Z(horizontal: 2, vertical: 2) 17 | let doubleValue:Double = 2.0 18 | 19 | func testEqual() { 20 | XCTAssert(self.vectorVector == self.vectorVector) 21 | XCTAssert(self.vectorVector == self.vectorPoint) 22 | XCTAssert(self.vectorVector == self.vectorSize) 23 | } 24 | 25 | func testLessThanOrEqual() { 26 | XCTAssert(self.vectorVector <= self.vectorVector) 27 | XCTAssert(self.vectorVector <= self.vectorPoint) 28 | XCTAssert(self.vectorVector <= self.vectorSize) 29 | self.vectorVector.horizontal = 0.0 30 | self.vectorVector.vertical = 0.0 31 | XCTAssert(self.vectorVector <= self.vectorVector) 32 | XCTAssert(self.vectorVector <= self.vectorPoint) 33 | XCTAssert(self.vectorVector <= self.vectorSize) 34 | 35 | 36 | 37 | } 38 | func testLessThan() { 39 | self.vectorVector.horizontal = 0.0 40 | self.vectorVector.vertical = 0.0 41 | XCTAssertFalse(self.vectorVector < self.vectorVector) 42 | XCTAssert(self.vectorVector < self.vectorPoint) 43 | XCTAssert(self.vectorVector < self.vectorSize) 44 | 45 | } 46 | func testMoreThanOrEqual() { 47 | XCTAssert(self.vectorVector >= self.vectorVector) 48 | XCTAssert(self.vectorVector >= self.vectorPoint) 49 | XCTAssert(self.vectorVector >= self.vectorSize) 50 | self.vectorVector.horizontal += 1.0 51 | self.vectorVector.vertical += 1.0 52 | XCTAssert(self.vectorVector >= self.vectorVector) 53 | XCTAssert(self.vectorVector >= self.vectorPoint) 54 | XCTAssert(self.vectorVector >= self.vectorSize) 55 | 56 | } 57 | func testMoreThan() { 58 | self.vectorVector.horizontal += 1.0 59 | self.vectorVector.vertical += 1.0 60 | XCTAssertFalse(self.vectorVector > self.vectorVector) 61 | XCTAssert(self.vectorVector > self.vectorPoint) 62 | XCTAssert(self.vectorVector > self.vectorSize) 63 | 64 | } 65 | func testSubtraction() { 66 | self.vectorVector = self.vectorVector - self.vectorVector 67 | XCTAssertEqual(self.vectorVector.vertical, self.doubleValue-self.doubleValue) 68 | XCTAssertEqual(self.vectorVector.horizontal, self.doubleValue-self.doubleValue) 69 | 70 | self.vectorVector = self.vectorVector - self.vectorPoint 71 | XCTAssertEqual(self.vectorVector.vertical, -self.doubleValue) 72 | XCTAssertEqual(self.vectorVector.horizontal, -self.doubleValue) 73 | 74 | self.vectorVector = self.vectorVector - self.vectorSize 75 | XCTAssertEqual(self.vectorVector.horizontal, -self.doubleValue*2) 76 | XCTAssertEqual(self.vectorVector.vertical, -self.doubleValue*2) 77 | 78 | } 79 | func testSubtractionAssignment() { 80 | self.vectorVector -= self.vectorVector 81 | XCTAssertEqual(self.vectorVector.vertical, self.doubleValue-self.doubleValue) 82 | XCTAssertEqual(self.vectorVector.horizontal, self.doubleValue-self.doubleValue) 83 | 84 | self.vectorVector -= self.vectorPoint 85 | XCTAssertEqual(self.vectorVector.vertical, -self.doubleValue) 86 | XCTAssertEqual(self.vectorVector.horizontal, -self.doubleValue) 87 | 88 | self.vectorVector -= self.vectorSize 89 | XCTAssertEqual(self.vectorVector.vertical, -self.doubleValue*2) 90 | XCTAssertEqual(self.vectorVector.horizontal, -self.doubleValue*2) 91 | 92 | } 93 | func testAddition() { 94 | self.vectorVector = self.vectorVector + self.vectorVector 95 | XCTAssertEqual(self.vectorVector.horizontal, self.doubleValue*2) 96 | XCTAssertEqual(self.vectorVector.vertical, self.doubleValue*2) 97 | 98 | self.vectorVector = self.vectorVector + self.vectorPoint 99 | XCTAssertEqual(self.vectorVector.horizontal, self.doubleValue*3) 100 | XCTAssertEqual(self.vectorVector.vertical, self.doubleValue*3) 101 | 102 | self.vectorVector = self.vectorVector + self.vectorSize 103 | XCTAssertEqual(self.vectorVector.horizontal, self.doubleValue*4) 104 | XCTAssertEqual(self.vectorVector.vertical, self.doubleValue*4) 105 | } 106 | 107 | func testAdditionAssignment() { 108 | self.vectorVector += self.vectorVector 109 | XCTAssertEqual(self.vectorVector.horizontal, self.doubleValue*2) 110 | XCTAssertEqual(self.vectorVector.vertical, self.doubleValue*2) 111 | 112 | self.vectorVector += self.vectorPoint 113 | XCTAssertEqual(self.vectorVector.horizontal, self.doubleValue*3) 114 | XCTAssertEqual(self.vectorVector.vertical, self.doubleValue*3) 115 | 116 | self.vectorVector += self.vectorSize 117 | XCTAssertEqual(self.vectorVector.horizontal, self.doubleValue*4) 118 | XCTAssertEqual(self.vectorVector.vertical, self.doubleValue*4) 119 | 120 | } 121 | func testMultiplication() { 122 | self.vectorVector = self.vectorVector * self.vectorVector 123 | XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 2)) 124 | XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 2)) 125 | 126 | self.vectorVector = self.vectorVector * self.vectorPoint 127 | XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 3)) 128 | XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 3)) 129 | 130 | self.vectorVector = self.vectorVector * self.vectorSize 131 | XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 4)) 132 | XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 4)) 133 | } 134 | 135 | func testMultiplicationAssignment() { 136 | self.vectorVector *= self.vectorVector 137 | XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 2)) 138 | XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 2)) 139 | 140 | self.vectorVector *= self.vectorPoint 141 | XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 3)) 142 | XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 3)) 143 | 144 | self.vectorVector *= self.vectorSize 145 | XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 4)) 146 | XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 4)) 147 | 148 | } 149 | func testDivision() { 150 | self.vectorVector = self.vectorVector / self.vectorVector 151 | XCTAssertEqual(self.vectorVector.horizontal, 1) 152 | XCTAssertEqual(self.vectorVector.vertical, 1) 153 | 154 | self.vectorVector = self.vectorVector / self.vectorPoint 155 | XCTAssertEqual(self.vectorVector.horizontal, 0.5) 156 | XCTAssertEqual(self.vectorVector.vertical, 0.5) 157 | 158 | self.vectorVector = self.vectorVector / self.vectorSize 159 | XCTAssertEqual(self.vectorVector.horizontal, 0.25) 160 | XCTAssertEqual(self.vectorVector.vertical, 0.25) 161 | 162 | } 163 | func testDivisionAssignment() { 164 | self.vectorVector /= self.vectorVector 165 | XCTAssertEqual(self.vectorVector.horizontal, 1) 166 | XCTAssertEqual(self.vectorVector.vertical, 1) 167 | 168 | self.vectorVector /= self.vectorPoint 169 | XCTAssertEqual(self.vectorVector.horizontal, 0.5) 170 | XCTAssertEqual(self.vectorVector.vertical, 0.5) 171 | 172 | self.vectorVector /= self.vectorSize 173 | XCTAssertEqual(self.vectorVector.horizontal, 0.25) 174 | XCTAssertEqual(self.vectorVector.vertical, 0.25) 175 | 176 | } 177 | 178 | func testMultiplicationScalar() { 179 | self.vectorVector = self.vectorVector * 2 180 | XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 2)) 181 | XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 2)) 182 | 183 | self.vectorVector = self.vectorVector * 2 184 | XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 3)) 185 | XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 3)) 186 | 187 | } 188 | func testMultiplicationScalarAssignment() { 189 | // self.vectorVector *= 2 190 | // XCTAssertEqual(self.vectorVector.horizontal, pow(self.doubleValue, 2)) 191 | // XCTAssertEqual(self.vectorVector.vertical, pow(self.doubleValue, 2)) 192 | 193 | } 194 | func testDivisionScalar() { 195 | self.vectorVector = self.vectorVector / 2 196 | XCTAssertEqual(self.vectorVector.horizontal, 1) 197 | XCTAssertEqual(self.vectorVector.vertical, 1) 198 | 199 | 200 | } 201 | func testDivisionScalarAssignment() { 202 | self.vectorVector /= 2 203 | XCTAssertEqual(self.vectorVector.horizontal, 1) 204 | XCTAssertEqual(self.vectorVector.vertical, 1) 205 | 206 | } 207 | 208 | 209 | 210 | } 211 | -------------------------------------------------------------------------------- /Source/Shared/VectorArithmetic.swift: -------------------------------------------------------------------------------- 1 | import CoreGraphics 2 | 3 | public protocol VectorOperatable { 4 | init(horizontal:Double,vertical:Double) 5 | var horizontal:Double { get set } 6 | var vertical:Double { get set } 7 | } 8 | 9 | public protocol VectorArithmetic : VectorOperatable { 10 | var angleInRadians:Double {get} 11 | var magnitude:Double {get} 12 | var length:Double {get} 13 | var lengthSquared:Double {get} 14 | func dotProduct (vector:T) -> Double 15 | func crossProduct (vector:T) -> Double 16 | func distanceTo (vector:T) -> Double 17 | var reversed:Self {get} 18 | var normalized:Self {get} 19 | func limited(scalar:Double) -> Self 20 | func scaled(scalar:Double) -> Self 21 | func angled(scalar:Double) -> Self 22 | 23 | 24 | } 25 | 26 | //Since these structs already have != operator for themselves, but not against each we can't use a generic constraint 27 | 28 | public func != (lhs: CGVector , rhs: CGSize) -> Bool { 29 | return (lhs == rhs) == false 30 | } 31 | public func != (lhs: CGVector , rhs: CGPoint) -> Bool { 32 | return (lhs == rhs) == false 33 | } 34 | public func != (lhs: CGSize , rhs: CGVector) -> Bool { 35 | return (lhs == rhs) == false 36 | } 37 | public func != (lhs: CGSize , rhs: CGPoint) -> Bool { 38 | return (lhs == rhs) == false 39 | } 40 | public func != (lhs: CGPoint , rhs: CGVector) -> Bool { 41 | return (lhs == rhs) == false 42 | } 43 | public func != (lhs: CGPoint , rhs: CGSize) -> Bool { 44 | return (lhs == rhs) == false 45 | } 46 | 47 | public func == (lhs:T,rhs:U) -> Bool { 48 | return (lhs.horizontal == rhs.horizontal && lhs.vertical == rhs.vertical) 49 | } 50 | //Gives ambigious operator since the struct already does compare to its own type 51 | //func != (lhs: T , rhs: U) -> Bool { 52 | // return (lhs == rhs) == false 53 | //} 54 | public func <= (lhs:T, rhs:U) -> Bool { 55 | return (lhs < rhs) || (lhs == rhs) 56 | } 57 | public func < (lhs: T , rhs: U) -> Bool { 58 | return (lhs.horizontal < rhs.horizontal || lhs.vertical < rhs.vertical) 59 | } 60 | public func >= (lhs: T , rhs: U) -> Bool { 61 | return (lhs > rhs) || ( lhs == rhs) 62 | } 63 | public func > (lhs: T , rhs: U) -> Bool { 64 | return (lhs <= rhs) == false 65 | } 66 | 67 | public func - (lhs: T, rhs:U) -> T { 68 | return T(horizontal: lhs.horizontal-rhs.horizontal, vertical: lhs.vertical-rhs.vertical) 69 | } 70 | public func -= (inout lhs: T, rhs:U) { 71 | lhs = lhs - rhs 72 | } 73 | 74 | public func + (lhs: T, rhs:U) -> T { 75 | return T(horizontal: lhs.horizontal+rhs.horizontal, vertical: lhs.vertical+rhs.vertical) 76 | } 77 | public func += (inout lhs: T, rhs:U) { 78 | lhs = lhs + rhs 79 | } 80 | 81 | public func * (lhs: T, rhs:U) -> T { 82 | return T(horizontal: lhs.horizontal*rhs.horizontal, vertical: lhs.vertical*rhs.vertical); 83 | } 84 | public func *= (inout lhs: T, rhs:U) { 85 | lhs = lhs * rhs 86 | 87 | } 88 | 89 | public func / (lhs:T, rhs:U) -> T { 90 | return T(horizontal: lhs.horizontal/rhs.horizontal, vertical: lhs.vertical/rhs.vertical); 91 | } 92 | public func /= (inout lhs:T, rhs:U) -> T { 93 | lhs = lhs / rhs 94 | return lhs 95 | } 96 | 97 | 98 | public func / (lhs:T, scalar:Double) -> T { 99 | return T(horizontal: lhs.horizontal/scalar, vertical: lhs.vertical/scalar); 100 | } 101 | public func /= (inout lhs:T, scalar:Double) -> T { 102 | lhs = lhs / scalar 103 | return lhs 104 | } 105 | 106 | public func * (lhs: T, scalar:Double) -> T { 107 | return T(horizontal: lhs.horizontal*scalar, vertical: lhs.vertical*scalar) 108 | } 109 | func * (scalar:Double, rhs: T) -> T { 110 | return T(horizontal: rhs.horizontal*scalar, vertical: rhs.vertical*scalar) 111 | } 112 | func *= (inout lhs: T, value:Double) { 113 | lhs = lhs * value 114 | } 115 | 116 | 117 | 118 | internal struct InternalVectorArithmetic { 119 | 120 | internal static func angleInRadians (vector:T) -> Double { 121 | let normalizedVector = self.normalized(vector) 122 | 123 | let theta = atan2(normalizedVector.vertical, normalizedVector.horizontal) 124 | return theta + M_PI_2 * -1 125 | } 126 | 127 | internal static func magnitude (vector:T) -> Double { 128 | return sqrt(self.lengthSquared(vector)) 129 | } 130 | 131 | internal static func lengthSquared (vector:T) -> Double { 132 | return ((vector.horizontal*vector.horizontal) + (vector.vertical*vector.vertical)) 133 | } 134 | 135 | 136 | internal static func reversed (vector:T) -> T { 137 | return vector * -1 138 | } 139 | 140 | internal static func dotProduct (vector:T, otherVector:U) -> Double { 141 | return (vector.horizontal*otherVector.horizontal) + (vector.vertical*otherVector.vertical) 142 | } 143 | 144 | internal static func crossProduct (vector:T, otherVector:U) -> Double { 145 | let deltaAngle = sin(self.angleInRadians(vector) - self.angleInRadians(otherVector)) 146 | return self.magnitude(vector) * self.magnitude(otherVector) * deltaAngle 147 | } 148 | 149 | 150 | internal static func distanceTo (vector:T, otherVector:U) -> Double { 151 | let deltaX = Double.abs(vector.horizontal - otherVector.horizontal) 152 | let deltaY = Double.abs(vector.vertical - otherVector.vertical) 153 | return self.magnitude(T(horizontal: deltaX, vertical: deltaY)) 154 | } 155 | 156 | internal static func normalized (vector:T) -> T { 157 | let length = self.magnitude(vector) 158 | var newPoint:T = vector 159 | if(length > 0.0) { 160 | newPoint /= length 161 | } 162 | return newPoint 163 | } 164 | 165 | internal static func limit (vector:T, scalar:Double) -> T { 166 | var newPoint = vector 167 | if(self.magnitude(vector) > scalar) { 168 | newPoint = self.normalized(newPoint) * scalar 169 | } 170 | return newPoint 171 | } 172 | 173 | 174 | internal static func vectorWithAngle (vector:T, scalar:Double) -> T { 175 | let length = self.magnitude(vector) 176 | return T(horizontal: cos(scalar) * length, vertical: sin(scalar) * length) 177 | } 178 | } 179 | 180 | 181 | extension CGPoint: VectorArithmetic { 182 | 183 | 184 | public init(horizontal:Double,vertical:Double) { 185 | self.init(x: horizontal, y: vertical) 186 | } 187 | 188 | 189 | // public init(x:Double, y:Double) { 190 | // self.init(x:CGFloat(x), y:CGFloat(y)) 191 | // } 192 | 193 | public var horizontal:Double { 194 | get { return Double(self.x) } 195 | set { self.x = CGFloat(newValue) } 196 | } 197 | public var vertical:Double { 198 | get {return Double(self.y) } 199 | set {self.y = CGFloat(newValue) } 200 | } 201 | 202 | 203 | public var angleInRadians:Double { return InternalVectorArithmetic.angleInRadians(self)} 204 | public var magnitude:Double { return InternalVectorArithmetic.magnitude(self) } 205 | public var length:Double { return self.magnitude } 206 | public var lengthSquared:Double { return InternalVectorArithmetic.lengthSquared(self) } 207 | public func dotProduct (vector:T) -> Double { return InternalVectorArithmetic.dotProduct(self, otherVector: vector) } 208 | public func crossProduct (vector:T) -> Double { return InternalVectorArithmetic.crossProduct(self, otherVector: vector) } 209 | public func distanceTo (vector:T) -> Double { return InternalVectorArithmetic.distanceTo(self, otherVector: vector) } 210 | public var reversed:CGPoint { return InternalVectorArithmetic.reversed(self) } 211 | public var normalized:CGPoint { return InternalVectorArithmetic.normalized(self) } 212 | public func limited(scalar:Double) -> CGPoint { return InternalVectorArithmetic.limit(self, scalar: scalar) } 213 | public func scaled(scalar:Double) -> CGPoint { return InternalVectorArithmetic.limit(self, scalar: scalar) } 214 | public func angled(scalar:Double) -> CGPoint { return InternalVectorArithmetic.vectorWithAngle(self, scalar: scalar) } 215 | 216 | 217 | } 218 | 219 | 220 | extension CGSize: VectorArithmetic { 221 | 222 | public init(horizontal:Double,vertical:Double) { 223 | self.init(width: horizontal, height: vertical) 224 | } 225 | 226 | 227 | // public init(width:Double, height:Double) { 228 | // self.init(width:CGFloat(width), height:CGFloat(height)) 229 | // } 230 | 231 | public var horizontal:Double { 232 | get { return Double(self.width) } 233 | set { self.width = CGFloat(newValue) } 234 | } 235 | public var vertical:Double { 236 | get {return Double(self.height) } 237 | set {self.height = CGFloat(newValue) } 238 | } 239 | 240 | 241 | 242 | public var angleInRadians:Double { return InternalVectorArithmetic.angleInRadians(self) } 243 | public var magnitude:Double { return InternalVectorArithmetic.magnitude(self) } 244 | public var length:Double { return self.magnitude } 245 | public var lengthSquared:Double { return InternalVectorArithmetic.lengthSquared(self) } 246 | public func dotProduct (vector:T) -> Double { return InternalVectorArithmetic.dotProduct(self, otherVector: vector) } 247 | public func crossProduct (vector:T) -> Double { return InternalVectorArithmetic.crossProduct(self, otherVector: vector) } 248 | 249 | public func distanceTo (vector:T) -> Double { return InternalVectorArithmetic.distanceTo(self, otherVector: vector) } 250 | public var reversed:CGSize { return InternalVectorArithmetic.reversed(self) } 251 | public var normalized:CGSize { return InternalVectorArithmetic.normalized(self) } 252 | public func limited(scalar:Double) -> CGSize { return InternalVectorArithmetic.limit(self, scalar: scalar) } 253 | public func scaled(scalar:Double) -> CGSize { return InternalVectorArithmetic.limit(self, scalar: scalar) } 254 | public func angled(scalar:Double) -> CGSize { return InternalVectorArithmetic.vectorWithAngle(self, scalar: scalar) } 255 | 256 | 257 | } 258 | 259 | extension CGVector: VectorArithmetic { 260 | 261 | public init(horizontal:Double,vertical:Double) { 262 | self.dx = CGFloat(horizontal) 263 | self.dy = CGFloat(vertical) 264 | 265 | } 266 | 267 | 268 | public init(_ dx:Double, _ dy:Double) { 269 | self.dx = CGFloat(dx) 270 | self.dy = CGFloat(dy) 271 | } 272 | 273 | public var horizontal:Double { 274 | get { return Double(self.dx) } 275 | set { self.dx = CGFloat(newValue) } 276 | } 277 | public var vertical:Double { 278 | get {return Double(self.dy) } 279 | set {self.dy = CGFloat(newValue) } 280 | } 281 | 282 | 283 | public var angleInRadians:Double { return InternalVectorArithmetic.angleInRadians(self) } 284 | public var magnitude:Double { return InternalVectorArithmetic.magnitude(self) } 285 | public var length:Double { return self.magnitude } 286 | public var lengthSquared:Double { return InternalVectorArithmetic.lengthSquared(self) } 287 | public func dotProduct (vector:T) -> Double { return InternalVectorArithmetic.dotProduct(self, otherVector: vector) } 288 | public func crossProduct (vector:T) -> Double { return InternalVectorArithmetic.crossProduct(self, otherVector: vector) } 289 | public func distanceTo (vector:T) -> Double { return InternalVectorArithmetic.distanceTo(self, otherVector: vector) } 290 | public var reversed:CGVector { return InternalVectorArithmetic.reversed(self) } 291 | public var normalized:CGVector { return InternalVectorArithmetic.normalized(self) } 292 | public func limited(scalar:Double) -> CGVector { return InternalVectorArithmetic.limit(self, scalar: scalar) } 293 | public func scaled(scalar:Double) -> CGVector { return InternalVectorArithmetic.limit(self, scalar: scalar) } 294 | public func angled(scalar:Double) -> CGVector { return InternalVectorArithmetic.vectorWithAngle(self, scalar: scalar) } 295 | 296 | } 297 | 298 | extension VectorOperatable { 299 | public var point: CGPoint { 300 | return CGPoint(x: horizontal, y: vertical) 301 | } 302 | 303 | public var size: CGSize { 304 | return CGSize(width: horizontal, height: vertical) 305 | } 306 | 307 | public var vector: CGVector { 308 | return CGVector(dx: horizontal, dy: vertical) 309 | } 310 | } 311 | 312 | extension CGRect { 313 | public var widthVector: CGVector { 314 | return CGVector(dx: size.width, dy: 0) 315 | } 316 | 317 | public var heightVector: CGVector { 318 | return CGVector(dx: 0, dy: size.height) 319 | } 320 | } -------------------------------------------------------------------------------- /VectorArithmetic.xcodeproj/project.pbxproj: -------------------------------------------------------------------------------- 1 | // !$*UTF8*$! 2 | { 3 | archiveVersion = 1; 4 | classes = { 5 | }; 6 | objectVersion = 46; 7 | objects = { 8 | 9 | /* Begin PBXBuildFile section */ 10 | 221518D01CFC2E1E00040369 /* VectorArithmetic.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 221518B11CFC2E0500040369 /* VectorArithmetic.framework */; }; 11 | 221518DF1CFC2E9F00040369 /* VectorArithmetic.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 221518BF1CFC2E0D00040369 /* VectorArithmetic.framework */; }; 12 | 221518F41CFC2EEE00040369 /* VectorArithmetic.h in Headers */ = {isa = PBXBuildFile; fileRef = 221518ED1CFC2EE900040369 /* VectorArithmetic.h */; settings = {ATTRIBUTES = (Public, ); }; }; 13 | 221518F51CFC2EEF00040369 /* VectorArithmetic.h in Headers */ = {isa = PBXBuildFile; fileRef = 221518ED1CFC2EE900040369 /* VectorArithmetic.h */; settings = {ATTRIBUTES = (Public, ); }; }; 14 | 221518FC1CFC302200040369 /* TestProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518F61CFC302200040369 /* TestProtocol.swift */; }; 15 | 221518FD1CFC302200040369 /* TestProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518F61CFC302200040369 /* TestProtocol.swift */; }; 16 | 221518FE1CFC302200040369 /* TestsGenericMathFunctions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518F71CFC302200040369 /* TestsGenericMathFunctions.swift */; }; 17 | 221518FF1CFC302200040369 /* TestsGenericMathFunctions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518F71CFC302200040369 /* TestsGenericMathFunctions.swift */; }; 18 | 221519001CFC302200040369 /* TestsGenericOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518F81CFC302200040369 /* TestsGenericOperators.swift */; }; 19 | 221519011CFC302200040369 /* TestsGenericOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518F81CFC302200040369 /* TestsGenericOperators.swift */; }; 20 | 221519021CFC302200040369 /* TestsInitializerVectorOperatable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518F91CFC302200040369 /* TestsInitializerVectorOperatable.swift */; }; 21 | 221519031CFC302200040369 /* TestsInitializerVectorOperatable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518F91CFC302200040369 /* TestsInitializerVectorOperatable.swift */; }; 22 | 221519041CFC302200040369 /* TestsMathFunctions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518FA1CFC302200040369 /* TestsMathFunctions.swift */; }; 23 | 221519051CFC302200040369 /* TestsMathFunctions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518FA1CFC302200040369 /* TestsMathFunctions.swift */; }; 24 | 221519061CFC302200040369 /* TestsOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518FB1CFC302200040369 /* TestsOperators.swift */; }; 25 | 221519071CFC302200040369 /* TestsOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518FB1CFC302200040369 /* TestsOperators.swift */; }; 26 | 221519081CFC309200040369 /* VectorArithmetic.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518EC1CFC2EE900040369 /* VectorArithmetic.swift */; }; 27 | 221519091CFC309200040369 /* VectorArithmetic.swift in Sources */ = {isa = PBXBuildFile; fileRef = 221518EC1CFC2EE900040369 /* VectorArithmetic.swift */; }; 28 | /* End PBXBuildFile section */ 29 | 30 | /* Begin PBXContainerItemProxy section */ 31 | 221518D11CFC2E1E00040369 /* PBXContainerItemProxy */ = { 32 | isa = PBXContainerItemProxy; 33 | containerPortal = 221518A61CFC2DEB00040369 /* Project object */; 34 | proxyType = 1; 35 | remoteGlobalIDString = 221518B01CFC2E0500040369; 36 | remoteInfo = "OSX-VectorArithmetic"; 37 | }; 38 | 221518E01CFC2E9F00040369 /* PBXContainerItemProxy */ = { 39 | isa = PBXContainerItemProxy; 40 | containerPortal = 221518A61CFC2DEB00040369 /* Project object */; 41 | proxyType = 1; 42 | remoteGlobalIDString = 221518BE1CFC2E0D00040369; 43 | remoteInfo = "iOS-VectorArithmetic"; 44 | }; 45 | /* End PBXContainerItemProxy section */ 46 | 47 | /* Begin PBXFileReference section */ 48 | 221518B11CFC2E0500040369 /* VectorArithmetic.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = VectorArithmetic.framework; sourceTree = BUILT_PRODUCTS_DIR; }; 49 | 221518BF1CFC2E0D00040369 /* VectorArithmetic.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = VectorArithmetic.framework; sourceTree = BUILT_PRODUCTS_DIR; }; 50 | 221518CB1CFC2E1E00040369 /* OSX-VectorArithmeticTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "OSX-VectorArithmeticTests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; }; 51 | 221518DA1CFC2E9F00040369 /* iOS-VectorArithmeticTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "iOS-VectorArithmeticTests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; }; 52 | 221518EC1CFC2EE900040369 /* VectorArithmetic.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VectorArithmetic.swift; sourceTree = ""; }; 53 | 221518ED1CFC2EE900040369 /* VectorArithmetic.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = VectorArithmetic.h; sourceTree = ""; }; 54 | 221518F61CFC302200040369 /* TestProtocol.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestProtocol.swift; sourceTree = ""; }; 55 | 221518F71CFC302200040369 /* TestsGenericMathFunctions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestsGenericMathFunctions.swift; sourceTree = ""; }; 56 | 221518F81CFC302200040369 /* TestsGenericOperators.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestsGenericOperators.swift; sourceTree = ""; }; 57 | 221518F91CFC302200040369 /* TestsInitializerVectorOperatable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestsInitializerVectorOperatable.swift; sourceTree = ""; }; 58 | 221518FA1CFC302200040369 /* TestsMathFunctions.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestsMathFunctions.swift; sourceTree = ""; }; 59 | 221518FB1CFC302200040369 /* TestsOperators.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TestsOperators.swift; sourceTree = ""; }; 60 | 2215190A1CFC37DD00040369 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; 61 | 221519141CFC3CAA00040369 /* InfoTests.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = InfoTests.plist; sourceTree = ""; }; 62 | /* End PBXFileReference section */ 63 | 64 | /* Begin PBXFrameworksBuildPhase section */ 65 | 221518AD1CFC2E0500040369 /* Frameworks */ = { 66 | isa = PBXFrameworksBuildPhase; 67 | buildActionMask = 2147483647; 68 | files = ( 69 | ); 70 | runOnlyForDeploymentPostprocessing = 0; 71 | }; 72 | 221518BB1CFC2E0D00040369 /* Frameworks */ = { 73 | isa = PBXFrameworksBuildPhase; 74 | buildActionMask = 2147483647; 75 | files = ( 76 | ); 77 | runOnlyForDeploymentPostprocessing = 0; 78 | }; 79 | 221518C81CFC2E1E00040369 /* Frameworks */ = { 80 | isa = PBXFrameworksBuildPhase; 81 | buildActionMask = 2147483647; 82 | files = ( 83 | 221518D01CFC2E1E00040369 /* VectorArithmetic.framework in Frameworks */, 84 | ); 85 | runOnlyForDeploymentPostprocessing = 0; 86 | }; 87 | 221518D71CFC2E9F00040369 /* Frameworks */ = { 88 | isa = PBXFrameworksBuildPhase; 89 | buildActionMask = 2147483647; 90 | files = ( 91 | 221518DF1CFC2E9F00040369 /* VectorArithmetic.framework in Frameworks */, 92 | ); 93 | runOnlyForDeploymentPostprocessing = 0; 94 | }; 95 | /* End PBXFrameworksBuildPhase section */ 96 | 97 | /* Begin PBXGroup section */ 98 | 221518A51CFC2DEB00040369 = { 99 | isa = PBXGroup; 100 | children = ( 101 | 221518E51CFC2EE900040369 /* Examples */, 102 | 221518E61CFC2EE900040369 /* Source */, 103 | 221518EE1CFC2EE900040369 /* Tests */, 104 | 221518B21CFC2E0500040369 /* Products */, 105 | ); 106 | sourceTree = ""; 107 | }; 108 | 221518B21CFC2E0500040369 /* Products */ = { 109 | isa = PBXGroup; 110 | children = ( 111 | 221518B11CFC2E0500040369 /* VectorArithmetic.framework */, 112 | 221518BF1CFC2E0D00040369 /* VectorArithmetic.framework */, 113 | 221518CB1CFC2E1E00040369 /* OSX-VectorArithmeticTests.xctest */, 114 | 221518DA1CFC2E9F00040369 /* iOS-VectorArithmeticTests.xctest */, 115 | ); 116 | name = Products; 117 | sourceTree = ""; 118 | }; 119 | 221518E51CFC2EE900040369 /* Examples */ = { 120 | isa = PBXGroup; 121 | children = ( 122 | ); 123 | path = Examples; 124 | sourceTree = ""; 125 | }; 126 | 221518E61CFC2EE900040369 /* Source */ = { 127 | isa = PBXGroup; 128 | children = ( 129 | 221518E71CFC2EE900040369 /* iOS */, 130 | 221518E91CFC2EE900040369 /* OSX */, 131 | 221518EB1CFC2EE900040369 /* Shared */, 132 | 221518ED1CFC2EE900040369 /* VectorArithmetic.h */, 133 | 2215190A1CFC37DD00040369 /* Info.plist */, 134 | ); 135 | path = Source; 136 | sourceTree = ""; 137 | }; 138 | 221518E71CFC2EE900040369 /* iOS */ = { 139 | isa = PBXGroup; 140 | children = ( 141 | ); 142 | path = iOS; 143 | sourceTree = ""; 144 | }; 145 | 221518E91CFC2EE900040369 /* OSX */ = { 146 | isa = PBXGroup; 147 | children = ( 148 | ); 149 | path = OSX; 150 | sourceTree = ""; 151 | }; 152 | 221518EB1CFC2EE900040369 /* Shared */ = { 153 | isa = PBXGroup; 154 | children = ( 155 | 221518EC1CFC2EE900040369 /* VectorArithmetic.swift */, 156 | ); 157 | path = Shared; 158 | sourceTree = ""; 159 | }; 160 | 221518EE1CFC2EE900040369 /* Tests */ = { 161 | isa = PBXGroup; 162 | children = ( 163 | 221519141CFC3CAA00040369 /* InfoTests.plist */, 164 | 221518EF1CFC2EE900040369 /* iOS */, 165 | 221518F11CFC2EE900040369 /* OSX */, 166 | 221518F31CFC2EE900040369 /* Shared */, 167 | ); 168 | path = Tests; 169 | sourceTree = ""; 170 | }; 171 | 221518EF1CFC2EE900040369 /* iOS */ = { 172 | isa = PBXGroup; 173 | children = ( 174 | ); 175 | path = iOS; 176 | sourceTree = ""; 177 | }; 178 | 221518F11CFC2EE900040369 /* OSX */ = { 179 | isa = PBXGroup; 180 | children = ( 181 | ); 182 | path = OSX; 183 | sourceTree = ""; 184 | }; 185 | 221518F31CFC2EE900040369 /* Shared */ = { 186 | isa = PBXGroup; 187 | children = ( 188 | 221518F61CFC302200040369 /* TestProtocol.swift */, 189 | 221518F71CFC302200040369 /* TestsGenericMathFunctions.swift */, 190 | 221518F81CFC302200040369 /* TestsGenericOperators.swift */, 191 | 221518F91CFC302200040369 /* TestsInitializerVectorOperatable.swift */, 192 | 221518FA1CFC302200040369 /* TestsMathFunctions.swift */, 193 | 221518FB1CFC302200040369 /* TestsOperators.swift */, 194 | ); 195 | path = Shared; 196 | sourceTree = ""; 197 | }; 198 | /* End PBXGroup section */ 199 | 200 | /* Begin PBXHeadersBuildPhase section */ 201 | 221518AE1CFC2E0500040369 /* Headers */ = { 202 | isa = PBXHeadersBuildPhase; 203 | buildActionMask = 2147483647; 204 | files = ( 205 | 221518F41CFC2EEE00040369 /* VectorArithmetic.h in Headers */, 206 | ); 207 | runOnlyForDeploymentPostprocessing = 0; 208 | }; 209 | 221518BC1CFC2E0D00040369 /* Headers */ = { 210 | isa = PBXHeadersBuildPhase; 211 | buildActionMask = 2147483647; 212 | files = ( 213 | 221518F51CFC2EEF00040369 /* VectorArithmetic.h in Headers */, 214 | ); 215 | runOnlyForDeploymentPostprocessing = 0; 216 | }; 217 | /* End PBXHeadersBuildPhase section */ 218 | 219 | /* Begin PBXNativeTarget section */ 220 | 221518B01CFC2E0500040369 /* OSX-VectorArithmetic */ = { 221 | isa = PBXNativeTarget; 222 | buildConfigurationList = 221518B71CFC2E0500040369 /* Build configuration list for PBXNativeTarget "OSX-VectorArithmetic" */; 223 | buildPhases = ( 224 | 221518AC1CFC2E0500040369 /* Sources */, 225 | 221518AD1CFC2E0500040369 /* Frameworks */, 226 | 221518AE1CFC2E0500040369 /* Headers */, 227 | 221518AF1CFC2E0500040369 /* Resources */, 228 | ); 229 | buildRules = ( 230 | ); 231 | dependencies = ( 232 | ); 233 | name = "OSX-VectorArithmetic"; 234 | productName = "OSX-VectorArithmetic"; 235 | productReference = 221518B11CFC2E0500040369 /* VectorArithmetic.framework */; 236 | productType = "com.apple.product-type.framework"; 237 | }; 238 | 221518BE1CFC2E0D00040369 /* iOS-VectorArithmetic */ = { 239 | isa = PBXNativeTarget; 240 | buildConfigurationList = 221518C41CFC2E0D00040369 /* Build configuration list for PBXNativeTarget "iOS-VectorArithmetic" */; 241 | buildPhases = ( 242 | 221518BA1CFC2E0D00040369 /* Sources */, 243 | 221518BB1CFC2E0D00040369 /* Frameworks */, 244 | 221518BC1CFC2E0D00040369 /* Headers */, 245 | 221518BD1CFC2E0D00040369 /* Resources */, 246 | ); 247 | buildRules = ( 248 | ); 249 | dependencies = ( 250 | ); 251 | name = "iOS-VectorArithmetic"; 252 | productName = "iOS-VectorArithmetic"; 253 | productReference = 221518BF1CFC2E0D00040369 /* VectorArithmetic.framework */; 254 | productType = "com.apple.product-type.framework"; 255 | }; 256 | 221518CA1CFC2E1E00040369 /* OSX-VectorArithmeticTests */ = { 257 | isa = PBXNativeTarget; 258 | buildConfigurationList = 221518D31CFC2E1E00040369 /* Build configuration list for PBXNativeTarget "OSX-VectorArithmeticTests" */; 259 | buildPhases = ( 260 | 221518C71CFC2E1E00040369 /* Sources */, 261 | 221518C81CFC2E1E00040369 /* Frameworks */, 262 | 221518C91CFC2E1E00040369 /* Resources */, 263 | ); 264 | buildRules = ( 265 | ); 266 | dependencies = ( 267 | 221518D21CFC2E1E00040369 /* PBXTargetDependency */, 268 | ); 269 | name = "OSX-VectorArithmeticTests"; 270 | productName = "OSX-VectorArithmeticTests"; 271 | productReference = 221518CB1CFC2E1E00040369 /* OSX-VectorArithmeticTests.xctest */; 272 | productType = "com.apple.product-type.bundle.unit-test"; 273 | }; 274 | 221518D91CFC2E9F00040369 /* iOS-VectorArithmeticTests */ = { 275 | isa = PBXNativeTarget; 276 | buildConfigurationList = 221518E21CFC2E9F00040369 /* Build configuration list for PBXNativeTarget "iOS-VectorArithmeticTests" */; 277 | buildPhases = ( 278 | 221518D61CFC2E9F00040369 /* Sources */, 279 | 221518D71CFC2E9F00040369 /* Frameworks */, 280 | 221518D81CFC2E9F00040369 /* Resources */, 281 | ); 282 | buildRules = ( 283 | ); 284 | dependencies = ( 285 | 221518E11CFC2E9F00040369 /* PBXTargetDependency */, 286 | ); 287 | name = "iOS-VectorArithmeticTests"; 288 | productName = "iOS-VectorArithmeticTests"; 289 | productReference = 221518DA1CFC2E9F00040369 /* iOS-VectorArithmeticTests.xctest */; 290 | productType = "com.apple.product-type.bundle.unit-test"; 291 | }; 292 | /* End PBXNativeTarget section */ 293 | 294 | /* Begin PBXProject section */ 295 | 221518A61CFC2DEB00040369 /* Project object */ = { 296 | isa = PBXProject; 297 | attributes = { 298 | LastSwiftUpdateCheck = 0730; 299 | LastUpgradeCheck = 0730; 300 | TargetAttributes = { 301 | 221518B01CFC2E0500040369 = { 302 | CreatedOnToolsVersion = 7.3.1; 303 | }; 304 | 221518BE1CFC2E0D00040369 = { 305 | CreatedOnToolsVersion = 7.3.1; 306 | }; 307 | 221518CA1CFC2E1E00040369 = { 308 | CreatedOnToolsVersion = 7.3.1; 309 | }; 310 | 221518D91CFC2E9F00040369 = { 311 | CreatedOnToolsVersion = 7.3.1; 312 | }; 313 | }; 314 | }; 315 | buildConfigurationList = 221518A91CFC2DEB00040369 /* Build configuration list for PBXProject "VectorArithmetic" */; 316 | compatibilityVersion = "Xcode 3.2"; 317 | developmentRegion = English; 318 | hasScannedForEncodings = 0; 319 | knownRegions = ( 320 | en, 321 | ); 322 | mainGroup = 221518A51CFC2DEB00040369; 323 | productRefGroup = 221518B21CFC2E0500040369 /* Products */; 324 | projectDirPath = ""; 325 | projectRoot = ""; 326 | targets = ( 327 | 221518B01CFC2E0500040369 /* OSX-VectorArithmetic */, 328 | 221518BE1CFC2E0D00040369 /* iOS-VectorArithmetic */, 329 | 221518CA1CFC2E1E00040369 /* OSX-VectorArithmeticTests */, 330 | 221518D91CFC2E9F00040369 /* iOS-VectorArithmeticTests */, 331 | ); 332 | }; 333 | /* End PBXProject section */ 334 | 335 | /* Begin PBXResourcesBuildPhase section */ 336 | 221518AF1CFC2E0500040369 /* Resources */ = { 337 | isa = PBXResourcesBuildPhase; 338 | buildActionMask = 2147483647; 339 | files = ( 340 | ); 341 | runOnlyForDeploymentPostprocessing = 0; 342 | }; 343 | 221518BD1CFC2E0D00040369 /* Resources */ = { 344 | isa = PBXResourcesBuildPhase; 345 | buildActionMask = 2147483647; 346 | files = ( 347 | ); 348 | runOnlyForDeploymentPostprocessing = 0; 349 | }; 350 | 221518C91CFC2E1E00040369 /* Resources */ = { 351 | isa = PBXResourcesBuildPhase; 352 | buildActionMask = 2147483647; 353 | files = ( 354 | ); 355 | runOnlyForDeploymentPostprocessing = 0; 356 | }; 357 | 221518D81CFC2E9F00040369 /* Resources */ = { 358 | isa = PBXResourcesBuildPhase; 359 | buildActionMask = 2147483647; 360 | files = ( 361 | ); 362 | runOnlyForDeploymentPostprocessing = 0; 363 | }; 364 | /* End PBXResourcesBuildPhase section */ 365 | 366 | /* Begin PBXSourcesBuildPhase section */ 367 | 221518AC1CFC2E0500040369 /* Sources */ = { 368 | isa = PBXSourcesBuildPhase; 369 | buildActionMask = 2147483647; 370 | files = ( 371 | 221519081CFC309200040369 /* VectorArithmetic.swift in Sources */, 372 | ); 373 | runOnlyForDeploymentPostprocessing = 0; 374 | }; 375 | 221518BA1CFC2E0D00040369 /* Sources */ = { 376 | isa = PBXSourcesBuildPhase; 377 | buildActionMask = 2147483647; 378 | files = ( 379 | 221519091CFC309200040369 /* VectorArithmetic.swift in Sources */, 380 | ); 381 | runOnlyForDeploymentPostprocessing = 0; 382 | }; 383 | 221518C71CFC2E1E00040369 /* Sources */ = { 384 | isa = PBXSourcesBuildPhase; 385 | buildActionMask = 2147483647; 386 | files = ( 387 | 221518FC1CFC302200040369 /* TestProtocol.swift in Sources */, 388 | 221518FE1CFC302200040369 /* TestsGenericMathFunctions.swift in Sources */, 389 | 221519041CFC302200040369 /* TestsMathFunctions.swift in Sources */, 390 | 221519061CFC302200040369 /* TestsOperators.swift in Sources */, 391 | 221519021CFC302200040369 /* TestsInitializerVectorOperatable.swift in Sources */, 392 | 221519001CFC302200040369 /* TestsGenericOperators.swift in Sources */, 393 | ); 394 | runOnlyForDeploymentPostprocessing = 0; 395 | }; 396 | 221518D61CFC2E9F00040369 /* Sources */ = { 397 | isa = PBXSourcesBuildPhase; 398 | buildActionMask = 2147483647; 399 | files = ( 400 | 221518FD1CFC302200040369 /* TestProtocol.swift in Sources */, 401 | 221518FF1CFC302200040369 /* TestsGenericMathFunctions.swift in Sources */, 402 | 221519051CFC302200040369 /* TestsMathFunctions.swift in Sources */, 403 | 221519071CFC302200040369 /* TestsOperators.swift in Sources */, 404 | 221519031CFC302200040369 /* TestsInitializerVectorOperatable.swift in Sources */, 405 | 221519011CFC302200040369 /* TestsGenericOperators.swift in Sources */, 406 | ); 407 | runOnlyForDeploymentPostprocessing = 0; 408 | }; 409 | /* End PBXSourcesBuildPhase section */ 410 | 411 | /* Begin PBXTargetDependency section */ 412 | 221518D21CFC2E1E00040369 /* PBXTargetDependency */ = { 413 | isa = PBXTargetDependency; 414 | target = 221518B01CFC2E0500040369 /* OSX-VectorArithmetic */; 415 | targetProxy = 221518D11CFC2E1E00040369 /* PBXContainerItemProxy */; 416 | }; 417 | 221518E11CFC2E9F00040369 /* PBXTargetDependency */ = { 418 | isa = PBXTargetDependency; 419 | target = 221518BE1CFC2E0D00040369 /* iOS-VectorArithmetic */; 420 | targetProxy = 221518E01CFC2E9F00040369 /* PBXContainerItemProxy */; 421 | }; 422 | /* End PBXTargetDependency section */ 423 | 424 | /* Begin XCBuildConfiguration section */ 425 | 221518AA1CFC2DEB00040369 /* Debug */ = { 426 | isa = XCBuildConfiguration; 427 | buildSettings = { 428 | }; 429 | name = Debug; 430 | }; 431 | 221518AB1CFC2DEB00040369 /* Release */ = { 432 | isa = XCBuildConfiguration; 433 | buildSettings = { 434 | }; 435 | name = Release; 436 | }; 437 | 221518B81CFC2E0500040369 /* Debug */ = { 438 | isa = XCBuildConfiguration; 439 | buildSettings = { 440 | ALWAYS_SEARCH_USER_PATHS = NO; 441 | CLANG_ANALYZER_NONNULL = YES; 442 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 443 | CLANG_CXX_LIBRARY = "libc++"; 444 | CLANG_ENABLE_MODULES = YES; 445 | CLANG_ENABLE_OBJC_ARC = YES; 446 | CLANG_WARN_BOOL_CONVERSION = YES; 447 | CLANG_WARN_CONSTANT_CONVERSION = YES; 448 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 449 | CLANG_WARN_EMPTY_BODY = YES; 450 | CLANG_WARN_ENUM_CONVERSION = YES; 451 | CLANG_WARN_INT_CONVERSION = YES; 452 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 453 | CLANG_WARN_UNREACHABLE_CODE = YES; 454 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 455 | CODE_SIGN_IDENTITY = "-"; 456 | COMBINE_HIDPI_IMAGES = YES; 457 | COPY_PHASE_STRIP = NO; 458 | CURRENT_PROJECT_VERSION = 1; 459 | DEBUG_INFORMATION_FORMAT = dwarf; 460 | DEFINES_MODULE = YES; 461 | DYLIB_COMPATIBILITY_VERSION = 1; 462 | DYLIB_CURRENT_VERSION = 1; 463 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 464 | ENABLE_STRICT_OBJC_MSGSEND = YES; 465 | ENABLE_TESTABILITY = YES; 466 | FRAMEWORK_VERSION = A; 467 | GCC_C_LANGUAGE_STANDARD = gnu99; 468 | GCC_DYNAMIC_NO_PIC = NO; 469 | GCC_NO_COMMON_BLOCKS = YES; 470 | GCC_OPTIMIZATION_LEVEL = 0; 471 | GCC_PREPROCESSOR_DEFINITIONS = ( 472 | "DEBUG=1", 473 | "$(inherited)", 474 | ); 475 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 476 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 477 | GCC_WARN_UNDECLARED_SELECTOR = YES; 478 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 479 | GCC_WARN_UNUSED_FUNCTION = YES; 480 | GCC_WARN_UNUSED_VARIABLE = YES; 481 | INFOPLIST_FILE = "$(SRCROOT)/Source/Info.plist"; 482 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 483 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/Frameworks"; 484 | MACOSX_DEPLOYMENT_TARGET = 10.11; 485 | MTL_ENABLE_DEBUG_INFO = YES; 486 | ONLY_ACTIVE_ARCH = YES; 487 | PRODUCT_BUNDLE_IDENTIFIER = "com.seivanheidari.OSX-VectorArithmetic"; 488 | PRODUCT_NAME = VectorArithmetic; 489 | SDKROOT = macosx; 490 | SKIP_INSTALL = YES; 491 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 492 | VERSIONING_SYSTEM = "apple-generic"; 493 | VERSION_INFO_PREFIX = ""; 494 | }; 495 | name = Debug; 496 | }; 497 | 221518B91CFC2E0500040369 /* Release */ = { 498 | isa = XCBuildConfiguration; 499 | buildSettings = { 500 | ALWAYS_SEARCH_USER_PATHS = NO; 501 | CLANG_ANALYZER_NONNULL = YES; 502 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 503 | CLANG_CXX_LIBRARY = "libc++"; 504 | CLANG_ENABLE_MODULES = YES; 505 | CLANG_ENABLE_OBJC_ARC = YES; 506 | CLANG_WARN_BOOL_CONVERSION = YES; 507 | CLANG_WARN_CONSTANT_CONVERSION = YES; 508 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 509 | CLANG_WARN_EMPTY_BODY = YES; 510 | CLANG_WARN_ENUM_CONVERSION = YES; 511 | CLANG_WARN_INT_CONVERSION = YES; 512 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 513 | CLANG_WARN_UNREACHABLE_CODE = YES; 514 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 515 | CODE_SIGN_IDENTITY = "-"; 516 | COMBINE_HIDPI_IMAGES = YES; 517 | COPY_PHASE_STRIP = NO; 518 | CURRENT_PROJECT_VERSION = 1; 519 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 520 | DEFINES_MODULE = YES; 521 | DYLIB_COMPATIBILITY_VERSION = 1; 522 | DYLIB_CURRENT_VERSION = 1; 523 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 524 | ENABLE_NS_ASSERTIONS = NO; 525 | ENABLE_STRICT_OBJC_MSGSEND = YES; 526 | FRAMEWORK_VERSION = A; 527 | GCC_C_LANGUAGE_STANDARD = gnu99; 528 | GCC_NO_COMMON_BLOCKS = YES; 529 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 530 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 531 | GCC_WARN_UNDECLARED_SELECTOR = YES; 532 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 533 | GCC_WARN_UNUSED_FUNCTION = YES; 534 | GCC_WARN_UNUSED_VARIABLE = YES; 535 | INFOPLIST_FILE = "$(SRCROOT)/Source/Info.plist"; 536 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 537 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/Frameworks"; 538 | MACOSX_DEPLOYMENT_TARGET = 10.11; 539 | MTL_ENABLE_DEBUG_INFO = NO; 540 | PRODUCT_BUNDLE_IDENTIFIER = "com.seivanheidari.OSX-VectorArithmetic"; 541 | PRODUCT_NAME = VectorArithmetic; 542 | SDKROOT = macosx; 543 | SKIP_INSTALL = YES; 544 | VERSIONING_SYSTEM = "apple-generic"; 545 | VERSION_INFO_PREFIX = ""; 546 | }; 547 | name = Release; 548 | }; 549 | 221518C51CFC2E0D00040369 /* Debug */ = { 550 | isa = XCBuildConfiguration; 551 | buildSettings = { 552 | ALWAYS_SEARCH_USER_PATHS = NO; 553 | CLANG_ANALYZER_NONNULL = YES; 554 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 555 | CLANG_CXX_LIBRARY = "libc++"; 556 | CLANG_ENABLE_MODULES = YES; 557 | CLANG_ENABLE_OBJC_ARC = YES; 558 | CLANG_WARN_BOOL_CONVERSION = YES; 559 | CLANG_WARN_CONSTANT_CONVERSION = YES; 560 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 561 | CLANG_WARN_EMPTY_BODY = YES; 562 | CLANG_WARN_ENUM_CONVERSION = YES; 563 | CLANG_WARN_INT_CONVERSION = YES; 564 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 565 | CLANG_WARN_UNREACHABLE_CODE = YES; 566 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 567 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; 568 | COPY_PHASE_STRIP = NO; 569 | CURRENT_PROJECT_VERSION = 1; 570 | DEBUG_INFORMATION_FORMAT = dwarf; 571 | DEFINES_MODULE = YES; 572 | DYLIB_COMPATIBILITY_VERSION = 1; 573 | DYLIB_CURRENT_VERSION = 1; 574 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 575 | ENABLE_STRICT_OBJC_MSGSEND = YES; 576 | ENABLE_TESTABILITY = YES; 577 | GCC_C_LANGUAGE_STANDARD = gnu99; 578 | GCC_DYNAMIC_NO_PIC = NO; 579 | GCC_NO_COMMON_BLOCKS = YES; 580 | GCC_OPTIMIZATION_LEVEL = 0; 581 | GCC_PREPROCESSOR_DEFINITIONS = ( 582 | "DEBUG=1", 583 | "$(inherited)", 584 | ); 585 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 586 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 587 | GCC_WARN_UNDECLARED_SELECTOR = YES; 588 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 589 | GCC_WARN_UNUSED_FUNCTION = YES; 590 | GCC_WARN_UNUSED_VARIABLE = YES; 591 | INFOPLIST_FILE = "$(SRCROOT)/Source/Info.plist"; 592 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 593 | IPHONEOS_DEPLOYMENT_TARGET = 9.3; 594 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 595 | MTL_ENABLE_DEBUG_INFO = YES; 596 | ONLY_ACTIVE_ARCH = YES; 597 | PRODUCT_BUNDLE_IDENTIFIER = "com.seivanheidari.iOS-VectorArithmetic"; 598 | PRODUCT_NAME = VectorArithmetic; 599 | SDKROOT = iphoneos; 600 | SKIP_INSTALL = YES; 601 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 602 | TARGETED_DEVICE_FAMILY = "1,2"; 603 | VERSIONING_SYSTEM = "apple-generic"; 604 | VERSION_INFO_PREFIX = ""; 605 | }; 606 | name = Debug; 607 | }; 608 | 221518C61CFC2E0D00040369 /* Release */ = { 609 | isa = XCBuildConfiguration; 610 | buildSettings = { 611 | ALWAYS_SEARCH_USER_PATHS = NO; 612 | CLANG_ANALYZER_NONNULL = YES; 613 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 614 | CLANG_CXX_LIBRARY = "libc++"; 615 | CLANG_ENABLE_MODULES = YES; 616 | CLANG_ENABLE_OBJC_ARC = YES; 617 | CLANG_WARN_BOOL_CONVERSION = YES; 618 | CLANG_WARN_CONSTANT_CONVERSION = YES; 619 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 620 | CLANG_WARN_EMPTY_BODY = YES; 621 | CLANG_WARN_ENUM_CONVERSION = YES; 622 | CLANG_WARN_INT_CONVERSION = YES; 623 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 624 | CLANG_WARN_UNREACHABLE_CODE = YES; 625 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 626 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; 627 | COPY_PHASE_STRIP = NO; 628 | CURRENT_PROJECT_VERSION = 1; 629 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 630 | DEFINES_MODULE = YES; 631 | DYLIB_COMPATIBILITY_VERSION = 1; 632 | DYLIB_CURRENT_VERSION = 1; 633 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 634 | ENABLE_NS_ASSERTIONS = NO; 635 | ENABLE_STRICT_OBJC_MSGSEND = YES; 636 | GCC_C_LANGUAGE_STANDARD = gnu99; 637 | GCC_NO_COMMON_BLOCKS = YES; 638 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 639 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 640 | GCC_WARN_UNDECLARED_SELECTOR = YES; 641 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 642 | GCC_WARN_UNUSED_FUNCTION = YES; 643 | GCC_WARN_UNUSED_VARIABLE = YES; 644 | INFOPLIST_FILE = "$(SRCROOT)/Source/Info.plist"; 645 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 646 | IPHONEOS_DEPLOYMENT_TARGET = 9.3; 647 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 648 | MTL_ENABLE_DEBUG_INFO = NO; 649 | PRODUCT_BUNDLE_IDENTIFIER = "com.seivanheidari.iOS-VectorArithmetic"; 650 | PRODUCT_NAME = VectorArithmetic; 651 | SDKROOT = iphoneos; 652 | SKIP_INSTALL = YES; 653 | TARGETED_DEVICE_FAMILY = "1,2"; 654 | VALIDATE_PRODUCT = YES; 655 | VERSIONING_SYSTEM = "apple-generic"; 656 | VERSION_INFO_PREFIX = ""; 657 | }; 658 | name = Release; 659 | }; 660 | 221518D41CFC2E1E00040369 /* Debug */ = { 661 | isa = XCBuildConfiguration; 662 | buildSettings = { 663 | ALWAYS_SEARCH_USER_PATHS = NO; 664 | CLANG_ANALYZER_NONNULL = YES; 665 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 666 | CLANG_CXX_LIBRARY = "libc++"; 667 | CLANG_ENABLE_MODULES = YES; 668 | CLANG_ENABLE_OBJC_ARC = YES; 669 | CLANG_WARN_BOOL_CONVERSION = YES; 670 | CLANG_WARN_CONSTANT_CONVERSION = YES; 671 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 672 | CLANG_WARN_EMPTY_BODY = YES; 673 | CLANG_WARN_ENUM_CONVERSION = YES; 674 | CLANG_WARN_INT_CONVERSION = YES; 675 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 676 | CLANG_WARN_UNREACHABLE_CODE = YES; 677 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 678 | CODE_SIGN_IDENTITY = "-"; 679 | COMBINE_HIDPI_IMAGES = YES; 680 | COPY_PHASE_STRIP = NO; 681 | DEBUG_INFORMATION_FORMAT = dwarf; 682 | ENABLE_STRICT_OBJC_MSGSEND = YES; 683 | ENABLE_TESTABILITY = YES; 684 | GCC_C_LANGUAGE_STANDARD = gnu99; 685 | GCC_DYNAMIC_NO_PIC = NO; 686 | GCC_NO_COMMON_BLOCKS = YES; 687 | GCC_OPTIMIZATION_LEVEL = 0; 688 | GCC_PREPROCESSOR_DEFINITIONS = ( 689 | "DEBUG=1", 690 | "$(inherited)", 691 | ); 692 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 693 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 694 | GCC_WARN_UNDECLARED_SELECTOR = YES; 695 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 696 | GCC_WARN_UNUSED_FUNCTION = YES; 697 | GCC_WARN_UNUSED_VARIABLE = YES; 698 | INFOPLIST_FILE = Tests/InfoTests.plist; 699 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks"; 700 | MACOSX_DEPLOYMENT_TARGET = 10.11; 701 | MTL_ENABLE_DEBUG_INFO = YES; 702 | ONLY_ACTIVE_ARCH = YES; 703 | PRODUCT_BUNDLE_IDENTIFIER = "com.seivanheidari.OSX-VectorArithmeticTests"; 704 | PRODUCT_NAME = "$(TARGET_NAME)"; 705 | SDKROOT = macosx; 706 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 707 | }; 708 | name = Debug; 709 | }; 710 | 221518D51CFC2E1E00040369 /* Release */ = { 711 | isa = XCBuildConfiguration; 712 | buildSettings = { 713 | ALWAYS_SEARCH_USER_PATHS = NO; 714 | CLANG_ANALYZER_NONNULL = YES; 715 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 716 | CLANG_CXX_LIBRARY = "libc++"; 717 | CLANG_ENABLE_MODULES = YES; 718 | CLANG_ENABLE_OBJC_ARC = YES; 719 | CLANG_WARN_BOOL_CONVERSION = YES; 720 | CLANG_WARN_CONSTANT_CONVERSION = YES; 721 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 722 | CLANG_WARN_EMPTY_BODY = YES; 723 | CLANG_WARN_ENUM_CONVERSION = YES; 724 | CLANG_WARN_INT_CONVERSION = YES; 725 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 726 | CLANG_WARN_UNREACHABLE_CODE = YES; 727 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 728 | CODE_SIGN_IDENTITY = "-"; 729 | COMBINE_HIDPI_IMAGES = YES; 730 | COPY_PHASE_STRIP = NO; 731 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 732 | ENABLE_NS_ASSERTIONS = NO; 733 | ENABLE_STRICT_OBJC_MSGSEND = YES; 734 | GCC_C_LANGUAGE_STANDARD = gnu99; 735 | GCC_NO_COMMON_BLOCKS = YES; 736 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 737 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 738 | GCC_WARN_UNDECLARED_SELECTOR = YES; 739 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 740 | GCC_WARN_UNUSED_FUNCTION = YES; 741 | GCC_WARN_UNUSED_VARIABLE = YES; 742 | INFOPLIST_FILE = Tests/InfoTests.plist; 743 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks"; 744 | MACOSX_DEPLOYMENT_TARGET = 10.11; 745 | MTL_ENABLE_DEBUG_INFO = NO; 746 | PRODUCT_BUNDLE_IDENTIFIER = "com.seivanheidari.OSX-VectorArithmeticTests"; 747 | PRODUCT_NAME = "$(TARGET_NAME)"; 748 | SDKROOT = macosx; 749 | }; 750 | name = Release; 751 | }; 752 | 221518E31CFC2E9F00040369 /* Debug */ = { 753 | isa = XCBuildConfiguration; 754 | buildSettings = { 755 | ALWAYS_SEARCH_USER_PATHS = NO; 756 | CLANG_ANALYZER_NONNULL = YES; 757 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 758 | CLANG_CXX_LIBRARY = "libc++"; 759 | CLANG_ENABLE_MODULES = YES; 760 | CLANG_ENABLE_OBJC_ARC = YES; 761 | CLANG_WARN_BOOL_CONVERSION = YES; 762 | CLANG_WARN_CONSTANT_CONVERSION = YES; 763 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 764 | CLANG_WARN_EMPTY_BODY = YES; 765 | CLANG_WARN_ENUM_CONVERSION = YES; 766 | CLANG_WARN_INT_CONVERSION = YES; 767 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 768 | CLANG_WARN_UNREACHABLE_CODE = YES; 769 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 770 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; 771 | COPY_PHASE_STRIP = NO; 772 | DEBUG_INFORMATION_FORMAT = dwarf; 773 | ENABLE_STRICT_OBJC_MSGSEND = YES; 774 | ENABLE_TESTABILITY = YES; 775 | GCC_C_LANGUAGE_STANDARD = gnu99; 776 | GCC_DYNAMIC_NO_PIC = NO; 777 | GCC_NO_COMMON_BLOCKS = YES; 778 | GCC_OPTIMIZATION_LEVEL = 0; 779 | GCC_PREPROCESSOR_DEFINITIONS = ( 780 | "DEBUG=1", 781 | "$(inherited)", 782 | ); 783 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 784 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 785 | GCC_WARN_UNDECLARED_SELECTOR = YES; 786 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 787 | GCC_WARN_UNUSED_FUNCTION = YES; 788 | GCC_WARN_UNUSED_VARIABLE = YES; 789 | INFOPLIST_FILE = Tests/InfoTests.plist; 790 | IPHONEOS_DEPLOYMENT_TARGET = 9.3; 791 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 792 | MTL_ENABLE_DEBUG_INFO = YES; 793 | ONLY_ACTIVE_ARCH = YES; 794 | PRODUCT_BUNDLE_IDENTIFIER = "com.seivanheidari.iOS-VectorArithmeticTests"; 795 | PRODUCT_NAME = "$(TARGET_NAME)"; 796 | SDKROOT = iphoneos; 797 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 798 | }; 799 | name = Debug; 800 | }; 801 | 221518E41CFC2E9F00040369 /* Release */ = { 802 | isa = XCBuildConfiguration; 803 | buildSettings = { 804 | ALWAYS_SEARCH_USER_PATHS = NO; 805 | CLANG_ANALYZER_NONNULL = YES; 806 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 807 | CLANG_CXX_LIBRARY = "libc++"; 808 | CLANG_ENABLE_MODULES = YES; 809 | CLANG_ENABLE_OBJC_ARC = YES; 810 | CLANG_WARN_BOOL_CONVERSION = YES; 811 | CLANG_WARN_CONSTANT_CONVERSION = YES; 812 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 813 | CLANG_WARN_EMPTY_BODY = YES; 814 | CLANG_WARN_ENUM_CONVERSION = YES; 815 | CLANG_WARN_INT_CONVERSION = YES; 816 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 817 | CLANG_WARN_UNREACHABLE_CODE = YES; 818 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 819 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; 820 | COPY_PHASE_STRIP = NO; 821 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 822 | ENABLE_NS_ASSERTIONS = NO; 823 | ENABLE_STRICT_OBJC_MSGSEND = YES; 824 | GCC_C_LANGUAGE_STANDARD = gnu99; 825 | GCC_NO_COMMON_BLOCKS = YES; 826 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 827 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 828 | GCC_WARN_UNDECLARED_SELECTOR = YES; 829 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 830 | GCC_WARN_UNUSED_FUNCTION = YES; 831 | GCC_WARN_UNUSED_VARIABLE = YES; 832 | INFOPLIST_FILE = Tests/InfoTests.plist; 833 | IPHONEOS_DEPLOYMENT_TARGET = 9.3; 834 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 835 | MTL_ENABLE_DEBUG_INFO = NO; 836 | PRODUCT_BUNDLE_IDENTIFIER = "com.seivanheidari.iOS-VectorArithmeticTests"; 837 | PRODUCT_NAME = "$(TARGET_NAME)"; 838 | SDKROOT = iphoneos; 839 | VALIDATE_PRODUCT = YES; 840 | }; 841 | name = Release; 842 | }; 843 | /* End XCBuildConfiguration section */ 844 | 845 | /* Begin XCConfigurationList section */ 846 | 221518A91CFC2DEB00040369 /* Build configuration list for PBXProject "VectorArithmetic" */ = { 847 | isa = XCConfigurationList; 848 | buildConfigurations = ( 849 | 221518AA1CFC2DEB00040369 /* Debug */, 850 | 221518AB1CFC2DEB00040369 /* Release */, 851 | ); 852 | defaultConfigurationIsVisible = 0; 853 | defaultConfigurationName = Release; 854 | }; 855 | 221518B71CFC2E0500040369 /* Build configuration list for PBXNativeTarget "OSX-VectorArithmetic" */ = { 856 | isa = XCConfigurationList; 857 | buildConfigurations = ( 858 | 221518B81CFC2E0500040369 /* Debug */, 859 | 221518B91CFC2E0500040369 /* Release */, 860 | ); 861 | defaultConfigurationIsVisible = 0; 862 | defaultConfigurationName = Release; 863 | }; 864 | 221518C41CFC2E0D00040369 /* Build configuration list for PBXNativeTarget "iOS-VectorArithmetic" */ = { 865 | isa = XCConfigurationList; 866 | buildConfigurations = ( 867 | 221518C51CFC2E0D00040369 /* Debug */, 868 | 221518C61CFC2E0D00040369 /* Release */, 869 | ); 870 | defaultConfigurationIsVisible = 0; 871 | defaultConfigurationName = Release; 872 | }; 873 | 221518D31CFC2E1E00040369 /* Build configuration list for PBXNativeTarget "OSX-VectorArithmeticTests" */ = { 874 | isa = XCConfigurationList; 875 | buildConfigurations = ( 876 | 221518D41CFC2E1E00040369 /* Debug */, 877 | 221518D51CFC2E1E00040369 /* Release */, 878 | ); 879 | defaultConfigurationIsVisible = 0; 880 | defaultConfigurationName = Release; 881 | }; 882 | 221518E21CFC2E9F00040369 /* Build configuration list for PBXNativeTarget "iOS-VectorArithmeticTests" */ = { 883 | isa = XCConfigurationList; 884 | buildConfigurations = ( 885 | 221518E31CFC2E9F00040369 /* Debug */, 886 | 221518E41CFC2E9F00040369 /* Release */, 887 | ); 888 | defaultConfigurationIsVisible = 0; 889 | defaultConfigurationName = Release; 890 | }; 891 | /* End XCConfigurationList section */ 892 | }; 893 | rootObject = 221518A61CFC2DEB00040369 /* Project object */; 894 | } 895 | --------------------------------------------------------------------------------