@aws-amplify/react-native 1.0.0

package/ios/JKBigInteger/JKBigDecimal.m

@@ -0,0 +1,224 @@
+//
+//  JKBigDecimal.m
+//  JKBigInteger
+//
+//  Created by Midfar Sun on 5/4/15.
+//  Copyright (c) 2015 Midfar Sun. All rights reserved.
+//
+
+// Licensed under the MIT License
+
+#import "JKBigDecimal.h"
+
+@implementation JKBigDecimal
+@synthesize bigInteger, figure;
+
++ (BOOL)supportsSecureCoding {
+    return YES;
+}
+
+- (id)init
+{
+    return [self initWithString:@"0"];
+}
+
+- (id)initWithString:(NSString *)string
+{
+    self = [super init];
+    if (self) {
+        figure = 0;
+        if ([string containsString:@"."]) {
+            NSRange range = [string rangeOfString:@"."];
+            figure = string.length-range.location-range.length;
+            string = [string stringByReplacingCharactersInRange:range withString:@""];
+        }
+        bigInteger = [[JKBigInteger alloc] initWithString:string];
+    }
+    return self;
+}
+
++ (id)decimalWithString:(NSString *)string
+{
+    return [[JKBigDecimal alloc] initWithString:string];
+}
+
+-(id)initWithBigInteger:(JKBigInteger *)i figure:(NSInteger)f
+{
+    self = [super init];
+    if (self) {
+        bigInteger = i;
+        figure = f;
+    }
+    return self;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)decoder
+{
+    self = [super init];
+    if (self) {
+        bigInteger = [[JKBigInteger alloc] initWithCoder:decoder];
+        figure = [decoder decodeInt32ForKey:@"JKBigDecimalFigure"];
+    }
+    return self;
+}
+-(void)encodeWithCoder:(NSCoder *)encoder
+{
+    [bigInteger encodeWithCoder:encoder];
+    [encoder encodeInteger:figure forKey:@"JKBigDecimalFigure"];
+}
+
+- (id)add:(JKBigDecimal *)bigDecimal
+{
+    NSInteger maxFigure = 0;
+    if (figure>=bigDecimal.figure) {
+        maxFigure = figure;
+        NSInteger exponent = maxFigure-bigDecimal.figure;
+        JKBigInteger *mInteger = [[JKBigInteger alloc] initWithString:@"10"];
+        JKBigInteger *newInteger = [mInteger pow:(unsigned int)exponent];
+        bigDecimal.bigInteger = [bigDecimal.bigInteger multiply:newInteger];
+        bigDecimal.figure = maxFigure;
+        
+    }else{
+        maxFigure = bigDecimal.figure;
+        NSInteger exponent = maxFigure-figure;
+        JKBigInteger *mInteger = [[JKBigInteger alloc] initWithString:@"10"];
+        JKBigInteger *newInteger = [mInteger pow:(unsigned int)exponent];
+        bigInteger = [bigInteger multiply:newInteger];
+        figure = maxFigure;
+        
+    }
+    JKBigInteger *newBigInteger = [bigInteger add:bigDecimal.bigInteger];
+    JKBigDecimal *newBigDecimal = [[JKBigDecimal alloc] initWithBigInteger:newBigInteger figure:maxFigure];
+    return newBigDecimal;
+}
+
+- (id)subtract:(JKBigDecimal *)bigDecimal
+{
+    NSInteger maxFigure = 0;
+    if (figure>=bigDecimal.figure) {
+        maxFigure = figure;
+        NSInteger exponent = maxFigure-bigDecimal.figure;
+        JKBigInteger *mInteger = [[JKBigInteger alloc] initWithString:@"10"];
+        JKBigInteger *newInteger = [mInteger pow:(unsigned int)exponent];
+        bigDecimal.bigInteger = [bigDecimal.bigInteger multiply:newInteger];
+        bigDecimal.figure = maxFigure;
+        
+    }else{
+        maxFigure = bigDecimal.figure;
+        NSInteger exponent = maxFigure-figure;
+        JKBigInteger *mInteger = [[JKBigInteger alloc] initWithString:@"10"];
+        JKBigInteger *newInteger = [mInteger pow:(unsigned int)exponent];
+        bigInteger = [bigDecimal.bigInteger multiply:newInteger];
+        figure = maxFigure;
+        
+    }
+    JKBigInteger *newBigInteger = [bigInteger subtract:bigDecimal.bigInteger];
+    JKBigDecimal *newBigDecimal = [[JKBigDecimal alloc] initWithBigInteger:newBigInteger figure:maxFigure];
+    return newBigDecimal;
+}
+
+- (id)multiply:(JKBigDecimal *)bigDecimal
+{
+    NSInteger totalFigure = figure+bigDecimal.figure;
+    JKBigInteger *newBigInteger = [bigInteger multiply:bigDecimal.bigInteger];
+    JKBigDecimal *newBigDecimal = [[JKBigDecimal alloc] initWithBigInteger:newBigInteger figure:totalFigure];
+    return newBigDecimal;
+}
+
+- (id)divide:(JKBigDecimal *)bigDecimal
+{
+    NSInteger totalFigure = figure-bigDecimal.figure;
+    if (totalFigure<0) {
+        NSInteger exponent = -totalFigure;
+        totalFigure=0;
+        JKBigInteger *mInteger = [[JKBigInteger alloc] initWithString:@"10"];
+        JKBigInteger *newInteger = [mInteger pow:(unsigned int)exponent];
+        bigInteger = [bigInteger multiply:newInteger];
+    }
+    JKBigInteger *newBigInteger = [bigInteger divide:bigDecimal.bigInteger];
+    JKBigDecimal *newBigDecimal = [[JKBigDecimal alloc] initWithBigInteger:newBigInteger figure:totalFigure];
+    return newBigDecimal;
+}
+
+- (id)remainder:(JKBigDecimal *)bigDecimal
+{
+    NSInteger totalFigure = figure-bigDecimal.figure;
+    if (totalFigure<0) {
+        NSInteger exponent = -totalFigure;
+        totalFigure=0;
+        JKBigInteger *mInteger = [[JKBigInteger alloc] initWithString:@"10"];
+        JKBigInteger *newInteger = [mInteger pow:(unsigned int)exponent];
+        bigInteger = [bigInteger multiply:newInteger];
+    }
+    JKBigInteger *newBigInteger = [bigInteger remainder:bigDecimal.bigInteger];
+    JKBigDecimal *newBigDecimal = [[JKBigDecimal alloc] initWithBigInteger:newBigInteger figure:bigDecimal.figure];
+    return newBigDecimal;
+}
+
+//- (NSArray *)divideAndRemainder:(JKBigDecimal *)bigInteger
+//{
+//    
+//}
+
+-(NSComparisonResult) compare:(JKBigDecimal *)other {
+    JKBigDecimal *tens = [[JKBigDecimal alloc] initWithString:@"10"];
+    JKBigInteger *scaledNum;
+    JKBigInteger *scaledCompareTo;
+    
+    if (figure > other.figure){
+        tens = [tens pow:(int)figure];
+    } else {
+        tens = [tens pow:(int)other.figure];
+    }
+    //scale my value to integer value
+    scaledNum = [[JKBigInteger alloc] initWithString:[[self multiply:tens] stringValue]];
+    //scale other value to integer
+    scaledCompareTo = [[JKBigInteger alloc] initWithString:[[other multiply:tens] stringValue]];
+    NSComparisonResult compareBigInteger = [scaledNum compare:scaledCompareTo];
+    return compareBigInteger;
+}
+
+- (id)pow:(unsigned int)exponent
+{
+    NSInteger totalFigure = figure*exponent;
+    JKBigInteger *newBigInteger = [bigInteger pow:exponent];
+    JKBigDecimal *newBigDecimal = [[JKBigDecimal alloc] initWithBigInteger:newBigInteger figure:totalFigure];
+    return newBigDecimal;
+}
+
+- (id)negate
+{
+    JKBigInteger *newBigInteger = [bigInteger negate];
+    JKBigDecimal *newBigDecimal = [[JKBigDecimal alloc] initWithBigInteger:newBigInteger figure:figure];
+    return newBigDecimal;
+}
+
+- (id)abs
+{
+    JKBigInteger *newBigInteger = [bigInteger abs];
+    JKBigDecimal *newBigDecimal = [[JKBigDecimal alloc] initWithBigInteger:newBigInteger figure:figure];
+    return newBigDecimal;
+}
+
+- (NSString *)stringValue
+{
+    NSString *string = [bigInteger stringValue];
+    if (figure==0) {
+        return string;
+    }
+    NSMutableString *mString = [NSMutableString stringWithString:string];
+    NSInteger newFigure = string.length-figure;
+    while (newFigure<=0) {
+        [mString insertString:@"0" atIndex:0];
+        newFigure++;
+    }
+    [mString insertString:@"." atIndex:newFigure];
+    return mString;
+}
+
+- (NSString *)description
+{
+    return [self stringValue];
+}
+
+@end

package/ios/JKBigInteger/JKBigInteger.h

@@ -0,0 +1,58 @@
+//
+//  JKBigInteger.h
+//  JKBigInteger
+//
+//  Created by Jānis Kiršteins on 5/21/13.
+//  Copyright (c) 2013 Jānis Kiršteins. All rights reserved.
+//
+
+// Licensed under the MIT License
+
+#import <Foundation/Foundation.h>
+#include "tommath.h"
+
+@interface JKBigInteger : NSObject <NSSecureCoding>
+
+- (id)initWithValue:(mp_int *)value;
+- (mp_int *)value;
+
+- (id)initWithUnsignedLong:(unsigned long)ul;
+- (id)initWithString:(NSString *)string;
+- (id)initWithString:(NSString *)string andRadix:(int)radix;
+- (id)initWithCString:(char *)cString;
+- (id)initWithCString:(char *)cString andRadix:(int)radix;
+
+- (id)add:(JKBigInteger *)bigInteger;
+- (id)subtract:(JKBigInteger *)bigInteger;
+- (id)multiply:(JKBigInteger *)bigInteger;
+- (id)divide:(JKBigInteger *)bigInteger;
+
+- (id)remainder:(JKBigInteger *)bigInteger;
+- (NSArray *)divideAndRemainder:(JKBigInteger *)bigInteger;
+
+- (id)pow:(unsigned int)exponent;
+- (id)pow:(JKBigInteger*)exponent andMod:(JKBigInteger*)modulus;
+- (id)negate;
+- (id)abs;
+
+- (id)bitwiseXor:(JKBigInteger *)bigInteger;
+- (id)bitwiseOr:(JKBigInteger *)bigInteger;
+- (id)bitwiseAnd:(JKBigInteger *)bigInteger;
+- (id)shiftLeft:(unsigned int)n;
+- (id)shiftRight:(unsigned int)n;
+
+- (id)gcd:(JKBigInteger *)bigInteger;
+
+- (NSComparisonResult) compare:(JKBigInteger *)bigInteger;
+
+- (unsigned long)unsignedIntValue;
+- (NSString *)stringValue;
+- (NSString *)stringValueWithRadix:(int)radix;
+
+- (NSString *)description;
+
+- (unsigned int)countBytes;
+- (void)toByteArraySigned: (unsigned char*) byteArray;
+- (void)toByteArrayUnsigned: (unsigned char*) byteArray;
+
+@end

package/ios/JKBigInteger/JKBigInteger.m

@@ -0,0 +1,419 @@
+//
+//  JKBigInteger.m
+//  JKBigInteger
+//
+//  Created by Jānis Kiršteins on 5/21/13.
+//  Copyright (c) 2013 Jānis Kiršteins. All rights reserved.
+//
+
+// Licensed under the MIT License
+
+#import "JKBigInteger.h"
+
+@implementation JKBigInteger {
+@private
+    mp_int m_value;
+}
+
++ (BOOL)supportsSecureCoding {
+    return YES;
+}
+
+- (id)initWithValue:(mp_int *)value {
+
+    self = [super init];
+	
+    if (self) {
+        mp_init_copy(&m_value, value);
+    }
+    
+    return self;
+}
+
+- (mp_int *)value {
+    return &m_value;
+}
+
+- (id)initWithUnsignedLong:(unsigned long)unsignedLong {
+
+    self = [super init];
+    
+    if (self) {
+        mp_set_int(&m_value, unsignedLong);
+    }
+    
+    return self;
+}
+
+- (id)init {
+    return [self initWithUnsignedLong:0];
+}
+
+- (id)initWithCString:(char *)cString andRadix:(int)radix {
+
+    if (radix < 2 || radix > 64) {
+        return nil;
+    }
+    
+    self = [super init];
+    
+    if (self) {
+        mp_init(&m_value);
+        int result;
+        result = mp_read_radix(&m_value, cString, radix);
+        
+        if (result != MP_OKAY) {
+            mp_clear(&m_value);
+            return nil;
+        }
+    }
+    
+    return self;
+}
+- (id)initWithCString:(char *)cString {
+    
+    int radix = 10;
+    return [self initWithCString:cString andRadix:radix];
+}
+
+- (id)initWithString:(NSString *)string andRadix:(int)radix {
+    return [self initWithCString:(char *)[string UTF8String] andRadix:radix];
+}
+
+- (id)initWithString:(NSString *)string {
+
+    int radix = 10;
+    return [self initWithCString:(char *)[string UTF8String] andRadix:radix];
+}
+
+- (id)initWithCoder:(NSCoder *)decoder {
+
+    self = [super init];
+    
+    if (self) {
+		int sign = [decoder decodeInt32ForKey:@"JKBigIntegerSign"];
+		int alloc = [decoder decodeInt32ForKey:@"JKBigIntegerAlloc"];
+
+		mp_init_size(&m_value, alloc);
+		
+        NSData *data = (NSData *)[decoder decodeObjectOfClass:[NSData class] forKey:@"JKBigIntegerDP"];
+        mp_digit *temp = (mp_digit *)[data bytes];
+        
+        for (unsigned int i = 0; i < alloc; ++i) {
+			m_value.dp[i] = temp[i];
+		}
+		
+		m_value.used = alloc;
+		m_value.sign = sign;
+    }
+
+    return self;
+}
+- (void)encodeWithCoder:(NSCoder *)encoder {
+
+    mp_clamp(&m_value);
+
+    NSData *data = [NSData dataWithBytes:(const void *)m_value.dp
+                                  length:m_value.alloc * sizeof(mp_digit)];
+
+    [encoder encodeObject:data forKey:@"JKBigIntegerDP"];
+    [encoder encodeInteger:m_value.alloc forKey:@"JKBigIntegerAlloc"];
+    [encoder encodeInteger:m_value.sign forKey:@"JKBigIntegerSign"];
+}
+
+- (id)add:(JKBigInteger *)bigInteger {
+
+    mp_int sum;
+    mp_init(&sum);
+    
+    mp_add(&m_value, [bigInteger value], &sum);
+    
+    id newBigInteger = [[JKBigInteger alloc] initWithValue:&sum];
+    mp_clear(&sum);
+    
+    return newBigInteger;
+}
+
+- (id)subtract:(JKBigInteger *)bigInteger {
+
+    mp_int difference;
+    mp_init(&difference);
+    
+    mp_sub(&m_value, [bigInteger value], &difference);
+    
+    id newBigInteger = [[JKBigInteger alloc] initWithValue:&difference];
+    mp_clear(&difference);
+    
+    return newBigInteger;
+}
+
+- (id)multiply:(JKBigInteger *)bigInteger {
+
+    mp_int product;
+    mp_init(&product);
+    
+    mp_mul(&m_value, [bigInteger value], &product);
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&product];
+    mp_clear(&product);
+    
+    return newBigInteger;
+}
+
+- (id)divide:(JKBigInteger *)bigInteger {
+
+    int result;
+    mp_int quotient;
+    mp_init(&quotient);
+    
+    result = mp_div(&m_value, [bigInteger value], &quotient, NULL);
+    if (result == MP_VAL) {
+        mp_clear(&quotient);
+        return nil;
+    }
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&quotient];
+    mp_clear(&quotient);
+    
+    return newBigInteger;
+}
+
+- (id)remainder:(JKBigInteger *)bigInteger {
+
+    int result;
+    mp_int remainder;
+    mp_init(&remainder);
+    
+    result = mp_div(&m_value, [bigInteger value], NULL, &remainder);
+    if (result == MP_VAL) {
+        mp_clear(&remainder);
+        return nil;
+    }
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&remainder];
+    mp_clear(&remainder);
+    
+    return newBigInteger;
+}
+
+- (NSArray *)divideAndRemainder:(JKBigInteger *)bigInteger {
+
+    int result;
+    mp_int quotient, remainder;
+    mp_init_multi(&quotient, &remainder, NULL);
+    
+    result = mp_div(&m_value, [bigInteger value], &quotient, &remainder);
+    if (result == MP_VAL) {
+        mp_clear_multi(&quotient, &remainder, NULL);
+        return nil;
+    }
+    
+    JKBigInteger *quotientBigInteger = [[JKBigInteger alloc] initWithValue:&quotient];
+    JKBigInteger *remainderBigInteger = [[JKBigInteger alloc] initWithValue:&remainder];
+    mp_clear_multi(&quotient, &remainder, NULL);
+    
+    return @[quotientBigInteger, remainderBigInteger];
+}
+
+- (id)pow:(unsigned int)exponent {
+
+    int result;
+    mp_int power;
+    mp_init(&power);
+    
+    result = mp_expt_d(&m_value, (mp_digit)exponent, &power);
+    if (result == MP_VAL) {
+        mp_clear(&power);
+        return nil;
+    }
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&power];
+    mp_clear(&power);
+    
+    return newBigInteger;
+}
+
+- (id)pow:(JKBigInteger*)exponent andMod: (JKBigInteger*)modulus {
+
+    int result;
+    mp_int output;
+    mp_init(&output);
+    
+    result = mp_exptmod(&m_value, &exponent->m_value, &modulus->m_value, &output);
+    if (result == MP_VAL) {
+        mp_clear(&output);
+        return nil;
+    }
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&output];
+    mp_clear(&output);
+    
+    return newBigInteger;
+}
+
+- (id)negate {
+
+    mp_int negate;
+    mp_init(&negate);
+    mp_neg(&m_value, &negate);
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&negate];
+    mp_clear(&negate);
+    
+    return newBigInteger;
+}
+
+- (id)abs {
+
+    mp_int absolute;
+    mp_init(&absolute);
+    mp_abs(&m_value, &absolute);
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&absolute];
+    mp_clear(&absolute);
+    
+    return newBigInteger;
+}
+
+- (id)bitwiseXor:(JKBigInteger *)bigInteger {
+
+    mp_int xor;
+    mp_init(&xor);
+    mp_xor(&m_value, [bigInteger value], &xor);
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&xor];
+    mp_clear(&xor);
+    
+    return newBigInteger;
+}
+
+- (id)bitwiseOr:(JKBigInteger *)bigInteger {
+
+    mp_int or;
+    mp_init(&or);
+    mp_or(&m_value, [bigInteger value], &or);
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&or];
+    mp_clear(&or);
+    
+    return newBigInteger;
+}
+
+- (id)bitwiseAnd:(JKBigInteger *)bigInteger {
+
+    mp_int and;
+    mp_init(&and);
+    mp_and(&m_value, [bigInteger value], &and);
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&and];
+    mp_clear(&and);
+    
+    return newBigInteger;
+}
+
+- (id)shiftLeft:(unsigned int)n {
+
+    mp_int lShift;
+    mp_init(&lShift);
+	mp_mul_2d(&m_value, n, &lShift);
+	
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&lShift];
+    mp_clear(&lShift);
+    
+    return newBigInteger;
+}
+
+- (id)shiftRight:(unsigned int)n {
+
+    mp_int rShift;
+    mp_init(&rShift);
+    mp_div_2d(&m_value, n, &rShift, NULL);
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&rShift];
+    mp_clear(&rShift);
+    
+    return newBigInteger;
+}
+- (id)gcd:(JKBigInteger *)bigInteger {
+
+    int result;
+    mp_int gcd;
+    mp_init(&gcd);
+    
+    result = mp_gcd(&m_value, [bigInteger value], &gcd);
+    if (result == MP_VAL) {
+        mp_clear(&gcd);
+        return nil;
+    }
+    
+    JKBigInteger *newBigInteger = [[JKBigInteger alloc] initWithValue:&gcd];
+    mp_clear(&gcd);
+    
+    return newBigInteger;
+}
+
+- (NSComparisonResult) compare:(JKBigInteger *)bigInteger {
+
+    NSComparisonResult comparisonResult;
+    comparisonResult = mp_cmp([bigInteger value], &m_value);
+    
+    switch (comparisonResult) {
+        case MP_GT:
+            return NSOrderedAscending;
+        case MP_EQ:
+            return NSOrderedSame;
+        case MP_LT:
+            return NSOrderedDescending;
+        default:
+            return 0;
+    }
+}
+
+- (unsigned long)unsignedIntValue {
+    return mp_get_int(&m_value);
+}
+
+- (NSString *)stringValue {
+
+    int radix = 10;
+    return [self stringValueWithRadix:radix];
+}
+
+- (NSString *)stringValueWithRadix:(int)radix {
+
+    int stringSize;
+    mp_radix_size(&m_value, radix, &stringSize);
+    char cString[stringSize];
+    mp_toradix(&m_value, cString, radix);
+    
+    for (int i = 0; i < stringSize; ++i) {
+        cString[i] = (char)tolower(cString[i]);
+    }
+    
+    return [NSString stringWithUTF8String:cString];
+}
+
+- (NSString *)description {
+    return [self stringValue];
+}
+
+- (void)dealloc {
+    mp_clear(&m_value);
+}
+
+/* Returns the number of bytes required to store this JKBigInteger as binary */
+- (unsigned int)countBytes {
+    return (unsigned int) mp_unsigned_bin_size(&m_value);
+}
+
+/* Retrieves the signed [big endian] format of this JKBigInteger */
+- (void)toByteArraySigned: (unsigned char*) byteArray {
+    mp_to_signed_bin(&m_value, byteArray);
+}
+
+/* Retrieves the unsigned [big endian] format of this JKBigInteger */
+- (void)toByteArrayUnsigned: (unsigned char*) byteArray {
+    mp_to_unsigned_bin(&m_value, byteArray);
+}
+
+@end

package/ios/JKBigInteger/LICENSE.txt

@@ -0,0 +1,18 @@
+Copyright (C) 2013 Jānis Kiršteins
+
+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.