initial commit

8 files changed, 729 insertions, 0 deletions

diff --git a/app/src/main/java/com/a404m/calculator/MainActivity.kt b/app/src/main/java/com/a404m/calculator/MainActivity.kt
new file mode 100644
index 0000000..9a40e9b
--- /dev/null
+++ b/app/src/main/java/com/a404m/calculator/MainActivity.kt
@@ -0,0 +1,27 @@
+package com.a404m.calculator
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import com.a404m.calculator.ui.page.HomePage
+import com.a404m.calculator.ui.theme.CalculatorTheme
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        setContent {
+            CalculatorTheme {
+                HomePage()
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/a404m/calculator/MathHelper.kt b/app/src/main/java/com/a404m/calculator/MathHelper.kt
new file mode 100644
index 0000000..fa6cfc7
--- /dev/null
+++ b/app/src/main/java/com/a404m/calculator/MathHelper.kt
@@ -0,0 +1,309 @@
+package com.a404m.calculator
+
+import android.util.Log
+import com.a404m.calculator.MathHelper.Operator.Kind
+import java.nio.charset.UnsupportedCharsetException
+
+object MathHelper {
+    private val operatorStrings = arrayOf(
+        '+',
+        '-',
+        '×',
+        '÷',
+        '%',
+    )
+    private val numberStrings = arrayOf(
+        '0',
+        '1',
+        '2',
+        '3',
+        '4',
+        '5',
+        '6',
+        '7',
+        '8',
+        '9',
+        '.',
+    )
+
+    private val plus = Operator(
+        '+',
+        Kind.PREFIX,
+        {
+            Operand(it.first().value)
+        }
+    )
+    private val minus = Operator(
+        '-',
+        Kind.PREFIX,
+        {
+            Operand(-it.first().value)
+        }
+    )
+    private val add = Operator(
+        '+',
+        Kind.INFIX,
+        {
+            Operand(it.first().value+it.last().value)
+        }
+    )
+    private val sub = Operator(
+        '-',
+        Kind.INFIX,
+        {
+            Operand(it.first().value-it.last().value)
+        }
+    )
+    private val mul = Operator(
+        '×',
+        Kind.INFIX,
+        {
+            Operand(it.first().value*it.last().value)
+        }
+    )
+    private val div = Operator(
+        '÷',
+        Kind.INFIX,
+        {
+            Operand(it.first().value/it.last().value)
+        }
+    )
+    private val rem = Operator(
+        '%',
+        Kind.INFIX,
+        {
+            Operand(it.first().value%it.last().value)
+        }
+    )
+    private val operatorOrders = arrayOf(
+        arrayOf(
+            plus,
+            minus,
+        ),
+        arrayOf(
+            mul,
+            div,
+            rem,
+        ),
+        arrayOf(
+            add,
+            sub,
+        )
+    )
+    private val operators = arrayOf(
+        plus,
+        minus,
+        add,
+        sub,
+        mul,
+        div,
+        rem,
+    )
+
+    fun eval(expression: String): String {
+        return try {
+            parse(lex(expression)).eval().toString()
+        } catch (e: Exception) {
+            e.message ?: "Exception"
+        }
+    }
+
+    private fun parse(lexed: ArrayList<Any>): Operator {
+        for (order in operatorOrders) {
+            if (lexed.size == 1) {
+                break
+            }
+            for (i in lexed.indices) {
+                val item = lexed[i]
+                if (item is BasicOperator) {
+                    var op = item.toOperator(
+                        lexed,
+                        i
+                    )
+                    if (op in order) {
+                        op = op.cloneWithoutOperands()
+                        Log.d(
+                            "A404M",
+                            "parse: $op"
+                        )
+                        lexed[i] = op
+                        when (op.kind) {
+                            Kind.NONE -> {}
+                            Kind.INFIX -> {
+                                op.operands.add(lexed.removeAt(i - 1))
+                                op.operands.add(lexed.removeAt(i))
+                            }
+
+                            Kind.PREFIX -> {
+                                op.operands.add(lexed.removeAt(i + 1))
+                            }
+
+                            Kind.POSTFIX -> {
+                                op.operands.add(lexed.removeAt(i - 1))
+                            }
+                        }
+                        break
+                    }
+                }
+            }
+        }
+        return if (lexed.size != 1) {
+            throw UnsupportedOperationException("lexed.size = ${lexed.size}: $lexed")
+        } else if (lexed.first() is Operator) {
+            lexed.first() as Operator
+        } else if (lexed.first() is Operand) {
+            plus.cloneWithoutOperands().cloneWithOperator(arrayListOf(lexed.first()))
+        } else {
+            throw UnsupportedOperationException("unsupported type ${lexed.first().javaClass}")
+        }
+    }
+
+    private fun lex(expression: String): ArrayList<Any> {
+        val items = arrayListOf<Any>()
+
+        var i = 0
+        while (i < expression.length) {
+            when (val c = expression[i]) {
+                in numberStrings -> {
+                    val start = i
+                    while (++i < expression.length && expression[i] in numberStrings);
+                    items.add(
+                        Operand(
+                            value = expression.substring(
+                                start,
+                                i
+                            ).toDouble()
+                        )
+                    )
+                    --i
+                }
+
+                in operatorStrings -> {
+                    items.add(
+                        BasicOperator(c)
+                    )
+                }
+
+                else -> throw UnsupportedCharsetException(c.toString())
+            }
+            ++i
+        }
+
+        return items
+    }
+
+    private class Operator(
+        val operator: Char,
+        val kind: Kind,
+        val operate: (operands:List<Operand>)->Operand,
+        val operands: ArrayList<Any> = arrayListOf(),
+    ) {
+        fun cloneWithoutOperands():Operator{
+            return Operator(
+                operator,
+                kind,
+                operate,
+            )
+        }
+
+        fun cloneWithOperator(operands: ArrayList<Any>): Operator {
+            return Operator(
+                operator,
+                kind,
+                operate,
+                operands,
+            )
+        }
+
+        fun eval(): Operand {
+            Log.d(
+                "A404M",
+                "eval: $operator $operands"
+            )
+            if(operandSize() != operands.size){
+                throw UnsupportedOperationException("Not enough operands")
+            }
+
+            val evaledOperands = operands.map {
+                if(it is Operator){
+                    it.eval()
+                }else{
+                    it as Operand
+                }
+            }
+
+            return operate(evaledOperands)
+        }
+
+        fun operandSize(): Int {
+            return when (kind) {
+                Kind.INFIX -> 2
+                Kind.PREFIX, Kind.POSTFIX -> 1
+                Kind.NONE -> 0
+            }
+        }
+
+        override fun toString(): String {
+            return "$operator $kind $operands"
+        }
+
+        enum class Kind {
+            NONE,
+            INFIX,
+            PREFIX,
+            POSTFIX,
+        }
+    }
+
+    private class BasicOperator(
+        val operator: Char,
+    ) {
+        fun toOperator(
+            items: List<Any>,
+            i: Int
+        ): Operator {
+            val left = items.getOrElse(
+                i - 1,
+                { Any() },
+            ) is Operand
+
+            val right = items.getOrElse(
+                i + 1,
+                { Any() },
+            ) is Operand
+
+            val k:Kind
+
+            if (left) {
+                if (right) {
+                    k = Kind.INFIX
+                } else {
+                    k = Kind.POSTFIX
+                }
+            } else if (right) {
+                k = Kind.PREFIX
+            } else {
+                k = Kind.NONE
+            }
+
+            return operators.first {
+                it.operator == operator && it.kind == k
+            }
+        }
+
+        override fun toString(): String {
+            return operator.toString();
+        }
+    }
+
+    private class Operand(
+        val value: Double,
+    ){
+        override fun toString(): String {
+            if(value % 1 == 0.0){
+                return "%.0f".format(value)
+            }
+            return value.toString()
+        }
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/a404m/calculator/model/CalcButtonModel.kt b/app/src/main/java/com/a404m/calculator/model/CalcButtonModel.kt
new file mode 100644
index 0000000..435acef
--- /dev/null
+++ b/app/src/main/java/com/a404m/calculator/model/CalcButtonModel.kt
@@ -0,0 +1,139 @@
+package com.a404m.calculator.model
+
+import com.a404m.calculator.MathHelper
+
+data class CalcButtonModel(
+    val text: String,
+    val weight:Float = 1F,
+    val op: (expression: String) -> String,
+) {
+    companion object {
+        val K_0 = CalcButtonModel(
+            text = "0",
+            op = {
+                it + '0'
+            }
+        )
+        val K_1 = CalcButtonModel(
+            text = "1",
+            op = {
+                it + '1'
+            }
+        )
+        val K_2 = CalcButtonModel(
+            text = "2",
+            op = {
+                it + '2'
+            }
+        )
+        val K_3 = CalcButtonModel(
+            text = "3",
+            op = {
+                it + '3'
+            }
+        )
+        val K_4 = CalcButtonModel(
+            text = "4",
+            op = {
+                it + '4'
+            }
+        )
+        val K_5 = CalcButtonModel(
+            text = "5",
+            op = {
+                it + '5'
+            }
+        )
+        val K_6 = CalcButtonModel(
+            text = "6",
+            op = {
+                it + '6'
+            }
+        )
+        val K_7 = CalcButtonModel(
+            text = "7",
+            op = {
+                it + '7'
+            }
+        )
+        val K_8 = CalcButtonModel(
+            text = "8",
+            op = {
+                it + '8'
+            }
+        )
+        val K_9 = CalcButtonModel(
+            text = "9",
+            op = {
+                it + '9'
+            }
+        )
+        val K_PLUS = CalcButtonModel(
+            text = "+",
+            op = {
+                it + '+'
+            }
+        )
+        val K_MINUS = CalcButtonModel(
+            text = "-",
+            op = {
+                it + '-'
+            }
+        )
+        val K_MULTIPLY = CalcButtonModel(
+            text = "×",
+            op = {
+                it + '×'
+            }
+        )
+        val K_DIVISION = CalcButtonModel(
+            text = "÷",
+            op = {
+                it + '÷'
+            }
+        )
+        val K_REMINDER = CalcButtonModel(
+            text = "%",
+            op = {
+                it + '%'
+            }
+        )
+        val K_EQUAL = CalcButtonModel(
+            text = "=",
+            op = {
+                MathHelper.eval(it)
+            }
+        )
+        val K_DOT = CalcButtonModel(
+            text = ".",
+            op = {
+                it + '.'
+            }
+        )
+        val K_C = CalcButtonModel(
+            text = "C",
+            op = {
+                ""
+            }
+        )
+        val K_BACKSPACE = CalcButtonModel(
+            text = "⌫",
+            op = {
+                if (it.length <= 1) {
+                    ""
+                } else {
+                    it.substring(
+                        0,
+                        it.length - 1,
+                    )
+                }
+            }
+        )
+        val K_SWITCH_MODE = CalcButtonModel(
+            text = "\u2026",
+            op = {
+                it
+            }
+        )
+    }
+}
diff --git a/app/src/main/java/com/a404m/calculator/ui/page/Home.kt b/app/src/main/java/com/a404m/calculator/ui/page/Home.kt
new file mode 100644
index 0000000..ba9a21e
--- /dev/null
+++ b/app/src/main/java/com/a404m/calculator/ui/page/Home.kt
@@ -0,0 +1,120 @@
+package com.a404m.calculator.ui.page
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.contentColorFor
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.a404m.calculator.model.CalcButtonModel
+import com.a404m.calculator.ui.theme.CalculatorTheme
+import com.a404m.calculator.ui.util.CalcGrid
+
+@Composable
+fun HomePage(modifier: Modifier = Modifier) {
+    var expression by rememberSaveable {
+        mutableStateOf("")
+    }
+    Scaffold(
+        modifier = modifier,
+    ) { paddingValues ->
+        Column(
+            modifier = Modifier
+                .padding(paddingValues)
+                .fillMaxSize(),
+            verticalArrangement = Arrangement.Bottom,
+        ) {
+            Text(
+                modifier = Modifier.padding(8.dp).fillMaxWidth(),
+                text = expression,
+                style = MaterialTheme.typography.titleLarge,
+                textAlign = TextAlign.Right,
+                fontSize = 35.sp,
+            )
+            HorizontalDivider(modifier = Modifier.padding(horizontal = 4.dp))
+            CalcGrid(
+                modifier = Modifier
+                    .padding(4.dp),
+                columns = 4,
+                items = arrayOf(
+                    CalcButtonModel.K_C,
+                    CalcButtonModel.K_BACKSPACE,
+                    CalcButtonModel.K_REMINDER,
+                    CalcButtonModel.K_DIVISION,
+                    CalcButtonModel.K_7,
+                    CalcButtonModel.K_8,
+                    CalcButtonModel.K_9,
+                    CalcButtonModel.K_MULTIPLY,
+                    CalcButtonModel.K_4,
+                    CalcButtonModel.K_5,
+                    CalcButtonModel.K_6,
+                    CalcButtonModel.K_MINUS,
+                    CalcButtonModel.K_1,
+                    CalcButtonModel.K_2,
+                    CalcButtonModel.K_3,
+                    CalcButtonModel.K_PLUS,
+                    CalcButtonModel.K_0,
+                    CalcButtonModel.K_DOT,
+                    CalcButtonModel.K_SWITCH_MODE,
+                    CalcButtonModel.K_EQUAL,
+                ),
+            ) {
+                val backColor = MaterialTheme.colorScheme.primary
+                Box(
+                    modifier = Modifier
+                        .padding(4.dp)
+                        .height(70.dp)
+                        .weight(it.weight)
+                        .clip(
+                            shape = RoundedCornerShape(10.dp),
+                        )
+                        .background(
+                            color = backColor,
+                            shape = RoundedCornerShape(10.dp),
+                        )
+                        .clickable {
+                            expression = it.op(expression)
+                        },
+                    contentAlignment = Alignment.Center,
+                ) {
+                    Text(
+                        text = it.text,
+                        style = MaterialTheme.typography.titleLarge,
+                        color = MaterialTheme.colorScheme.contentColorFor(backColor)
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+private fun HomePagePreview() {
+    CalculatorTheme {
+        HomePage(
+            modifier = Modifier.fillMaxSize(),
+        )
+    }
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/a404m/calculator/ui/theme/Color.kt b/app/src/main/java/com/a404m/calculator/ui/theme/Color.kt
new file mode 100644
index 0000000..6a4fd22
--- /dev/null
+++ b/app/src/main/java/com/a404m/calculator/ui/theme/Color.kt
@@ -0,0 +1,11 @@
+package com.a404m.calculator.ui.theme
+
+import androidx.compose.ui.graphics.Color
+
+val Purple80 = Color(0xFFD0BCFF)
+val PurpleGrey80 = Color(0xFFCCC2DC)
+val Pink80 = Color(0xFFEFB8C8)
+
+val Purple40 = Color(0xFF6650a4)
+val PurpleGrey40 = Color(0xFF625b71)
+val Pink40 = Color(0xFF7D5260)
\ No newline at end of file
diff --git a/app/src/main/java/com/a404m/calculator/ui/theme/Theme.kt b/app/src/main/java/com/a404m/calculator/ui/theme/Theme.kt
new file mode 100644
index 0000000..20d6120
--- /dev/null
+++ b/app/src/main/java/com/a404m/calculator/ui/theme/Theme.kt
@@ -0,0 +1,58 @@
+package com.a404m.calculator.ui.theme
+
+import android.app.Activity
+import android.os.Build
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.dynamicDarkColorScheme
+import androidx.compose.material3.dynamicLightColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+
+private val DarkColorScheme = darkColorScheme(
+    primary = Purple80,
+    secondary = PurpleGrey80,
+    tertiary = Pink80
+)
+
+private val LightColorScheme = lightColorScheme(
+    primary = Purple40,
+    secondary = PurpleGrey40,
+    tertiary = Pink40
+
+    /* Other default colors to override
+    background = Color(0xFFFFFBFE),
+    surface = Color(0xFFFFFBFE),
+    onPrimary = Color.White,
+    onSecondary = Color.White,
+    onTertiary = Color.White,
+    onBackground = Color(0xFF1C1B1F),
+    onSurface = Color(0xFF1C1B1F),
+    */
+)
+
+@Composable
+fun CalculatorTheme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    // Dynamic color is available on Android 12+
+    dynamicColor: Boolean = true,
+    content: @Composable () -> Unit
+) {
+    val colorScheme = when {
+        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+            val context = LocalContext.current
+            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
+        }
+
+        darkTheme -> DarkColorScheme
+        else -> LightColorScheme
+    }
+
+    MaterialTheme(
+        colorScheme = colorScheme,
+        typography = Typography,
+        content = content
+    )
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/a404m/calculator/ui/theme/Type.kt b/app/src/main/java/com/a404m/calculator/ui/theme/Type.kt
new file mode 100644
index 0000000..42ec494
--- /dev/null
+++ b/app/src/main/java/com/a404m/calculator/ui/theme/Type.kt
@@ -0,0 +1,34 @@
+package com.a404m.calculator.ui.theme
+
+import androidx.compose.material3.Typography
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.sp
+
+// Set of Material typography styles to start with
+val Typography = Typography(
+    bodyLarge = TextStyle(
+        fontFamily = FontFamily.Default,
+        fontWeight = FontWeight.Normal,
+        fontSize = 16.sp,
+        lineHeight = 24.sp,
+        letterSpacing = 0.5.sp
+    )
+    /* Other default text styles to override
+    titleLarge = TextStyle(
+        fontFamily = FontFamily.Default,
+        fontWeight = FontWeight.Normal,
+        fontSize = 22.sp,
+        lineHeight = 28.sp,
+        letterSpacing = 0.sp
+    ),
+    labelSmall = TextStyle(
+        fontFamily = FontFamily.Default,
+        fontWeight = FontWeight.Medium,
+        fontSize = 11.sp,
+        lineHeight = 16.sp,
+        letterSpacing = 0.5.sp
+    )
+    */
+)
\ No newline at end of file
diff --git a/app/src/main/java/com/a404m/calculator/ui/util/Container.kt b/app/src/main/java/com/a404m/calculator/ui/util/Container.kt
new file mode 100644
index 0000000..ba27afe
--- /dev/null
+++ b/app/src/main/java/com/a404m/calculator/ui/util/Container.kt
@@ -0,0 +1,31 @@
+package com.a404m.calculator.ui.util
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@Composable
+fun <T> CalcGrid(
+    modifier: Modifier = Modifier,
+    columns: Int,
+    items: Array<T>,
+    builder: @Composable (T) -> Unit,
+) {
+    Column(
+        modifier = modifier,
+    ) {
+        var index = 0
+        while (index != items.size) {
+            Row {
+                for (j in 0 until columns) {
+                    if(index == items.size){
+                        break
+                    }
+                    builder(items[index])
+                    ++index
+                }
+            }
+        }
+    }
+}
\ No newline at end of file